动态代理详解

简介

在某些情况下，我们不希望或是不能直接访问对象 A，而是通过访问一个中介对象 B，由 B 去访问 A 达成目的，这种方式我们就称为代理。

这里对象 A 所属类我们称为委托类，也称为被代理类，对象 B 所属类称为代理类。

代理优点有：

• 隐藏委托类的实现
• 解耦，不改变委托类代码情况下做一些额外处理，比如添加初始判断及其他公共操作

根据程序运行前代理类是否已经存在，可以将代理分为静态代理和动态代理。
动态代理实现方式主要有两种，分别是JDK动态代理和CGlib动态代理。二者的主要区别是JDK动态代理是通过反射，只能代理实现接口的目标类，而CGlib是通过继承目标类，因而不能代理final类。

代理类在程序运行前不存在、运行时由程序动态生成的代理方式称为动态代理。

Java 提供了动态代理的实现方式，可以在运行时刻动态生成代理类。这种代理方式的一大好处是可以方便对代理类的函数做统一或特殊处理，如记录所有函数执行时间、所有函数执行前添加验证判断、对某个特殊函数进行特殊操作，而不用像静态代理方式那样需要修改每个函数。

代理模式原理

代理模式就是给某一个对象创建了一个代理对象，由这个代理对象控制原对象的引用，而创建这个代理对象后可以在调用原对象时增加一些额外的操作。如下图所示是代理模式的结构。

接口：它是代理对象的真实对象要实现的接口

代理类：除了实现上述的接口外，还需要持有代理对象的引用

实现类：被代理的类，是目标对象

代理模式结构

创建代理对象的时序图如下所示

创建代理对象的时序图

动态代理实现

JDK实现动态代理包括三步：

1. 新建委托类；
2. 实现InvocationHandler接口，这是负责连接代理类和委托类的中间类必须实现的接口；
3. 通过Proxy类新建代理类对象。

接口

public interface Greeting {
    void sayHello(String name);
}

目标类

public class GreetingImpl implements Greeting {
    public void sayHello(String name) {
        System.out.println("say Hello:"+name);
    }
}

JDK代理类

InvocationHandler接口，前者Invocation为执行，后者Handler为句柄（实际对象的间接引用）。对于invoke函数，调用代理对象的所有方法都会调用这个函数。

public class JDKDynamicProxy implements InvocationHandler {

    private Object target;

    public JDKDynamicProxy(Object target){
        this.target = target;
    }

    public <T> T getPoxy(){
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this
        );
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(target,args);
        after();
        return result;
    }

    public void before(){
        System.out.println("before");
    }

    public void after(){
        System.out.println("after");
    }
}

cglib代理类

public class CGLibDynamicProxy implements MethodInterceptor {

    private static CGLibDynamicProxy instance = new CGLibDynamicProxy();

    private CGLibDynamicProxy(){
    }

    public static CGLibDynamicProxy getInstance(){
        return instance;
    }

    public <T> T getProxy(Class<T> cls){
        return (T) Enhancer.create(cls,this);
    }

    @Override
    public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        before();
        Object result = proxy.invokeSuper(target,args);
        after();
        return result;
    }


    public void before(){
        System.out.println("before");
    }

    public void after(){
        System.out.println("after");
    }

}

测试

public class Client {
    public static void main(String[] args) {
        //JDK动态代理
        Greeting greeting = new JDKDynamicProxy(new GreetingImpl()).getPoxy();
        greeting.sayHello("Jack");
        //CGLib动态代理
        Greeting greeting2 = CGLibDynamicProxy.getInstance().getProxy(GreetingImpl.class);
        greeting2.sayHello("Rose");
    }
}

结果

before
say Hello:Jack
after
before
say Hello:Rose
after

参考资料

《架构探险》

《深入分析Java Web技术内幕》