动态代理：为你的代码增添灵活性

Ozl_from_Guet_码到成功

已于 2024-08-08 08:20:28 修改

阅读量580

点赞数 16

分类专栏：设计模式文章标签： java 动态代理 proxy模式

于 2024-08-08 08:19:27 首次发布

本文链接：https://blog.csdn.net/m0_62993574/article/details/141014283

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

导言

在软件开发中，动态代理是一种强大的设计模式。它允许你在运行时动态地创建对象，并定义方法调用的处理逻辑。通过动态代理，你可以在不修改现有代码的情况下增强功能，比如添加日志、权限检查等。

动态代理的核心思想

想象一下，你是一位忙碌的老板，需要一个助理来帮助处理事务。这位助理不仅能签合同，还能处理其他事务，比如开会、审核文件等。你可以随时告诉助理需要处理哪些事务，而不需要在一开始就为每个任务指定特定的代理人。这种灵活性正是动态代理的魅力所在。

动态代理的工作流程

创建代理： 你需要一个可以根据需要处理不同事务的助理，这位助理能够动态处理事务。
指定处理逻辑： 告诉助理每当处理一个事务时，该怎么做。例如，签合同时要注意合同条款，开会时要记录会议纪要等。
执行事务： 当需要处理事务时，比如签合同，助理会按照指定的逻辑进行操作。

角色对应

你（老板）： 被代理的对象（真实对象）。
助理： 代理对象。
事务（签合同、开会等）： 方法调用。
指定处理逻辑： 代理对象的增强逻辑。

动态代理的具体实现

在 Java 中，实现动态代理的核心在于 InvocationHandler 接口和创建代理对象。以下是一个完整的实现流程，包括代码示例和说明。

步骤 1：定义接口

首先，定义一个接口，代理类将实现这个接口。

public interface MyService {
    void doSomething(); // 定义一个方法，代理类将实现这个方法
}

步骤 2：实现接口

然后，实现这个接口，这将是我们的目标对象。

public class MyServiceImpl implements MyService {
    @Override
    public void doSomething() { // 实现接口中定义的方法
        System.out.println("Doing something..."); // 打印一条消息
    }
}

步骤 3：实现 `InvocationHandler`

实现 InvocationHandler 接口，这个类将负责处理对代理对象方法的调用。

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

public class MyServiceProxy implements InvocationHandler { // 实现InvocationHandler接口，用于自定义代理对象的行为

    private Object targetObject; // 目标对象，即我们想要代理的真实对象
    
    /**
     * 创建代理对象
     * @param targetObject 目标对象
     * @return 代理对象
     */
    public Object createProxyObject(Object targetObject) { // 创建代理对象的方法
        this.targetObject = targetObject; // 将传入的目标对象赋值给成员变量
        return Proxy.newProxyInstance( // 调用 Proxy 类的静态方法 newProxyInstance
                targetObject.getClass().getClassLoader(), // 获取目标对象的类加载器
                targetObject.getClass().getInterfaces(), // 获取目标对象实现的接口数组
                this); // 将当前的InvocationHandler实例作为参数传递，用于拦截代理对象的方法调用
    }

    /**
     * 拦截代理对象的方法调用
     * @param proxy 代理对象
     * @param method 被调用的方法
     * @param args 方法参数
     * @return 方法调用结果
     * @throws Throwable 可能抛出的异常
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 拦截代理对象的方法调用
        System.out.println("Before method call"); // 在调用目标方法之前打印日志
        
        Object result = method.invoke(targetObject, args); // 调用目标对象的方法
        
        System.out.println("After method call"); // 在调用目标方法之后打印日志
        
        //处理完目标对象的方法后的AOP如（日志记录、性能监控……）
        
        return result; // 返回方法调用的结果
    }
}

步骤 4：创建代理对象

使用 Proxy.newProxyInstance 方法创建代理对象。

public class DynamicProxyDemo {
    public static void main(String[] args) {
        MyService proxy = (MyService) new MyServiceProxy().createProxyObject(new MyServiceImpl()); // 创建 InvocationHandler 实例并生成代理对象

        // 调用代理对象的方法，这将触发 MyServiceProxy 中的 invoke 方法
        proxy.doSomething();
    }
}

动态代理的工作原理

“拦截代理对象的方法调用” 是指在动态代理机制中，当代理对象的某个方法被调用时，该调用不会直接执行目标对象的方法实现，而是先被转发到 InvocationHandler 的 invoke 方法中。在 invoke 方法内，你可以定义在实际调用目标方法之前或之后要执行的任何代码，例如日志记录、权限检查、事务处理等。