Java代理模式

最新推荐文章于 2025-04-02 18:31:21 发布

Kichlvichn·хуту

最新推荐文章于 2025-04-02 18:31:21 发布

阅读量416

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.youkuaiyun.com/qq_43959027/article/details/124154939

版权

Java 专栏收录该内容

12 篇文章

订阅专栏

1. 代理模式

使用代理对象来代替对真实对象的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。

代理模式有静态代理和动态代理两种实现方式。

2. 静态代理

静态代理中，对目标对象的每个方法的增强都是手动完成的，非常不灵活（比如接口一旦新增加方法，目标对象和代理对象都要进行修改）且麻烦(需要对每个目标类都单独写一个代理类)。实际应用场景非常非常少。

从 JVM 层面来说，静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。

静态代理实现步骤:

定义一个接口及其实现类
创建一个代理类同样实现这个接口
将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些事情。

例如：
定义打印日志的接口

interface LogService{
    String printConsoleLogs(String log);
}

实现打印日志的接口

class LogServiceImpl implements LogService{
    @Override
    public String printConsoleLogs(String log) {
        System.out.println("log i : " + log);
        return log;
    }
}

创建代理类并同样实现打印日志的接口

class LogProxy implements LogService{

    private final LogService logService;

    LogProxy(LogService logService){
        this.logService = logService;
    }

    @Override
    public String printConsoleLogs(String log) {
        System.out.println("before");
        logService.printConsoleLogs(log);
        System.out.println("after");
        return null;
    }
}

实际使用

public class Demo{
    public static void main(String[] args) {
        LogService logger = new LogServiceImpl();
        LogProxy logProxy = new LogProxy(logger);
        logProxy.printConsoleLogs("error");
    }
}

3. 动态代理

动态代理更加灵活。不需要针对每个目标类都单独创建一个代理类，并且也不需要必须实现接口，可以直接代理实现类( CGLIB 动态代理机制)。

从 JVM 角度来说，动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。

Spring AOP、RPC 框架它们的实现都依赖了动态代理。

动态代理的实现方式有很多种，比如 JDK 动态代理、CGLIB 动态代理等等。

3.1. JDK 动态代理机制

3.1.1. 介绍

在 Java 动态代理机制中 InvocationHandler 接口和 Proxy 类是核心。

Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象。

/**
* loader :类加载器，用于加载代理对象。
* interfaces : 被代理类实现的一些接口；
* h : 实现了 InvocationHandler 接口的对象；
**/
@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
        //pass
    }

要实现动态代理的话，还必须需要实现InvocationHandler 来自定义处理逻辑。当我们的动态代理对象调用一个方法时，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用。

/**
     * 当使用代理对象调用方法的时候实际会调用到这个方法
     * @param proxy:动态生成的代理类
     * @param method : 与代理类对象调用的方法相对应
     * @param objects : 当前 method 方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] objects) throws Throwable {
        return null;
    }

通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

3.1.2 JDK 动态代理类使用步骤

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

示例：

定义打印日志的接口

interface LogService{
    String printConsoleLogs(String log);
}

实现打印日志的接口

class LogServiceImpl implements LogService{
    @Override
    public String printConsoleLogs(String log) {
        System.out.println("log i : " + log);
        return log;
    }
}

定义一个 JDK 动态代理类

class DynamicInvocationHandler implements InvocationHandler{

    private final Object target;

    public DynamicInvocationHandler(Object obj){
        target = obj;
    }

    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {

        System.out.println("before : " + method.getName());
        Object result = method.invoke(target, objects);
        System.out.println("after : " + method.getName());

        return result;
    }
}

invoke() 方法: 当动态代理对象调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法代替我们去调用了被代理对象的原生方法。

获取代理对象的工厂类

class ProxyFactory{
    public static Object getProxy(Object target){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new DynamicInvocationHandler(target));
    }
}

getProxy() ：主要通过Proxy.newProxyInstance（）方法获取某个类的代理对象

5.实际使用

public class Demo{
    public static void main(String[] args) {
        LogService logger = new LogServiceImpl();
        LogService logService = (LogService)ProxyFactory.getProxy(logger);
        logService.printConsoleLogs("jdk");
    }
}

3.2 CGLIB 动态代理机制

3.2.1. 介绍

JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心。
需要自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法。

/**
*obj :被代理的对象（需要增强的对象）
*method :被拦截的方法（需要增强的方法）
*args :方法入参
*proxy :用于调用原始方法
**/
public interface MethodInterceptor
extends Callback{
    // 拦截被代理类中的方法
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                               MethodProxy proxy) throws Throwable;
}

可以通过 Enhancer类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法。

3.2.2. CGLIB 动态代理类使用步骤

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

示例：
实现一个使用阿里云发送短信的类

public class AliSmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

自定义 MethodInterceptor（方法拦截器）

/**
 * 自定义MethodInterceptor
 */
public class DebugMethodInterceptor implements MethodInterceptor {


    /**
     * @param o           代理对象（增强的对象）
     * @param method      被拦截的方法（需要增强的方法）
     * @param args        方法入参
     * @param methodProxy 用于调用原始方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object object = methodProxy.invokeSuper(o, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return object;
    }

}

获取代理类

public class CglibProxyFactory {

    public static Object getProxy(Class<?> clazz) {
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new DebugMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}

实际使用

AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
aliSmsService.send("java");

3.3. JDK 动态代理和 CGLIB 动态代理对比

JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。另外， CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。
就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

4. 静态代理和动态代理的对比

灵活性：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改
JVM 层面：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。