代理模式[转][整理]

[b]代理模式[/b]

代理模式的[b]作用[/b]是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式一般涉及到的[b]角色[/b]有：

1. [b]抽象角色[/b]：声明真实对象和代理对象的共同接口，(并非必需的，使用cglib实现代理时，可以不申明抽象角色)；
2. [b]代理角色[/b]：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
3. [b]真实角色[/b]：代理角色所代表的真实对象，是我们最终要引用的对象。

以下以《Java与模式》中的示例为例：

//抽象角色： 
abstract public class Subject{       
    abstract public void request(); 
}

//真实角色：实现了Subject的request()方法。 
public class RealSubject extends Subject{ 
    public RealSubject(){  
    } 
    public void request(){ 
        System.out.println("From real subject."); 
    } 
}

//代理角色： 
public class ProxySubject extends Subject{ 
    private RealSubject realSubject; //以真实角色作为代理角色的属性  
    public ProxySubject(){ 
    }  
    public void request(){ //该方法封装了真实对象的request方法  
        preRequest(); // 调用真实角色前的处理
        if( realSubject == null ){ 
            realSubject = new RealSubject(); 
        } 
        realSubject.request(); //此处执行真实对象的request方法  
        postRequest(); // 调用真实角色后的处理
    } 
    private void preRequest(){  
        //something you want to do before requesting  
    } 
    private void postRequest(){  
        //something you want to do after requesting  
    } 
}

// 使用场景
public class ProxyTest { 
    public static void main(String[] args) { 
        Subject sub=new ProxySubject(); 
        Sub.request();
    }
}

以上的代码，创建一个新的类，实现抽象接口，并对真实角色进行封装，从而达到代理的效果。
但是，这样的实现，1、真实角色必须已经存在，并将其作为代理角色的内部属性。2、在使用时，必须一个真实角色对应一个代理角色。如果大量使用会导致类的急剧膨胀。
此外，如果实现不知道真实对象，也无法使用这样的代理方式。

[b]动态代理[/b]

使用java.lang.reflect.Porxy 和 java.lang.reflect.InvocationHandler接口实现代理模式。

* Interface InvocationHandler :是代理角色实现的接口。提供一个方法

      Object invoke(Object proxy, Method method, Object[] args)  throws Throwable

在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。

* java.lang.reflect.Proxy ：该类即为动态代理类，作用类似于上例中的ProxySubject，提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。
o Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。
o Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。它的主要方法有：
o Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。

所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

将上面的例子，修改为被代理的类如果实现接口，那么使用JDK的代理模式，设计到Proxy,InvocationHandler。
如果被代理的类没有实现接口，那么使用CGLIB来实现代理。

public interface Subject{       
    public void request(); 
}

public class RealSubject implements Subject{ 
    public RealSubject(){  
    } 
    public void request(){ 
        System.out.println("From real subject."); 
    } 
}

public class ProxySubject implements InvocationHandler {

    private Object target;

    public ProxySubject(Object obj) {
        this.target = obj;
    }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("before calling " + method);
        Object result = method.invoke(this.target, args);
        System.out.println("after calling " + method);
        return result;proxyRs
    }

    /**
     * 提供一个静态方法，获取动态代理实例
     */
    public static Object createProxyInstance(Object obj) {
        Assert.notNull(obj);
        Class<?> clz = obj.getClass();
        /*
          以下是分解步骤
          Class c = Proxy.getProxyClass(clz.getClassLoader(),clz.getInterfaces());
          Constructor ct=c.getConstructor(new Class[]{InvocationHandler.class});
          Subject subject =(Subject) ct.newInstance(new Object[]{new MyInvocationHandler(obj)});
         */

         //以下是一次性生成
        return Proxy.newProxyInstance(clz.getClassLoader(), clz.getInterfaces(), new DynamicSubject(obj));
    }
}

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

// 使用场景
public class ProxyTest {
    public static void main(String[] args) throws Throwable {
        RealSubject rs = new RealSubject(); // 在这里指定被代理类
        Subject subject = (Subject) DynamicSubject.createProxyInstance(rs);// 获取代理类
        subject.request();
    }
}

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

[b]Cglib实现代理模式[/b]

被代理的类如果实现接口，那么使用JDK的代理模式，设计到Proxy,InvocationHandler。
如果被代理的类没有实现接口，那么使用CGLIB来实现代理。

还是用上面的例子，去掉接口类。

//真实角色：实现了Subject的request()方法。 
public class RealSubject { 
    public RealSubject(){  
    } 
    public void request(){ 
        System.out.println("From real subject."); 
    } 
}

public class CGLIBProxyFactory implements MethodInterceptor {

    private Object target;

    public CGLIBProxyFactory(Object obj) {
        this.target = obj;
    }

    public static Object creatNewProxyInstance(Object obj) {
        CGLIBProxyFactory proxy = new CGLIBProxyFactory(obj);

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(proxy.getTarget().getClass()); 代理类会生产一个被代理类的子类，final方法除外
        enhancer.setCallback(proxy);//将CGLIBProxyFactory实例设为回调对象，必须实现接口 MehtoInterceptor
        return enhancer.create();
    }

    //代理对象被回调的时候调用此方法
    @Override
    public Object intercept(Object proxy, Method method, Object[] args,
            MethodProxy methodProxy) throws Throwable {

        System.out.println("before calling " + method);
        Object result = methodProxy.invoke(this.target, args);
        System.out.println("after calling " + method);

        return result;
    }

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }
}

// 使用场景
public class ProxyTest {
    public static void main(String[] args) throws Throwable {
        RealSubject rs = new RealSubject();
        RealSubject proxyRs = (RealSubject) CGLIBProxyFactory.creatNewProxyInstance(rs);
        proxyRs.request();
    }
}

可以看到，cglib在使用场景里的代码，与使用反射的代码，基本上是一样的。只是cglib可以直接实现对一个实例的代理，而用反射方式，必须有声明一个接口。

CgLib 就可以不用接口，它底层调用 asm 动态生成一个代理类去覆盖父类中非 final 的方法，然后实现 MethodInterceptor 接口的 intercept 方法，这样以后直接调用重写的方法，比 JDK 要快。

加载 cglib 消耗时间比直接 jdk 反射时间长，开发的过程中，如果是反复动态生成新的代理类推荐用 jdk 自身的反射，反之用 cglib.

简单的做了一个测试，使用上面的代码，循环10000次，使用反射方式创建代理类需要402毫秒；使用cglib创建代理类需要1072毫秒。