Java 動態代理實戰：JDK Proxy 與 InvocationHandler 核心機制深度解析

動態代理是 Spring AOP、RPC 框架、緩存攔截、事務管理等無數框架的基石。JDK 原生 `java.lang.reflect.Proxy` 運行時生成實現指定介面的代理類，將方法調用分派到 `InvocationHandler`。本文剖析核心機制、實戰權限控制場景、字節碼結構、性能優化與 CGLIB 對比。

核心架構三要素

Subject (介面)
    ↑ 實現
RealSubject (真實對象) ←—— 委託 ——→ InvocationHandler (攔截邏輯)
    ↑                                          ↑
    └────────── Proxy.newProxyInstance ───────┘
                    生成代理類 $Proxy0
                    實現 Subject
                    持有 InvocationHandler 引用
                    方法調用 → handler.invoke(proxy, method, args)

核心 API 速覽

// 唯一入口：生成代理實例
public static Object newProxyInstance(
    ClassLoader loader,           // 代理類加載器 (通常用目標類加載器)
    Class[] interfaces,        // 代理實現的介面列表 (至少一個)
    InvocationHandler h           // 方法調用攔截器
)

// InvocationHandler 核心方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;

實戰場景：基於角色的方法級權限控制

1. 業務介面

public interface UserService {
    String getName();
    String getEmail();
    void setName(String name);
    void setEmail(String email);
    void deleteUser();           // 敏感操作
    void changePassword(String newPwd);
}

2. 真實實現

public class UserServiceImpl implements UserService {
    private String name;
    private String email;
    // 實現略...
}

3. 權限攔截器

public class PermissionInvocationHandler implements InvocationHandler {
    private final UserService target;
    private final String currentUserRole; // ADMIN / USER / GUEST
    
    public PermissionInvocationHandler(UserService target, String role) {
        this.target = target;
        this.currentUserRole = role;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        
        // 1. 管理員全權限
        if ("ADMIN".equals(currentUserRole)) {
            return method.invoke(target, args);
        }
        
        // 2. 普通用戶：可讀、可改自身資料、可改密碼，不可刪除用戶
        if ("USER".equals(currentUserRole)) {
            if (methodName.startsWith("get") || 
                methodName.equals("setName") || 
                methodName.equals("setEmail") ||
                methodName.equals("changePassword")) {
                return method.invoke(target, args);
            }
            if (methodName.equals("deleteUser")) {
                throw new AccessDeniedException("USER role cannot delete user");
            }
        }
        
        // 3. 訪客：僅可讀
        if ("GUEST".equals(currentUserRole)) {
            if (methodName.startsWith("get")) {
                return method.invoke(target, args);
            }
            throw new AccessDeniedException("GUEST role read-only");
        }
        
        throw new AccessDeniedException("Unknown role: " + currentUserRole);
    }
}

4. 代理工廠與測試

public class ProxyFactory {
    public static UserService createProxy(UserService target, String role) {
        return (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new PermissionInvocationHandler(target, role)
        );
    }
}

// 測試
public static void main(String[] args) {
    UserService real = new UserServiceImpl();
    real.setName("Alice");
    real.setEmail("alice@example.com");
    
    UserService adminProxy = ProxyFactory.createProxy(real, "ADMIN");
    UserService userProxy = ProxyFactory.createProxy(real, "USER");
    UserService guestProxy = ProxyFactory.createProxy(real, "GUEST");
    
    System.out.println("Admin delete: "); adminProxy.deleteUser(); // 成功
    System.out.println("User delete: "); 
    try { userProxy.deleteUser(); } catch (AccessDeniedException e) { System.out.println("Denied: " + e.getMessage()); }
    System.out.println("Guest setName: ");
    try { guestProxy.setName("Bob"); } catch (AccessDeniedException e) { System.out.println("Denied: " + e.getMessage()); }
}

JDK 動態代理字節碼結構解析

生成的 `$Proxy0` 類特徵：

• 繼承 `java.lang.reflect.Proxy`
• 實現目標所有介面
• 每個方法構造 `Method` 對象 (靜態常量池緩存)
• 方法體極簡：`return super.h.invoke(this, mX, args);`
• 靜態初始化塊預先解析所有 `Method` 對象 (反射開銷前置)

// 反編譯 $Proxy0 概貌
public final class $Proxy0 extends Proxy implements UserService {
    private static final Method m0, m1, m2, m3, m4, m5; // getName, getEmail, setName, setEmail, deleteUser, changePassword
    
    static {
        try {
            m0 = UserService.class.getMethod("getName");
            m1 = UserService.class.getMethod("getEmail");
            m2 = UserService.class.getMethod("setName", String.class);
            m3 = UserService.class.getMethod("setEmail", String.class);
            m4 = UserService.class.getMethod("deleteUser");
            m5 = UserService.class.getMethod("changePassword", String.class);
        } catch (NoSuchMethodException e) { throw new NoSuchMethodError(e.getMessage()); }
    }
    
    public $Proxy0(InvocationHandler h) { super(h); }
    
    public String getName() { 
        try { return (String) super.h.invoke(this, m0, null); }
        catch (Error|RuntimeException e) { throw e; }
        catch (Throwable e) { throw new UndeclaredThrowableException(e); }
    }
    // 其他方法同理...
}

關鍵限制與最佳實踐

性能優化建議

• Method 對象緩存：JDK Proxy 靜態初始化已緩存，自定義 `InvocationHandler` 內部勿重複 `getMethod`。
• 避免反射調用開銷：熱點路徑改用 `MethodHandle` / `VarHandle` / Lambda 元工廠 (JDK 8+ `LambdaMetafactory`) 生成直接調用句柄。
• 輕量級 InvocationHandler：無狀態、單例、無同步鎖、邏輯簡單 (如委託給策略 Map)。
• 考慮 ByteBuddy 生成子類代理：無介面限制、性能接近直接調用、支援字段攔截、方法重寫。

JDK Proxy vs CGLIB vs ByteBuddy 選型

總結

JDK 動態代理以「介面 + InvocationHandler」極簡模型，賦能 AOP、RPC、安全、監控等橫切關注點分離。掌握其生成機制、限制邊界、性能特徵，是閱讀 Spring 源碼、設計擴展點、排查代理相關 Bug 的核心功力。現代框架開發建議：業務面向介面 + JDK Proxy 為主，ByteBuddy 解決介面限制與極致性能，CGLIB 維護兼容。