Java动态代理笔记

在Java中， AOP、mybatis、日志打印等等很多地方都是使用代理模式实现。通过代理模式，可以实现在不修改目标对象的情况下对目标对象的功能进行增强。本文给出静态代理，动态代理中JDK和cgilb的实现总结。

代理模式基本概念

结合着上图，理解下面的三个概念：

• Subject抽像主题：定义接口
• RealSubject真实主题：被代理的类，实现了Subject接口，实际实现具体的功能。
• Proxy代理类：代理类内部会定义属性来持RealSubject的对象，同时也实现Subject的接口，在方法的内部，调用持有的RealSubject对象的方法，完成具体的功能。代理对象可以在调用RealSubject对象的方法的前后增加一些功能，来实现对RealSubject功能的增强。

静态代理

为了便于理解，先举一个静态代理的例子。
如下代码实现通过代理类对Person这个对象的睡觉动作，进行前置和后置的功能增强，增加睡觉开始和结束时间的记录。

// Person接口（对应Subject抽像主题）
public interface Person {  
	void sleep();  
}

// person的实现类 （对于RealSubject真实主题）
public class PersonImpl implements Person {

    @Override
    public void sleep() {
        System.out.println("睡觉中.........");
    }
}

// 代理类
public class PersonProxy implements Person {

	// 持有被代理对象
    private Person person;

    public PersonProxy(Person person) {
        this.person = person;
    }
	// 调用被代理对象，并完成前置和后置的功能增强
    @Override
    public void sleep() {
        System.out.println("前置动作，记录开始睡觉时间：" + new Date(System.currentTimeMillis()));
        person.sleep();
        System.out.println("后置动作，记录结束睡觉时间：" + new Date(System.currentTimeMillis()));
    }
}

public class StaticProxyTest {

    public static void main(String[] args) {
        Person personProxy = new PersonProxy(new PersonImpl());
        personProxy.sleep();
    }
}

结果：

前置动作，记录开始睡觉时间：Sun Nov 26 22:03:10 CST 2023
睡觉中.........
后置动作，记录结束睡觉时间：Sun Nov 26 22:03:10 CST 2023

静态代理，理解上虽然简单, 但是存在很多问题：使用静态需要手动创建代理，并且实现和目标对象一样的接口，造成了代码的冗余，如果目标对象的接口有改动时，对应的代理也得修改维护，增加了维护的复杂性。所以静态代理并不灵活。

动态代理

为了解决静态代理的缺点，可以使用Java的动态代理。动态代理从实现上可以这样理解，不用像静态代理那样将代码写死，而是在代码执行的时候，根据代码中指定的被代理类和功能增强关系，动态的生成代理类。

实现方式有两种:

• jdk动态代理
• cglib动态代理.

JDK实现动态代理

使用JDK内建实现动态代理需要关注InvocationHandler 接口和Proxy类。

要实现对被代理对象的功能增强，需要实现InvocationHandler接口，然后重写invoke方法，在该方法内完成对被代理对象的方法的功能增强。如下是一个示例：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Date;

public class ProxyInvocationHandler implements InvocationHandler {

    // 持有被代理对象
    private Object obj;

    public ProxyInvocationHandler(Object obj) {
        this.obj = obj;
    }

    /**
     * 在这里实现对被代理对象的功能增强
     * 
     * @param proxy 真实代理对象
     * @param method 所要调用某个对象真实的方法的Method对象
     * @param args 代理对象方法传递的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置动作，记录开始睡觉时间：" + new Date(System.currentTimeMillis()));
        Object result = method.invoke(obj, args);
        System.out.println("后置动作，记录结束睡觉时间：" + new Date(System.currentTimeMillis()));
        // 返回被代理对象的结果
        return result;
    }
}

测试一下：

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

public class DynamicJdkProxyTest {

    public static void main(String[] args) {
        PersonImpl person = new PersonImpl();
        InvocationHandler invocationHandler = new ProxyInvocationHandler(person);
        // 通过Proxy获取代理对象
        Person proxy = (Person) Proxy.newProxyInstance(invocationHandler.getClass().getClassLoader(), person.getClass().getInterfaces(), invocationHandler);
        // 调用具体实现
        proxy.sleep();
    }
}

输出结果：

前置动作，记录开始睡觉时间：Sat Dec 02 14:52:56 CST 2023
睡觉中.........
后置动作，记录结束睡觉时间：Sat Dec 02 14:52:56 CST 2023

根据输出结果可以发现最终执行的是InvocationHandler的invoke方法。

在上面最核心的是调用了Proxy类的newProxyInstance方法，结合着这个方法的定义，解释一下参数和方法的作用：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

方法的作用： 返回一个指定接口的代理类实例，该代理类将方法调用分派给指定的调用处理器。

方法的参数：

• loader： 一个classloader对象，定义了由哪个classloader对象对生成的代理类进行加载。
• interfaces：一个interface对象的数组，目的是声明代理类实现了这些接口，代理类就可以调用接口中声明的所有方法。
• InvocationHandler： 具体InvocationHandler接口的实现对象，表示当前动态代理对象关联到哪一个具体的InvocationHandler。

CGLIB实现动态代理

CGLIB 是通过继承来完成动态代理的。使用步骤如下：

• 实现MethodInterceptor接口，然后重写intercept方法，对被代理的方法进行功能增强
• 创建Enhancer类的对象，设置被代理的类，以及要对被代理的进行功能增强的MethodInterceptor
• 调用enhancer.create()创建代理类的实例，调用具体的实现

MethodInterceptor的示例:

lib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;
import java.util.Date;

public class CglibProxyInterceptor implements MethodInterceptor {

    /**
     *
     * @param o 表示要进行增强的对象
     * @param method 表示拦截的方法
     * @param objects 数组表示被拦截方法的参数列表
     * @param methodProxy  表示对方法的代理
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("前置动作，记录开始睡觉时间：" + new Date(System.currentTimeMillis()));
        // 对被代理对象方法的调用
        Object result = methodProxy.invokeSuper(o, objects);
        System.out.println("后置动作，记录结束睡觉时间：" + new Date(System.currentTimeMillis()));
        // 被代理方法的执行结果
        return result;
    }
    
}

测试：

import com.yutao.daily.yu.examples.cases.StaticProxy.PersonImpl;
import org.springframework.cglib.proxy.Enhancer;

public class DynamicCglibProxyTest {

    public static void main(String[] args) {

        // 创建Enhancer对象
        Enhancer enhancer = new Enhancer();
        // 设置被代理的类
        enhancer.setSuperclass(PersonImpl.class);
        // 设置回调函数
        enhancer.setCallback(new CglibProxyInterceptor());
        // create方法正式创建代理类
        PersonImpl person = (PersonImpl) enhancer.create();
        person.sleep();
    }
}

输出结果：

前置动作，记录开始睡觉时间：Sat Dec 02 15:54:08 CST 2023
睡觉中.........
后置动作，记录结束睡觉时间：Sat Dec 02 15:54:08 CST 2023

参考文章

• Java动态代理InvocationHandler和Proxy学习笔记： https://blog.csdn.net/yaomingyang/article/details/80981004
• Java动态代理之一CGLIB详解： https://zhuanlan.zhihu.com/p/115744594
• 动态代理：Java开发必学: https://zhuanlan.zhihu.com/p/128538288