[z]Java代理(jdk静态代理、动态代理和cglib动态代理)

一、代理是Java常用的设计模式，代理类通过调用被代理类的相关方法，并对相关方法进行增强。加入一些非业务性代码，比如事务、日志、报警发邮件等操作。

二、jdk静态代理

1、业务接口

1 2 3 4 5 6 7 8 9 10 11 12 13

/**  * 业务接口  * @author pc  *  */ public interface UserService {           // 增加一个用户     public void addUser();     // 编辑账户     public void editUser();   }

2、业务实现类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

/**  * 业务实现类  * @author pc  *  */ public class UserServiceImpl implements UserService {       public void addUser() {         System.out.println("增加一个用户。。。");     }       public void editUser() {         System.out.println("编辑一个用户。。。");     }   }

3、代理类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

/**  * 代理类  *  * @author pc  *  */ public class UserServiceProxy implements UserService {       private UserServiceImpl userImpl;       public UserServiceProxy(UserServiceImpl countImpl) {         this.userImpl = countImpl;     }       public void addUser() {         System.out.println("代理类方法，进行了增强。。。");         System.out.println("事务开始。。。");         // 调用委托类的方法;         userImpl.addUser();         System.out.println("处理结束。。。");     }       public void editUser() {         System.out.println("代理类方法，进行了增强。。。");         System.out.println("事务开始。。。");         // 调用委托类的方法;         userImpl.editUser();         System.out.println("事务结束。。。");     }   }

　　

4、测试类

1 2 3 4 5 6 7

public static void main(String[] args) {     UserServiceImpl userImpl = new UserServiceImpl();     UserServiceProxy proxy = new UserServiceProxy(userImpl);     proxy.addUser();     System.out.println("----------分割线----------");     proxy.editUser(); }

5、结果

1 2 3 4 5 6 7 8 9

代理类方法，进行了增强。。。 事务开始。。。 增加一个用户。。。 处理结束。。。 ----------分割线---------- 代理类方法，进行了增强。。。 事务开始。。。 编辑一个用户。。。 事务结束。。。

　　

三、jdk动态代理

1、业务接口

1 2 3 4 5 6 7 8 9 10 11 12 13

/**  * 业务接口  * @author pc  *  */ public interface UserService {           // 增加一个用户     public void addUser();     // 编辑账户     public void editUser();   }

2、业务接口实现类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

/**  * 业务接口实现类  * @author pc  *  */ public class UserServiceImpl implements UserService {       public void addUser() {         System.out.println("增加一个用户。。。");     }       public void editUser() {         System.out.println("编辑一个用户。。。");     } }

3、代理类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;   /**  *  * @author pc  *  */ public class ServiceInvocationHandler implements InvocationHandler {       // 目标对象     private Object target;       public ServiceInvocationHandler(Object target) {         super();         this.target = target;     }       /**      * 创建代理实例      * @return      * @throws Throwable      */     public Object getProxy() throws Throwable {         return Proxy.newProxyInstance(Thread.currentThread()                 .getContextClassLoader(), this.target.getClass()                 .getInterfaces(), this);         // 这样写只返回了目标对象，没有生成代理对象。         // return target;     }       /**      * 实现InvocationHandler接口方法      * 执行目标对象的方法，并进行增强      */     public Object invoke(Object proxy, Method method, Object[] args)             throws Throwable {         Object result = null;         System.out.println("代理类方法，进行了增强。。。");         System.out.println("事务开始。。。");         // 执行目标方法对象         result = method.invoke(target, args);         System.out.println("事务结束。。。");         return result;     }   }

　　

4、测试类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public class Test {     /**      * jdk动态代理会生成一个动态代理类，生成相应的字节码，然后通过ClassLoader加载字节码。      * 该实例继承了Proxy类，并实现了业务接口，在实现的方法里通过反射调用了InvocationHandler接口实现类      * 的invoke()回调方法。      * @param args      * @throws Throwable      */     public static void main(String[] args) throws Throwable {         UserService userService = new UserServiceImpl();         ServiceInvocationHandler handler = new ServiceInvocationHandler(userService);         // 根据目标生成代理对象         UserService proxy = (UserService) handler.getProxy();         proxy.addUser(); //      proxy.editUser();       }   }

5、测试结果

1 2 3 4

代理类方法，进行了增强。。。 事务开始。。。 增加一个用户。。。 事务结束。。。

　　

四、cglib动态代理

需要引入cglib的jar包，

在pom.xml加入依赖：

1 2 3 4 5 6

<!-- https://mvnrepository.com/artifact/cglib/cglib --> <dependency>     <groupId>cglib</groupId>     <artifactId>cglib</artifactId>     <version>2.2.2</version> </dependency>

　　

1、业务类，没有实现接口

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

/**  * 业务类  * 没有实现接口  * 如果类是final的，则没法生成代理对象，报错。  * 如果方法是final的，代理无效  * @author pc  *  */ public class UserServiceImpl {       public void addUser() {         System.out.println("增加一个用户。。。");     }       public void editUser() {         System.out.println("编辑一个用户。。。");     } }

2、代理类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

import java.lang.reflect.Method;   import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy;   /**  * 使用Cglib动态代理  * @author pc  *  */ public class UserServiceCglib implements MethodInterceptor{       private Object target;           /**      * 创建代理实例      * @param target      * @return      */     public Object getInstance(Object target){         this.target = target;         Enhancer enhancer = new Enhancer();         enhancer.setSuperclass(this.target.getClass());         // 设置回调方法         enhancer.setCallback(this);         // 创建代理对象         return enhancer.create();     }           /**      * 实现MethodInterceptor接口要重写的方法。      * 回调方法      */     public Object intercept(Object obj, Method method, Object[] args,             MethodProxy proxy) throws Throwable {         System.out.println("事务开始。。。");            Object result = proxy.invokeSuper(obj, args);            System.out.println("事务结束。。。");            return result;        }   }

　　

3、测试类

1 2 3 4 5 6 7 8 9

public class TestCglib {       public static void main(String[] args) {         UserServiceCglib cglib = new UserServiceCglib();         UserServiceImpl bookFacadeImpl = (UserServiceImpl)cglib.getInstance(new UserServiceImpl());         bookFacadeImpl.addUser(); //      bookFacadeImpl.editUser();     } }

4、结果：

1 2 3

事务开始。。。 增加一个用户。。。 事务结束。。。

5、如果业务实现类被定义成final类，就会报以下错误

1 2 3 4 5 6 7 8

Exception in thread "main" java.lang.IllegalArgumentException: Cannot subclass final class class cn.xx.xx.cgilb.UserServiceImpl     at net.sf.cglib.proxy.Enhancer.generateClass(Enhancer.java:446)     at net.sf.cglib.core.DefaultGeneratorStrategy.generate(DefaultGeneratorStrategy.java:25)     at net.sf.cglib.core.AbstractClassGenerator.create(AbstractClassGenerator.java:216)     at net.sf.cglib.proxy.Enhancer.createHelper(Enhancer.java:377)     at net.sf.cglib.proxy.Enhancer.create(Enhancer.java:285)     at cn.pconline.proxy.cgilb.UserServiceCglib.getInstance(UserServiceCglib.java:30)     at cn.pconline.proxy.cgilb.TestCglib.main(TestCglib.java:7)

五、总结

1、原理

   jdk静态代理实现比较简单，一般是直接代理对象直接包装了被代理对象。

　 jdk动态代理是接口代理，被代理类A需要实现业务接口，业务代理类B需要实现InvocationHandler接口。

    jdk动态代理会根据被代理对象生成一个继承了Proxy类，并实现了该业务接口的jdk代理类，该类的字节码会被传进去的ClassLoader加载，创建了jdk代理对象实例，

   jdk代理对象实例在创建时，业务代理对象实例会被赋值给Proxy类，jdk代理对象实例也就有了业务代理对象实例，同时jdk代理对象实例通过反射根据被代理类的业务方法创建了相应的Method对象m（可能有多个）。当jdk代理对象实例调用业务方法，如proxy.addUser();这个会先把对应的m对象作为参数传给invoke()方法（就是invoke方法的第二个参数），调用了jdk代理对象实例的invoke()回调方法，在invoke方法里面再通过反射来调用被代理对象的因为方法，即result = method.invoke(target, args);。

  cglib动态代理是继承代理，通过ASM字节码框架修改字节码生成新的子类，重写并增强方法的功能。

2、优缺点

     jdk静态代理类只能为一个被代理类服务，如果需要代理的类比较多，那么会产生过多的代理类。jdk静态代理在编译时产生class文件，运行时无需产生，可直接使用，效率好。

     jdk动态代理必须实现接口，通过反射来动态代理方法，消耗系统性能。但是无需产生过多的代理类，避免了重复代码的产生，系统更加灵活。

     cglib动态代理无需实现接口，通过生成子类字节码来实现，比反射快一点，没有性能问题。但是由于cglib会继承被代理类，需要重写被代理方法，所以被代理类不能是final类，被代理方法不能是final。

因此，cglib的应用更加广泛一点。

参考：http://blog.csdn.net/fighterandknight/article/details/51200470

http://blog.csdn.net/jiankunking/article/details/52143504