代理模式详解 — 静态代理与动态代理

如果把代理模式的本质用伪代码表达，就是：

// 代理类的"灵魂"就在这一个方法里
public void doWork() {
    // ===== 前置增强：代理的附加逻辑 =====
    before();

    // ===== 委托：真正干活的是目标对象 =====
    target.doWork();

    // ===== 后置增强：代理的附加逻辑 =====
    after();
}

静态代理和动态代理的区别，仅仅在于这个代理类是怎么来的：

• 静态代理：你手写 StaticProxy.java，编译时就有了
• 动态代理：JVM 在运行时动态生成代理类的字节码，没 .java文件

品牌方不知道也不需要知道明星在干嘛（代理对调用方透明），但最终还是要明星亲自去拍广告、唱歌、演戏（真正的活还得目标对象干）。经纪人（代理）帮明星过滤邀约、谈价格、排档期——不修改明星的行为，但增加了额外功能。

// ========== 1. 定义接口 ==========
interface Service {
    void doWork();
}

// ========== 2. 目标类（真正干活的） ==========
class RealService implements Service {
    public void doWork() {
        System.out.println("RealService: 干活");
    }
}

// ========== 3. 代理类（增强 + 委托） ==========
class StaticProxy implements Service {
    private Service target;          // 持有目标对象的引用

    public StaticProxy(Service target) {
        this.target = target;        // 通过构造器注入目标
    }

    public void doWork() {
        System.out.println("前置：日志");   // 前置增强
        target.doWork();                   // 委托给目标
        System.out.println("后置：事务");   // 后置增强
    }
}

// ========== 4. 使用 ==========
public class Main {
    public static void main(String[] args) {
        Service real = new RealService();        // 创建目标对象
        Service proxy = new StaticProxy(real);   // 用代理包装目标
        proxy.doWork();                          // 调用代理，代理增强 + 委托
    }
}

输出：

前置：日志
RealService: 干活
后置：事务

Java 动态代理的核心是 java.lang.reflect.Proxy和 InvocationHandler：

newProxyInstance()需要三个参数：

1. ClassLoader：用哪个类加载器加载生成的代理类（通常用目标类的 ClassLoader）
2. 接口数组：代理类要实现哪些接口（可同时代理多个接口）
3. InvocationHandler：所有方法调用都转发到这个 handler 的 invoke 方法

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

// ========== 接口和目标类同上 ==========
interface Service {
    void doWork();
}

class RealService implements Service {
    public void doWork() {
        System.out.println("RealService: 干活");
    }
}

// ========== 使用动态代理 ==========
public class DynamicProxyDemo {
    public static void main(String[] args) {
        // 1. 创建目标对象
        Service real = new RealService();

        // 2. 创建动态代理实例
        Service proxy = (Service) Proxy.newProxyInstance(
            real.getClass().getClassLoader(),      // 参数1：类加载器
            real.getClass().getInterfaces(),        // 参数2：目标实现的接口
            new InvocationHandler() {               // 参数3：调用处理器
                @Override
                public Object invoke(
                        Object proxy,               // 代理实例自身
                        Method method,              // 被调用的方法
                        Object[] args               // 方法参数
                ) throws Throwable {
                    System.out.println("前置：日志");            // 前置增强
                    // 反射调用目标对象的真正方法
                    Object result = method.invoke(real, args); // 委托
                    System.out.println("后置：事务");            // 后置增强
                    return result;
                }
            }
        );

        // 3. 调用代理方法
        proxy.doWork();
    }
}

输出与静态代理完全一致：

前置：日志
RealService: 干活
后置：事务

一个自然的疑问：既然代理对象的每个方法都只是转发给 handler.invoke()，那为什么不直接调用 handler.invoke()呢？为什么还需要 Proxy.newProxyInstance()生成的那个代理对象？

答案是：Proxy 对象不是可有可无的中间人，它承担着不可替代的关键角色。

用代码对比来感受差异：

// =====  没有 Proxy：调用方必须手动处理反射 =====
InvocationHandler handler = new InvocationHandler() {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置：日志");
        Object result = method.invoke(real, args);
        System.out.println("后置：事务");
        return result;
    }
};

// 调用方每次都要手动反射，痛苦！
Method method = Calculator.class.getMethod("add", int.class, int.class);
Object result = handler.invoke(null, method, new Object[]{3, 5});
// 没有类型安全，编译器不检查，IDE 不补全，异常要 try-catch


// =====  有 Proxy：调用方像调用普通对象一样自然 =====
Calculator proxy = (Calculator) Proxy.newProxyInstance(
    real.getClass().getClassLoader(),
    real.getClass().getInterfaces(),
    handler
);

int result = proxy.add(3, 5);  // 类型安全！IDE 自动补全！编译器检查！
// 调用者完全不知道背后有 InvocationHandler 在干活

无论静态还是动态，代理的核心思想都是一样的：代理站在调用方和目标之间，既能让调用方无感使用（接口相同），又能拦截每个方法调用（委托 + 增强）。