【设计模式】代理模式之JDK动态代理与CGLIb代理区别

一、什么是代理？

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

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

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

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

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

1、静态代理实例

  静态代理UML类图

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

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

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

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

Subject:

/** 
 
 * 抽象主题，定义主要功能 
 
 */  
  
public interface Subject {  
  
     void operate();  
  
}  

RealSubject：

/** 
 
 * 具体主题 
 
 */  
  
public class RealSubject implements Subject{  
  
   
  
   @Override  
  
   public void operate() {  
  
        System.out.println("realsubject operatestarted......");  
  
   }  
  
}  

代理类Proxy：

/** 
 
 * 代理类 
 
 */  
  
public class Proxy implements Subject {  
  
  
   private Subject subject;  
  
  
   public Proxy(Subject subject) {  
  
        this.subject = subject;  
  
   }  
  
   
  
   @Override  
  
   public void operate() {  
  
        System.out.println("before operate......");  
  
        subject.operate();  
  
        System.out.println("after operate......");  
  
   }  
  
}  

客户端：

/** 
 * 客户调用 
 */  
public class Client {  
   /** 
    * @param args 
    */  
   public staticvoid main(String[] args) {  
        Subject subject = new RealSubject();  
        Proxy proxy = new Proxy(subject);  
        proxy.operate();  
   }  
}  

  从静态代理中可以看出：

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

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

2、动态代理实例

2.1、jdk动态代理实现方式：

动态代理类克服了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：

package org.wavefar.core;

public interface IUser {
    void addUser();
    void delUser();
}

具体Subject：

package org.wavefar.core;

public class UserImpl implements IUser {
    @Override
    public void addUser() {
        System.out.println("添加了一个用户！");
    }

    @Override
    public void delUser() {
        System.out.println("删除了一个用户！");
    }
}

代理处理器(ProxyHandler):

package org.wavefar.core;

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

public class UserProxy implements InvocationHandler {

    private  Object obj;
    public Object getInstance(Object obj){
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        System.out.println("Proxy start...");
        Object result = method.invoke(obj,args);
        System.out.println("Proxy end...");
        return result;
    }
}

测试类：

package org.wavefar.core;

public class UserProxyTest {
    public static void main(String[]args) {
        UserProxy userProxy = new UserProxy();
        IUser iUser = (IUser) userProxy.getInstance(new UserImpl());
        iUser.addUser();
        iUser.delUser();
    }
}

 对于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方法再执行相应的代理操作，可以实现对业务方法的再包装

 

2.2、CGLib 动态代理简介

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，使用CGLib实现动态代理，完全不受代理类必须实现接口的限制，而且CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的方法进行代理，因为CGLib原理是动态生成被代理类的子类。

下面，将通过一个实例介绍使用CGLib实现动态代理。

直接看示例：

业务类：

package org.wavefar.core;

/**
 * 这个没实现接口
 * @author summer
 */
public class UserImpl /*implements IUser */{
    public void addUser() {
        System.out.println("添加了一个用户！");
    }

    public void delUser() {
        System.out.println("删除了一个用户！");
    }
}

代理类：

package org.wavefar.core;
  
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 summer
 */
public class UserProxyCglib 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 start...");
        Object object = proxy.invokeSuper(obj, args);
        System.out.println("Proxy end...");
        return object;

    }  
  
}

测试：

package org.wavefar.core; 
  
  
public class TestCglib {  
      
    public static void main(String[] args) {  
        UserProxyCglib cglib = new UserProxyCglib();  
        UserImpl userImpl = (UserImpl)cglib.getInstance(new UserImpl());  
        userImpl.addUser(); 
        userImpl.delUser();
    }  
}  

 

二、代理模式的用途，可以分为如下几种（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)，这不难理解。复杂隐藏代理和外观模式是不一样的，因为代理控制访问，而外观模式是不一样的，因为代理控制访问，而外观模式只提供另一组接口。