Java动态代理的实现方式

Mr_Richard

于 2024-07-08 19:58:37 发布

阅读量532

点赞数 10

分类专栏： JavaSE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/Mr_Richard/article/details/140277523

版权

JavaSE 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Java动态代理的实现方式

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

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

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

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

1. JDK动态代理

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

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

举例：

定义接口

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

定义被代理类实现接口

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;
    }
}

定义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;
    }
}

定义代理类的创建工厂

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 接口的对象
    }
}

测试
```
@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 用于拦截增强被代理类的方法。步骤如下：

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

举例：

引入cglib依赖

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

定义被代理类

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;
    }
}

定义方法拦截器

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;
    }
}

定义代理类的创建工厂

/**
 * 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();
    }
}

测试

@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 动态代理。

Mr_Richard

关注

10
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
Java动态代理的实现方式

代理模式是一种设计模式，，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，。代理分为动态代理和静态代理。举例：通过中介进行的商品交易，中介就是代理，代替卖方进行商品销售。静态代理比较麻烦，需要对每个目标对象都设置专用的代理类，实际开发中很少使用。动态代理是的一种技术。**从 JVM 角度来说，动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。
复制链接

扫一扫