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;  
  
    /** 
     * 创建代理对象 13      * @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