Spring 动态代理详解

2. 编写调用处理器

这是最关键的一步。我们需要实现 InvocationHandler 接口，在这里决定代理对象被调用时具体做什么。

package com.example.demo.proxy;

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

public class ProxyInvocationHandler implements InvocationHandler {

    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    // 生成代理对象
    public Object getProxy() {
        return Proxy.newProxyInstance(
            this.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            this
        );
    }

    // 拦截方法调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置处理：比如记录日志
        System.out.println("执行了 " + method.getName() + " 方法");
        
        // 核心逻辑：反射调用真实对象的方法
        Object result = method.invoke(target, args);
        
        // 后置处理
        return result;
    }
}

这里有个细节要注意：invoke 方法里的 method.invoke(target, args) 才是真正执行业务逻辑的地方。我们在它前后加入的逻辑，就是所谓的'横切关注点'。

3. 客户端调用

最后，客户端只需要持有代理对象，就像使用普通对象一样。

package com.example.demo.client;

import com.example.demo.UserService;
import com.example.demo.UserServiceImpl;
import com.example.demo.proxy.ProxyInvocationHandler;

public class Client {
    public static void main(String[] args) {
        // 真实角色
        UserServiceImpl userService = new UserServiceImpl();

        // 创建代理处理器
        ProxyInvocationHandler handler = new ProxyInvocationHandler();
        handler.setTarget(userService);

        // 获取代理对象
        UserService proxy = (UserService) handler.getProxy();
        
        // 调用代理方法
        proxy.add();
    }
}

总结

与静态代理不同，在这个实例中我们没有手动创建具体的代理类，而是让动态代理机制在运行时自动生成。这意味着多个不同的真实角色可以复用同一个代理类，极大地提高了开发效率。这种灵活性正是 Spring 能够轻松实现 AOP 等功能的基础。