Java中的动态代理

场景

将某个类的功能，委托给其他类来执行。那这个其他类就被称为代理类。并且在代理类中，可以有目的的实现一些增强功能。如：日志打印、性能监控...等

基于JDK的动态代理实现方式

在JDK中提供了接口：java.lang.reflect.InvocationHandler、类：java.lang.reflect.Proxy来实现动态代理。

例子

假设我们有一个功能接口、实现如下：

/** 接口 */
public interface Hello {
    String say();
}
/** 实现 */
public class HelloImpl implements Hello {
    @Override
    public String say() {
        return "hello proxy";
    }
}

现在，需要在调用say()方法的前后，各打印一段字符串。最直接的做法：

public static void main(String[] args) {
        Hello hello = new HelloImpl();

        System.out.println("执行前");
        hello.say();
        System.out.println("执行后");
    }

是不是觉得很low逼...，并且假设有另一个接口的实现同样需要类似的操作，岂不是代码里面充斥着这样的坏味道。
那有没有优雅的解决方案呢？当然，我们可以借助JDK的动态代理来解决这个问题。

首先，实现接口java.lang.reflect.InvocationHandler

public class DynamicProxy implements InvocationHandler {

    /**
     * 被代理的实例
     */
    private Object target;

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

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

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

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

那么，如何使用呢？接下来看我们怎么利用JDK的java.lang.reflect.Proxy类来创建一个动态代理

public class Main {

    public static void main(String[] args) {
        // 创建被代理的对象
        Hello hello = new HelloImpl();
        
        DynamicProxy dynamicProxy = new DynamicProxy(hello);
        
        // 创建代理
        Hello helloProxy = (Hello) Proxy.newProxyInstance(
                hello.getClass().getClassLoader(),
                hello.getClass().getInterfaces(),
                dynamicProxy
        );
        
        helloProxy.say();
    }
}

可以看到，创建代理时需要传入类加载器、被代理类实现的接口、以及我们实现的InvocationHandler接口实例。此处可以繁琐，可以使用泛型进行优化，我们将DynamicProxy重构为如下：

public class DynamicProxy implements InvocationHandler {

    /**
     * 被代理的实例
     */
    private Object target;

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

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

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

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

    /**
     * 使用泛型优化
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }


}

在之后，我们可以直接按照下面的方式来使用动态代理

public class Main {

    public static void main(String[] args) {
        // 创建被代理的对象
        Hello hello = new HelloImpl();

        DynamicProxy dynamicProxy = new DynamicProxy(hello);

        // 创建代理
        Hello helloProxy = dynamicProxy.getProxy();

        helloProxy.say();
    }
}

以上就是用JDK创建动态代理的方式。

基于CGLib的动态代理实现方式

在jdk的动态代理中，如果要代理的是一个没有任何接口的类。那jdk的动态代理就没有用武之地了。
如果需要代理没有接口的类，可以使用CGLib这个类库，它是一个在运行期间动态生成字节码的工具。

实现方式

maven添加CGLIB的依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.6</version>
</dependency>

通过实现接口net.sf.cglib.proxy.MethodInterceptor

public class CGLibProxy implements MethodInterceptor{

    private static final CGLibProxy INSTANCE = new CGLibProxy();

    private CGLibProxy() {}

    public static CGLibProxy getInstance() {
        return INSTANCE;
    }


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

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

    /**
     * 增强方法（执行被代理类时，额外执行的方法）
     */
    private void before() {
        System.out.println("before....");
    }

    /**
     * 增强方法（执行被代理类时，额外执行的方法）
     */
    private void after() {
        System.out.println("after....");
    }
}

调用

public class Main {

    public static void main(String[] args) {
        Hello helloProxy = CGLibProxy.getInstance().getProxy(HelloImpl.class);
        helloProxy.say();
    }
}

总结

1. JDK的动态代理提高了我们实现代理的灵活性，带局限于存在接口的情况下；
2. 在需要代理一个没有接口的类时，可以使用CGLib替换JDK动态代理来实现；