Java 動態代理深度解析：從核心原理到實戰應用

引言：為什麼需要動態代理？

在 Spring AOP、RPC 框架、事務管理、日誌攔截等無數經典場景中，動態代理都是核心基石。相較於靜態代理（手寫代理類），動態代理能在運行時動態生成代理類字節碼，實現「寫一次攔截邏輯，處處復用」的極致解耦。本文將從角色劃分、核心 API、字節碼生成機制、實戰陷阱四個維度徹底講透 JDK 動態代理。

三大核心角色重新定義

關鍵限制：JDK 動態代理強制要求目標類實現至少一個介面。若目標類未實現介面，必須改用 CGLIB（繼承子類代理）或 ByteBuddy 等字節碼操作庫。

核心雙雄：InvocationHandler 與 Proxy

InvocationHandler：攔截器的靈魂

@FunctionalInterface
public interface InvocationHandler {
    /**
     * @param proxy  代理對象自身引用（極少直接使用）
     * @param method 被調用的介面方法（含聲明異常、泛型等元數據）
     * @param args   實際參數值陣列
     * @return 方法返回值
     * @throws Throwable 任意異常，將拋回調用方
     */
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

每個代理對象持有一個 InvocationHandler 實例。當調用代理方法時，JVM 會將調用重定向到 invoke()，開發者在其中實現：前置增強、參數校驗、事務開啟、調用真實對象、後置增強、異常處理、結果包裝等邏輯。

Proxy.newProxyInstance()：代理工廠方法

public static Object newProxyInstance(
    ClassLoader loader,        // 代理類加載器，通常用目標類的 getClassLoader()
    Class[] interfaces,     // 代理需實現的介面陣列（決定代理類類型）
    InvocationHandler h        // 方法調用處理器
) throws IllegalArgumentException

該方法內部流程：

1. 驗證介面合法性（皆為介面、非重複、可見性檢查）
2. 生成代理類字節碼（類名 com.sun.proxy.$ProxyN，實現所有指定介面）
3. 定義構造函數接收 InvocationHandler
4. 實例化代理對象並返回

完整實戰代碼：從入門到生產級寫法

1. 定義業務契約

public interface UserService {
    void register(String username, String password);
    User findById(Long id);
}

2. 真實業務實現

public class UserServiceImpl implements UserService {
    @Override
    public void register(String username, String password) {
        System.out.printf("[業務] 註冊用戶: %s%n", username);
        // 模擬 DB 操作
    }

    @Override
    public User findById(Long id) {
        System.out.printf("[業務] 查詢用戶 ID: %d%n", id);
        return new User(id, "user_" + id);
    }
}

3. 通用攔截器（支援日誌、事務、效能監控）

public class LoggingInterceptor implements InvocationHandler {

    private final Object target;

    public LoggingInterceptor(Object target) {
        this.target = Objects.requireNonNull(target);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        long start = System.nanoTime();

        try {
            System.out.printf("[前置] %s 開始執行，參數: %s%n", methodName, Arrays.toString(args));
            Object result = method.invoke(target, args); // 反射調用真實對象
            System.out.printf("[後置] %s 執行成功，耗時: %.2f ms%n", methodName, (System.nanoTime() - start) / 1e6);
            return result;
        } catch (InvocationTargetException e) {
            System.err.printf("[異常] %s 拋出異常: %s%n", methodName, e.getCause());
            throw e.getCause(); // 拋出真實業務異常
        }
    }
}

4. 客戶端使用與類型轉換原理

public class Client {
    public static void main(String[] args) {
        UserService real = new UserServiceImpl();
        UserService proxy = (UserService) Proxy.newProxyInstance(
            real.getClass().getClassLoader(),
            real.getClass().getInterfaces(), // 關鍵：代理類實現了相同介面
            new LoggingInterceptor(real)
        );

        proxy.register("alice", "secret123");
        User u = proxy.findById(1001L);
        System.out.println("返回對象: " + u);
    }
}

為何能強轉為 UserService？ 生成的 $Proxy0 類聲明實現了 UserService 介面（由第二個參數決定），因此滿足「是一個」關係，編譯與運行期均合法。

System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
// 或 JVM 參數 -Dsun.misc.ProxyGenerator.saveGeneratedFiles=true

public final class $Proxy0 extends Proxy implements UserService {
    protected $Proxy0(InvocationHandler h) { super(h); }

    public final void register(String username, String password) throws Throwable {
        super.h.invoke(this, m1, new Object[]{username, password}); // m1 為 Method 對象
    }

    public final User findById(Long id) throws Throwable {
        return (User) super.h.invoke(this, m2, new Object[]{id});
    }

    // 繼承自 Proxy 的 equals/hashCode/toString 也會被攔截
    static { /* 初始化 Method 對象 m1, m2... */ }
}

if (method.getDeclaringClass() == Object.class) {
    return method.invoke(this, args); // 直接走默認邏輯
}

catch (InvocationTargetException e) {
    throw e.getCause(); // 而非 throw e，否則外層捕獲的是 InvocationTargetException
}