JAVA之动态代理，静态代理和CGLIB

来源：互联网发布：电信软件市场编辑：程序博客网时间：2024/05/01 03:03

总结：

静态代理：最简单，首先要有接口，然后new实际类A，并将指针转为接口传给proxy，proxy实现了接口，在每个函数内部的before和after执行代理代码后，再调用传入的A的接口函数。使用时，使用proxy类的接口指针。
动态代理：不用专门实现一个具体的proxy类。实现一个通用类即可，内部使用getProxyClass(目标类的loader, 目标类的interfaces)函数进行绑定（使用反射遍历所有接口函数处理）。不用实现proxy类，所以不用每个接口函数都要写一个对应函数处理。
动态代理可能的实现思路（不一定是实际实现方式）：
1. 其核心是使用Method.invoke的反射机制调用业务逻辑，并在前后增加代理代码
2. 接口所有Method的获取，由封装proxy代码完成，利用类似Object.getClass().getInterfaces()[0].getDeclaredMethods()这样的代码，将其存入map中。
3. 用户调用(接口)proxy.接口函数()时，需要封装proxy完成从接口函数到method.invoke的传递：
  1. 首先，proxy需要预先对每个接口method生成一个同名方法。运行调用后，以便通过map获取到真正的Method对象；
  2. 其次，由于Method.invoke和前后的代理代码是用户定制，所有，这里需要实现类似SPI的invocationhandler接口。proxy中对应的接口函数实现代码中，在从map获取到对应Method后，调用invocationhandler.invoke(this,取出的Method，传入的参数)，随后进入用户实现的代码！
4. 注意，Method.invoke第一个参数是类对象，由于这里是实际业务逻辑，所以需要实际业务对象。由于在proxy.接口函数时没有传入业务对象的入口，所以需要在其他地方传入，现在的方式是在实现invocationhandler的类中初始化时即传入实际业务对象并保存起来。
5. 总结：proxy代理封装，主要做的工作是两个，第一是遍历所有接口获取Method并存入map。第二，对所有Method实现同名函数（自己动态生成一个实现了接口的代理类），在其中实现查找map取出真正Method，并通过接口将Method传给用户代码。
6. 为何必须基于接口？如果用getClass().getMethods()也可以获取所有public函数，也可以存入map。对于生成代理类的方法，可以直接根据所有public函数生成所有代理接口函数，理论上，也可以完成代理，不一定是接口。但是！在最外层用户调用“proxy.接口函数()”时，如果不用接口，编译器不知道proxy会有哪些函数，编译会报错！只有通过接口和多态结合方式，编译器才能正确识别不报错！---需要进一步分析CGLIB的表示方式，如何绕过编译器检查的。
CGLIB：不基于接口，基于继承。优点是即使没有基于接口也可以用，缺点是final类不可用。
1. CGLIB被用户使用时，不是用接口类型，而是直接将返回的Object强制转为目标class类型，使用目标Class类型。然后就可以使用目标class的所有函数。但这里有个问题，将Object强制转化为目标Class，必须遵守编译器的限制！即多态的父类子类关系！因此，CGLIB是基于继承的方案。
2. 其他原理，依然遵循动态代理的思路。
总结：动态代理的其核心都是使用method.invoke。为了支持编译器编译判定，在用户代码端如果要可以直接对Obj对象调用目标函数，有两种方式。第一种是使用接口，将实现了接口的对象obj（动态代理类）转为接口类型的obj是可行的。第二种是使用继承，将子类对象obj（动态代理类）转为父类对象obj（目标类）是可行的。

以下转载自：http://blog.csdn.net/hintcnuie/article/details/10954631

昨天被人问及动态代理与CGlib的区别，赶紧回顾一下：

什么是代理？
静态代理与动态代理
静态代理实例
JDK动态代理实例
CGLib 简介
CGLib 与JDK动态代理的区别

代理模式是Java中常见的一种模式，英文名字叫走Proxy或者Surrogate，代理的本意是一个人代表另一个人，或者一个机构代表另一个机构，采取行动，因而，代理和现实生活中的中介有很大的类似，你买房子、卖房子，可以自己去操作，但是需要了解和买卖房产无关的细节，如契税等，而找一个中介，则不用关心这些与买卖房产无直接关系的中间细节，只关心业务本身。

静态代理UML类图

模式中包含的角色及其职责

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

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

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

Subject:

[java] view plain copy
/** 
 
 * 抽象主题，定义主要功能 
 
 */  
  
publicinterface Subject {  
  
   publicvoid operate();  
  
}

RealSubject：

[java] view plain copy
 
/** 
 
 * 具体主题 
 
 */  
  
publicclass RealSubject implements Subject{  
  
   @Override  
  
   publicvoid operate() {  
  
        System.out.println("realsubject operatestarted......");  
  
   }  
  
}

代理类Proxy：

[java] view plain copy
 
/** 
 
 * 代理类 
 
 */  
  
publicclass Proxy implements Subject{  
  
   private Subject subject;  
  
   public Proxy(Subject subject) {  
  
        this.subject = subject;  
  
   }  
  
   @Override  
  
   publicvoid operate() {  
  
        System.out.println("before operate......");  
  
        subject.operate();  
  
        System.out.println("after operate......");  
  
   }  
  
}

客户端：

[java] view plain copy
 
/** 
 * 客户 
 */  
publicclass Client {  
   /** 
    * @param args 
    */  
   publicstaticvoid main(String[] args) {  
        Subject subject = new RealSubject();  
        Proxy proxy = new Proxy(subject);  
        proxy.operate();  
   }  
}  

代理模式的适用，总结为：代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等

代理模式的用途，可以分为如下几种（From GOF）:

(1)远程代理(Remote Proxy) ---A remote proxy provides a local representative for an object in a different address space.为远程对象提供一个本地的代理对象，典型的例子如RMI， EJB，local bean 为remote 接口对象提供一个stub

(2)虚拟代理(Virtual Proxy) – A virtual proxy creates expensive objects on demand.允许内存开销较大的对象在需要的时候创建。只有我们真正需要这个对象的时候才创建。

虚拟代理模式(Virtual Proxy)是一种节省内存的技术，它建议创建那些占用大量内存或处理复杂的对象时，把创建这类对象推迟到使用它的时候。在特定的应用中，不同部分的功能由不同的对象组成，应用启动的时候，不会立即使用所有的对象。在这种情况下，虚拟代理模式建议推迟对象的创建直到应用程序需要它为止。对象被应用第一次引用时创建并且同一个实例可以被重用。这种方法优缺点并存。
　　
　　优点：
　　
　　这种方法的优点是，在应用程序启动时，由于不需要创建和装载所有的对象，因此加速了应用程序的启动。
　　
　　缺点:
　　
　　因为不能保证特定的应用程序对象被创建，在访问这个对象的任何地方，都需要检测确认它不是空(null)。也就是，这种检测的时间消耗是最大的缺点。
　　
　　应用虚拟代理模式，需要设计一个与真实对象具有相同接口的单独对象（指虚拟代理）。不同的客户对象可以在创建和使用真实对象地方用相应的虚拟对象来代替。虚拟对象把真实对象的引用作为它的实例变量维护。代理对象不要自动创建真实对象，当客户需要真实对象的服务时，调用虚拟代理对象上的方法，并且检测真实对象是否被创建。
　　
　　如果真实对象已经创建，代理把调用转发给真实对象
　　
　　如果真实对象没有被创建：
　　
　　1）代理对象创建真实对象
　　
　　2）代理对象把这个对象分配给引用变量。
　　
　　3）代理把调用转发给真实对象
　　
　　按照这种安排，验证对象存在和转发方法调用这些细节对于客户是不可见的。客户对象就像和真实对象一样与代理对象进行交互。因此客户从检测真实对象是否为null中解脱出来，另外，由于创建代理对象在时间和处理复杂度上要少于创建真实对象。因此，在应用程序启动的时候，用代理对象代替真实对象初始化。

(3)写入时复制代理(Copy-On-Write Proxy) – 用来控制对象的复制，方法是延迟对象的复制，直到客户真的需要为止。是虚拟代理的一个变体。

(4)保护代理(Protection (Access)Proxy) – A protection proxy controls access to the original object. Protection proxies are useful when objects should have different access rights.为不同的客户提供不同级别的目标对象访问权限

(5)缓存代理(Cache Proxy) – 为开销大的运算结果提供暂时存储，它允许多个客户共享结果，以减少计算或网络延迟。

(6)防火墙代理(Firewall Proxy) – 控制网络资源的访问，保护主题免于恶意客户的侵害。

(7)同步代理(SynchronizationProxy) –在多线程的情况下为主题提供安全的访问。

(8)智能引用代理(Smart ReferenceProxy) - A smart reference is a replacement for a bare pointer that performs additional actions when an object is accessed。当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来等。

(9)复杂隐藏代理(Complexity HidingProxy) – 用来隐藏一个类的复杂集合的复杂度，并进行访问控制。有时候也称为外观代理(Façade Proxy)，这不难理解。复杂隐藏代理和外观模式是不一样的，因为代理控制访问，而外观模式是不一样的，因为代理控制访问，而外观模式只提供另一组接口。

2.静态代理与动态代理

代理分为静态代理和动态代理

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

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

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

3.静态代理实例

静态代理实例：

首先需要一个接口：

[java] view plain copy
 
package net.battier.dao;  
  
/** 
 * 定义一个账户接口 
 *  
 * @author Administrator 
 *  
 */  
public interface Count {  
    // 查看账户方法  
    public void queryCount();  
  
    // 修改账户方法  
    public void updateCount();  
  
}  

然后是委托类，也就是接口的真正实现类，内涵主要的业务逻辑：

[java] view plain copy
 
package net.battier.dao.impl;  
  
import net.battier.dao.Count;  
  
/** 
 * 委托类(包含业务逻辑) 
 *  
 * @author Administrator 
 *  
 */  
public class CountImpl implements Count {  
  
    @Override  
    public void queryCount() {  
        System.out.println("查看账户方法...");  
  
    }  
  
    @Override  
    public void updateCount() {  
        System.out.println("修改账户方法...");  
  
    }  
  
}  

最后是代理类：

[java] view plain copy
 
CountProxy.java  
package net.battier.dao.impl;  
  
import net.battier.dao.Count;  
  
/** 
 * 这是一个代理类（增强CountImpl实现类） 
 *  
 * @author Administrator 
 *  
 */  
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("事务处理之后");  
  
    }  
  
}  

运行：

[java] view plain copy
 
package com.mahoutchina.pattern.proxy;  
  
public class CountTest {  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        CountImpl countImpl = new CountImpl();    
        CountProxy countProxy = new CountProxy(countImpl);    
        countProxy.updateCount();    
        countProxy.queryCount();   
  
    }  
  
}  

从静态代理中可以看出：

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

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

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

latex-table

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

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

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

Subject：

[java] view plain copy
 
public  interface Subject {  
  abstract  public  void request();  
}  

具体Subject：

[java] view plain copy
 
// 具体角色RealSubject：  
public  class RealSubject implements Subject {  
  public RealSubject() {}  
  
  public  void request() {  
    System.out.println( " From real subject. " );  
 }  
  
}  

代理处理器(ProxyHandler):

[java] view plain copy
 
import java.lang.reflect.Method;  
import java.lang.reflect.InvocationHandler;  
  
public  class DynamicSubject implements InvocationHandler {  
  private Object sub;  
  public DynamicSubject() {}  
  
  public DynamicSubject(Object obj) {  
    sub = obj;  
  }  
  
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
    System.out.println( " before calling "  + method);  
    method.invoke(sub,args);  
  
    System.out.println( " after calling "  + method);  
    return  null ;  
  }  
}  

该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值；此外，在该类还实现了invoke方法，该方法中的

method.invoke(sub,args);

其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，args为执行被代理对象相应操作所需的参数。通过动态代理类，我们可以在调用之前或之后执行一些相关操作。

[java] view plain copy
 
// 客户端：  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Proxy;  
import java.lang.reflect.Constructor;  
import java.lang.reflect.Method;  
  
public class Client {  
  
  static public void main(String[] args) throws Throwable {  
   RealSubject rs = new RealSubject(); // 在这里指定被代理类  
   InvocationHandler ds = new DynamicSubject(rs);  
   Class cls = rs.getClass();  
  
   // 以下是一次性生成代理  
   Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),ds );  
   subject.request();  
  }  
}  

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

从JDK 1.3以来，Java 语言通过java.lang.reflex库提供的三个类直接支持代理：

java.lang.reflect.Proxy,java.lang.reflect.InvocationHandler 和Method.

Proxy类在运行时动态创建代理对象，这也是dynamic proxy的由来，下面是类图，其中最重要的是newProxyInstance,这个方法中，指明了将要代理的类的加载器，业务类接口，以及代理类要执行动作的调用处理器（InvokeHandler)

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
参数说明：
ClassLoader loader：类加载器
Class<?>[] interfaces：得到全部的接口
InvocationHandler h：得到InvocationHandler接口的子类实例

Ps:类加载器
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器;
Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的；
Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类;
AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。

当系统有了一个代理对象之后，对原方法的调用会首先被分派到一个调用处理器（Invocation Handler).InvocationHandler 接口如下图所示：

代码：

接口：

[java] view plain copy
 
package com.mahoutchina.pattern.proxy.dynamicproxy;  
  
public interface BookFacade {  
    public void addBook();  
    public void deleteBook();  
}  

实际业务类：

[java] view plain copy
 
package com.mahoutchina.pattern.proxy.dynamicproxy;  
  
public class BookFacadeImpl implements BookFacade {  
  
    @Override  
    public void addBook() {  
        System.out.println("add book logic is running。。。");   
    }  
  
    @Override  
    public void deleteBook() {  
        System.out.println("delete book logic is running。。。");  
          
    }  
      
  
}  

动态代理类：

[java] view plain copy
 
package com.mahoutchina.pattern.proxy.dynamicproxy;  
  
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;  
        // 取得代理对象  
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
                target.getClass().getInterfaces(), this);  
    }  
  
    @Override  
    public Object invoke(Object proxy, Method method, Object[] args)  
            throws Throwable {  
        Object result=null;  
        System.out.println("Proxy start...");  
        System.out.println("method name:"+method.getName());  
        result=method.invoke(target, args);  
        System.out.println("Proxy end...");  
        return result;  
    }  
  
}  

测试类：

[java] view plain copy
 
package com.mahoutchina.pattern.proxy.dynamicproxy;  
  
ublic class TestProxy {  
  
/** 
 * @param args 
 */  
public static void main(String[] args) {  
    BookFacadeProxy proxy = new BookFacadeProxy();  
    BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  
    bookProxy.addBook();  
    bookProxy.deleteBook();  
}  

对于JDK 的Proxy,有以下几点：

1）Interface：对于JDK proxy，业务类是需要一个Interface的，这也是一个缺陷

2）Proxy，Proxy 类是动态产生的，这个类在调用Proxy.newProxyInstance(targetCls.getClassLoader, targetCls.getInterface,InvocationHander)之后，会产生一个Proxy类的实例。实际上这个Proxy类也是存在的，不仅仅是类的实例。这个Proxy类可以保存到硬盘上。

3） Method:对于业务委托类的每个方法，现在Proxy类里面都不用静态显示出来

4） InvocationHandler: 这个类在业务委托类执行时，会先调用invoke方法。invoke方法再执行相应的代理操作，可以实现对业务方法的再包装

5 CGLib 简介

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

业务类：

[java] view plain copy
 
package net.battier.dao;  
  
public interface BookFacade {  
    public void addBook();  
}  

[java] view plain copy
 
package net.battier.dao.impl;  
  
/** 
 * 这个是没有实现接口的实现类 
 *  
 * @author student 
 *  
 */  
public class BookFacadeImpl1 {  
    public void addBook() {  
        System.out.println("增加图书的普通方法...");  
    }  
}  

代理：

[java] view plain copy
 
package net.battier.proxy;  
  
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 student 
 *  
 */  
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;  
  
  
    }  
  
}  

测试；

[java] view plain copy
 
package net.battier.test;  
  
import net.battier.dao.impl.BookFacadeImpl1;  
import net.battier.proxy.BookFacadeCglib;  
  
public class TestCglib {  
      
    public static void main(String[] args) {  
        BookFacadeCglib cglib=new BookFacadeCglib();  
        BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  
        bookCglib.addBook();  
    }  
}  

0 0