【28】动态代理proxy与CGLib的区别

1. 什么是代理？
2. 静态代理与动态代理
3. 静态代理实例
4. JDK动态代理实例
5. CGLib 简介
6. CGLib 与JDK动态代理的区别

   1. 代理模式是Java中常见的一种模式，不多说，直接上代码。

  静态代理UML类图

Subject：抽象主题角色，抽象主题类可以是抽象类，也可以是接口，是一个最普通的业务类型定义，无特殊要求。

RealSubject：具体主题角色，也叫被委托角色、被代理角色。是业务逻辑的具体执行者。

Proxy：代理主题角色，也叫委托类、代理类。它把所有抽象主题类定义的方法给具体主题角色实现，并且在具体主题角色处理完毕前后做预处理和善后工作。（最简单的比如打印日志）： 

   2.静态代理与动态代理

 按照代理创建的时期，可以分为动态代理和静态代理：

 静态代理：由程序员或者自动生成工具生成代理类，然后进行代理类的编译和运行。在代理类、委托类运行之前，代理类已经以.class的格式存在。

 动态代理：在程序运行时，由反射机制动态创建而成。

 3.静态代理实例

    静态代理实例：

     首先需要一个接口：     

1. public interface Count {  
2.     public void queryCount();  
3.     public void updateCount();  
4.   }  

  然后是真正实现类：   

1. public class CountImpl implements Count {    
2.     @Override  
3.     public void queryCount() {  
4.         System.out.println("查看账户方法...");    
5.     }    
6.     @Override  
7.     public void updateCount() {  
8.         System.out.println("修改账户方法...");    
9.     }    
10. }  

   最后是代理类：        

1. public class CountProxy implements Count {  
2.     private CountImpl countImpl;  
3.  
4.     public CountProxy(CountImpl countImpl) {  
5.         this.countImpl = countImpl;  
6.     }  
7.   
8.     @Override  
9.     public void queryCount() {  
10.         System.out.println("事务处理之前");  
11.         countImpl.queryCount();  
12.         System.out.println("事务处理之后");  
13.     }  
14.   
15.     @Override  
16.     public void updateCount() {  
17.         System.out.println("事务处理之前");  
18.         countImpl.updateCount();  
19.         System.out.println("事务处理之后");    
20.     }    
21. }  

运行：   

1. package com.mahoutchina.pattern.proxy;    
2. public class CountTest {  
3.     public static void main(String[] args) {  
4.         CountImpl countImpl = new CountImpl();    
5.         CountProxy countProxy = new CountProxy(countImpl);    
6.         countProxy.updateCount();    
7.         countProxy.queryCount();     
8.     }    
9. }  

  从静态代理中可以看出：

    1.接口：代理类需要实现一个接口，这个接口和委托类的接口是一样的，这样proxy才能和委托类行为表现一致

    2. 方法（Method）:由于接口限制，proxy类中也要有interface中的各个方法，这就造成了代码重复   

4.动态代理实例
    动态代理类克服了proxy需要继承专一的interface接口，并且要实现相应的method的缺陷。

 

java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类：

1. Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。在实际使用时，第一个参数obj一般是指代理 类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。 这个抽 象方法在代理类中动态实现。
2. Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject。
3. Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。
4. Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个 代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
5. Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用 (可使用被代理类的在Subject接口中声明过的方法)。

在使用动态代理类时，我们必须实现InvocationHandler， 以上面的代码为例：

  Subject：

1. public  interface Subject {  
2.   abstract  public  void request();  
3. }  

具体Subject：

1. public  class RealSubject implements Subject {  
2.   public RealSubject() {}    
3.   public  void request() {  
4.     System.out.println( " From real subject. " );  
5.  }    
6. }  

代理处理器(ProxyHandler):

1. import java.lang.reflect.Method;  
2. import java.lang.reflect.InvocationHandler;  
3.   
4. public  class DynamicSubject implements InvocationHandler {  
5.   private Object sub;  
6.   public DynamicSubject() {}  
7.   
8.   public DynamicSubject(Object obj) {  
9.     sub = obj;  
10.   }  
11.   
12.   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
13.     System.out.println( " before calling "  + method);  
14.     method.invoke(sub,args);    
15.     System.out.println( " after calling "  + method);  
16.     return  null ;  
17.   }  
18. }  

该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值；此外，在该类还实现了invoke方法，该方法中的method.invoke(sub,args);其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，args为执 行被代理对象相应操作所需的参数。通过动态代理类，我们可以在调用之前或之后执行一些 相关操作。

1. // 客户端：  
2. import java.lang.reflect.InvocationHandler;  
3. import java.lang.reflect.Proxy;  
4. import java.lang.reflect.Constructor;  
5. import java.lang.reflect.Method;    
6.  
7. public class Client {    
8.   static public void main(String[] args) throws Throwable {  
9.    RealSubject rs = new RealSubject(); // 在这里指定被代理类  
10.    InvocationHandler ds = new DynamicSubject(rs);  
11.    Class cls = rs.getClass();    
12.    // 以下是一次性生成代理  
13.    Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),ds );  
14.    subject.request();  
15.   }  
16. }  

通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口 (Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实 现了非常灵活的动态代理关系。

    5 CGLib 简介

          JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 
示例 

   业务类：

1. public interface BookFacade {  
2.     public void addBook();  
3. }  

1. public class BookFacadeImpl1 {  
2.     public void addBook() {  
3.         System.out.println("增加图书的普通方法...");  
4.     }  
5. }  

1. /** 
2.  * 使用cglib动态代理 
3.  */  
4. public class BookFacadeCglib implements MethodInterceptor {  
5.     private Object target;  
6.   
7.     /** 
8.      * 创建代理对象 
9.      *  
10.      * @param target 
11.      * @return 
12.      */  
13.     public Object getInstance(Object target) {  
14.         this.target = target;  
15.         Enhancer enhancer = new Enhancer();  
16.         enhancer.setSuperclass(this.target.getClass());  
17.         // 回调方法  
18.         enhancer.setCallback(this);  
19.         // 创建代理对象  
20.         return enhancer.create();  
21.     }  
22.   
23.     @Override  
24.     // 回调方法  
25.     public Object intercept(Object obj, Method method, Object[] args,  
26.             MethodProxy proxy) throws Throwable {  
27.         System.out.println("事物开始");  
28.         proxy.invokeSuper(obj, args);  
29.         System.out.println("事物结束");  
30.         return null;    
31.     }    
32. }  

1. public class TestCglib {        
2.     public static void main(String[] args) {  
3.         BookFacadeCglib cglib=new BookFacadeCglib();  
4.         BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  
5.         bookCglib.addBook();  
6.     }  
7. }