2017.5.1 java动态代理总结

参考来自：http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html

1.代理模式

 代理类和委托类有相同接口。
 代理类负责为委托类：预处理消息
                  过滤消息
                  把消息转发给委托类
                  事后处理消息等
 代理类和委托类会相关联。
 代理类不真正实现服务，而是通过调用委托类的相关方法，来提供服务。

2.代理的分类

 静态代理：由程序员创建，或者由特定工具自动生成源代码，再对其编译。在运行之前，代理类的.class文件就存在了。
 动态代理：在程序运行时，根据java的反射机制动态创建。
　　3 jdk动态代理：委托类必须实现接口。
　　4 Cglib动态代理：委托类不用实现接口，针对类。

2.1 静态代理

（1）实例

 public interface Count {
     // 查看账户方法
     public void queryCount();
     // 修改账户方法
     public void updateCount();
 }  

 public class CountImpl implements Count {  

     @Override
     public void queryCount() {
         System.out.println("查看账户方法...");
     }  

     @Override
     public void updateCount() {
         System.out.println("修改账户方法...");
     }
 }  

创建一个代理类，可以看到CountProxy和CountImpl实现了同样的接口：Count。

 public class CountProxy implements Count {
     private CountImpl countImpl;  

     /**
      * 覆盖默认构造器
      *
      * @param countImpl
      */
     public CountProxy(CountImpl countImpl) {
         this.countImpl = countImpl;
     }  

     @Override
     public void queryCount() {
         System.out.println("事务处理之前");
         // 调用委托类的方法;
         countImpl.queryCount(); 
         System.out.println("事务处理之后");
     }  

     @Override
     public void updateCount() {
         System.out.println("事务处理之前");
         // 调用委托类的方法;
         countImpl.updateCount(); 
         System.out.println("事务处理之后");
     }  

 }  

（2）测试

由测试可知，采用constructor关联起来的proxy和impl，必须是1对1的，十分低效。

 public class TestCount {
     public static void main(String[] args) {
         CountImpl countImpl = new CountImpl();
         CountProxy countProxy = new CountProxy(countImpl);
         countProxy.updateCount();
         countProxy.queryCount();
     }
 } 

显然，通过上面的代码可以知道，这样的代理类只能为一个接口服务，会产生过多的代理类。而且所有的代理类中除了调用的方法不一样，其他操作都一样，重复代码过多。为了使用一个代理类来完成全部的代理功能，显然不能在运行前就生成好代理类的.class文件。即，必须使用动态代理。

2.2 JDK动态代理

（1）interface InvocationHandler

 public interface InvocationHandler {
      public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
 }

参数说明：

 Object proxy：指被代理的对象。
 Method method：要调用的方法
 Object[] args：方法调用时所需要的参数 

（2）class Proxy

java.lang.reflect.Proxy类提供了一个方法：newProxyInstance。

 public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)  throws IllegalArgumentException 

参数说明：

1 ClassLoader loader：类加载器
2 Class<?>[] interfaces：得到全部的接口
3 InvocationHandler h：得到InvocationHandler接口的子类实例 

（3）实例

 1 public interface BookFacade {
 2     public void addBook();
 3 }
 4
 5 public class BookFacadeImpl implements BookFacade {
 6
 7     @Override
 8     public void addBook() {
 9         System.out.println("增加图书方法。。。");
10     }
11 }  

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;  

 public class BookFacadeProxy implements InvocationHandler {
     private Object target;
     /**
      * 绑定委托对象并返回一个代理类
      * @param target 委托对象
      * @return 代理类
      */
     public Object bind(Object target) {
         this.target = target;
         //取得代理对象  //要绑定接口(这是一个缺陷，cglib弥补了)
         return Proxy.newProxyInstance(target.getClass().getClassLoader(),
16　　                                   target.getClass().getInterfaces(),
17　　　　　　　　                         this);
     }  

     @Override
     /**
      * 调用委托类的方法
      */
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         Object result=null;
         System.out.println("事物开始");
         //执行方法
         result=method.invoke(target, args);
         System.out.println("事物结束");
         return result;
     }
 }  

（4）测试

由测试可知，此时只需要一个代理类，就可以通用了。但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。

 public class TestProxy {  

     public static void main(String[] args) {
         BookFacadeProxy proxy = new BookFacadeProxy();
         BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());
         bookProxy.addBook();
     }
 }

2.3 Cglib动态代理

由前面可知，当委托类并没有实现某个接口（implements someInterface）时，jdk动态代理就不能使用了。

cglib是针对类来实现代理（没有实现某个接口也不会造成影响），原理：对委托类生成一个子类（局限：final），并覆盖其中方法实现增强。

（1）实例

 public class BookFacadeImpl1 {  //没有implements BookFacade
     public void addBook() {
         System.out.println("增加图书的普通方法...");
     }
 } 

 import java.lang.reflect.Method;  

 import net.sf.cglib.proxy.Enhancer;
 import net.sf.cglib.proxy.MethodInterceptor;
 import net.sf.cglib.proxy.MethodProxy;  

 public class BookFacadeCglib 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();
     }  

     @Override
     // 回调方法
     public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
         System.out.println("事物开始");
         proxy.invokeSuper(obj, args);
         System.out.println("事物结束");
         return null;
     }
   }

（2）测试

 public class TestCglib {  

     public static void main(String[] args) {
         BookFacadeCglib cglib=new BookFacadeCglib();
         BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());
         bookCglib.addBook();
     }
 } 

3.总结

 静态代理缺点：代码一对一，重复冗余，编译时就需要存在代理类的.class文件。
 动态代理优点：动态生成，统一处理，运行时生成代理类。
 jdk动态代理： Proxy，InvocationHandler
 cglib动态代理：MethodInterceptor