Java动态代理的实现方式

Java动态代理的实现方式

代理模式是一种设计模式，使用代理对象来代替对目标对象(real object)的访问 ，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。代理分为动态代理和静态代理。

举例：通过中介进行的商品交易，中介就是代理，代替卖方进行商品销售。

静态代理比较麻烦，需要对每个目标对象都设置专用的代理类，实际开发中很少使用。

动态代理是在程序运行期间创建目标对象的代理对象，并对目标对象中的方法进行功能性增强的一种技术。**从 JVM 角度来说，动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。**Java常见的的动态代理有以下两种方式：

1. JDK动态代理

通过Java动态代理机制，借助Proxy.newInstance()方法实现，但这种方式需要被代理类实现了接口才有效。步骤如下：

1. 定义一个接口及其实现类（被代理类）；
2. 自定义类实现 InvocationHandler 接口并重写invoke方法，在 invoke 方法中我们会调用目标对象的方法（被代理类的方法）并自定义一些处理逻辑；
3. 通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象，参数依次为代理对象的类加载器、被代理对象实现的接口和实现 InvocationHandler 接口的对象。

举例：

1. 定义接口

   /**
    * MyService接口
    */
   public interface MyService {
       String reverse(String message);
   }

2. 定义被代理类实现接口

   import com.example.aop.service.MyService;
   import lombok.extern.slf4j.Slf4j;
   
   /**
    * MyService接口实现类
    *
    * @author: hong.jian
    * @date 2024-07-08 16:44
    */
   @Slf4j
   public class MyServiceImpl implements MyService {
   
       @Override
       public String reverse(String message) {
           log.info("MyServiceImpl-reverse方法参数：{}", message);
           String res = new StringBuilder(message).reverse().toString();
           log.info("MyServiceImpl-reverse方法返回值：{}", res);
           return res;
       }
   }

3. 定义JDK动态代理类

   import lombok.extern.slf4j.Slf4j;
   import net.sf.cglib.proxy.MethodInterceptor;
   import net.sf.cglib.proxy.MethodProxy;
   
   import java.lang.reflect.Method;
   import java.util.Arrays;
   
   /**
    * 自定义MethodInterceptor方法拦截器
    */
   @Slf4j
   public class MyMethodInterceptor implements MethodInterceptor {
       /**
        * @param o           被代理的对象（需要增强的对象）
        * @param method      被拦截的方法（需要增强的方法）
        * @param args        方法参数
        * @param methodProxy 用于调用原始方法
        */
       @Override
       public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
           log.info("MyInvocationHandler-目标方法执行之前方法打印，方法名称：{}，方法参数：{}", method.getName(), Arrays.toString(args));
           Object res = methodProxy.invokeSuper(o, args);  // 执行目标方法
           log.info("MyInvocationHandler-目标方法执行之后方法打印，方法名称：{}", method.getName());
           return res;
       }
   }

4. 定义代理类的创建工厂

   import com.example.aop.config.MyInvocationHandler;
   
   import java.lang.reflect.Proxy;
   
   /**
    * JDK动态代理创建
    * @author: hong.jian
    * @date 2024-07-08 16:51
    */
   public class JDKProxyFactory {
   
       /**
        * 通过Proxy.newProxyInstance（）方法获取target的代理对象
        */
       public static Object getProxy(Object target) {
           // 通过Proxy.newProxyInstance（）方法获取target的代理对象
           return Proxy.newProxyInstance(target.getClass().getClassLoader(),    // 类加载器，用于加载代理对象
                   target.getClass().getInterfaces(),  // 被代理类实现的一些接口
                   new MyInvocationHandler(target));    // 实现了 InvocationHandler 接口的对象
       }
   }

5. 测试

   @Test
   void test() {
       MyService myService = (MyService) JDKProxyFactory.getProxy(new MyServiceImpl());
       myService.reverse("Hello, world!");
   }

   控制台日志：

   2024-07-08 19:38:53.992 INFO 325852 --- [ main] c.e.aop.config.MyInvocationHandler : MyInvocationHandler-目标方法执行之前方法打印，方法名称：reverse，方法参数：[Hello, world!]

   2024-07-08 19:38:53.993 INFO 325852 --- [ main] c.e.aop.service.impl.MyServiceImpl : MyServiceImpl-reverse方法参数：Hello, world!

   2024-07-08 19:38:53.993 INFO 325852 --- [ main] c.e.aop.service.impl.MyServiceImpl : MyServiceImpl-reverse方法返回值：!dlrow ,olleH

   2024-07-08 19:38:53.993 INFO 325852 --- [ main] c.e.aop.config.MyInvocationHandler : MyInvocationHandler-目标方法执行之后方法打印，方法名称：reverse

2. Cglib动态代理

但JDK 动态代理只能代理实现了接口的类，使用起来有局限性。

Cglib动态代理通过 Enhancer类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 方法拦截器MethodInterceptor 中的 intercept 方法，intercept 用于拦截增强被代理类的方法。步骤如下：

1. 定义一个类；
2. 自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；
3. 通过 Enhancer 类的 create()创建代理类；

举例：

1. 引入cglib依赖

   <!-- cglib -->
   <dependency>
       <groupId>cglib</groupId>
       <artifactId>cglib</artifactId>
       <version>3.3.0</version>
   </dependency>

2. 定义被代理类

   import lombok.extern.slf4j.Slf4j;
   
   /**
    * 未实现接口的类SmsServiceImpl
    * @author: hong.jian
    * @date 2024-07-08 17:23
    */
   @Slf4j
   public class SmsServiceImpl {
   
       /**
        * 测试方法
        */
       public String send(String message) {
           log.info("SmsServiceImpl-send方法参数：{}", message);
           log.info("message:{}", message);
           log.info("SmsServiceImpl-send方法返回值：{}", message);
           return message;
       }
   }

3. 定义方法拦截器

   import lombok.extern.slf4j.Slf4j;
   import net.sf.cglib.proxy.MethodInterceptor;
   import net.sf.cglib.proxy.MethodProxy;
   
   import java.lang.reflect.Method;
   import java.util.Arrays;
   
   /**
    * 自定义MethodInterceptor方法拦截器
    */
   @Slf4j
   public class MyMethodInterceptor implements MethodInterceptor {
       /**
        * @param o           被代理的对象（需要增强的对象）
        * @param method      被拦截的方法（需要增强的方法）
        * @param args        方法参数
        * @param methodProxy 用于调用原始方法
        */
       @Override
       public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
           log.info("MyInvocationHandler-目标方法执行之前方法打印，方法名称：{}，方法参数：{}", method.getName(), Arrays.toString(args));
           Object res = methodProxy.invokeSuper(o, args);  // 执行目标方法
           log.info("MyInvocationHandler-目标方法执行之后方法打印，方法名称：{}", method.getName());
           return res;
       }
   }

4. 定义代理类的创建工厂

   /**
    * Cglib创建动态代理
    *
    * @author: hong.jian
    * @date 2024-07-08 17:22
    */
   public class CglibProxyFactory {
       /**
        * 通过Enhancer.create()方法创建代理类
        */
       public static Object getProxy(Class<?> clazz) {
           // 创建动态代理增强类
           Enhancer enhancer = new Enhancer();
           // 设置代理类的类加载器
           enhancer.setClassLoader(clazz.getClassLoader());
           // 设置被代理类
           enhancer.setSuperclass(clazz);
           // 设置方法拦截器
           enhancer.setCallback(new MyMethodInterceptor());
           return enhancer.create();
       }
   }

5. 测试

@Test
void test2() {
    SmsServiceImpl smsService = (SmsServiceImpl) CglibProxyFactory.getProxy(SmsServiceImpl.class);
    smsService.send("Hello, world!");
}

控制台日志：

2024-07-08 19:40:33.361  INFO 326440 --- [           main] c.e.aop.config.MyMethodInterceptor       : MyMethodInterceptor-目标方法执行之前方法打印，方法名称：send，方法参数：[Hello, world!]
2024-07-08 19:40:33.374  INFO 326440 --- [           main] c.e.aop.service.impl.SmsServiceImpl      : SmsServiceImpl-send方法参数：Hello, world!
2024-07-08 19:40:33.374  INFO 326440 --- [           main] c.e.aop.service.impl.SmsServiceImpl      : message:Hello, world!
2024-07-08 19:40:33.374  INFO 326440 --- [           main] c.e.aop.service.impl.SmsServiceImpl      : SmsServiceImpl-send方法返回值：Hello, world!
2024-07-08 19:40:33.374  INFO 326440 --- [           main] c.e.aop.config.MyMethodInterceptor       : MyMethodInterceptor-目标方法执行之后方法打印，方法名称：send

3. 两种方式对比

特点	JDK 动态代理	CGLIB 动态代理
代理目标性	只能代理实现了接口的类	可以代理没有实现接口的类，但不能代理final类
实现机制	通过反射机制生成代理类	通过生成目标类的子类实现代理
性能	由于使用了反射机制，性能较低	由于直接生成字节码，性能较高
依赖性	不需要额外的库，JDK 本身支持	需要引入 CGLIB 库

注： Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。