JDK動态代理和CGLIB位元組碼增強

一、JDK動态代理

Java 在 java.lang.reflect 包中有自己的代理支援，該類（Proxy.java）用于動态生成代理類，隻需傳入目标接口、目标接口的類加載器以及 InvocationHandler 便可為目标接口生成代理類及代理對象。我們稱這個Java技術為：動态代理

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
//...
}
           

在 Java 中規定，要想産生一個對象的代理對象，那麼這個對象必須要有一個接口，是以 interfaces 必須是一個接口。

在動态代理技術裡，由于不管使用者調用代理對象的什麼方法，都是調用開發人員編寫的 InvocationHandler 的 invoke 方法（這相當于 invoke 方法攔截到了代理對象的方法調用）。

是以 JDK 動态代理的整體流程為：

1. 實作 InvocationHandler，用來處理對象攔截後的邏輯。（該對象必須是接口，或者父類是接口）
2. 使用 Proxy.newProxyInstance 産生代理對象。

以下是一個用 JDK 動态代碼實作 AOP 的具體例子：

1.目标（Target）類

public interface UserService {
    void eat();
}
           

public class UserServiceImpl implements UserService {
    @Override
    public void eat() {
        System.out.println("吃東西");
    }
}
           

2.切面（Aspect）類

public class MyAspect {
    /**
     * 前置通知
     */
    public void before() {
        System.out.print("先洗手再");
    }
}
           

3. 織入（Weaving）過程

/**
 * 産生代理對象的工廠類
 */
public class MyFactoryBean {

    private MyFactoryBean() {
    }
    
    public static UserService getInstance() {
        // target ： 目标類
        final UserService userService = new UserServiceImpl();
        // Aspect : 切面類
        final MyAspect myAspect = new MyAspect();
        // Weaving : 織入，也就是産生代理的過程
        UserService proxyInstance = (UserService) Proxy.newProxyInstance(UserService.class.getClassLoader(),
                new Class[]{UserService.class}, (Object proxy, Method method, Object[] args) -> {
                    // 模拟切點 - pointcut
                    if ("eat".equals(method.getName())) {
                        myAspect.before();
                    }
                    return method.invoke(userService, args);
                });
        return proxyInstance;
    }
}
           

public static void main(String[] args) {
        UserService userService = MyFactoryBean.getInstance();
        // 先洗手再吃東西
        userService.eat();
    }
           

想想看，這其實跟我們平常使用的 AOP 已經很相似了，Spring 裡面定義了前置通知（@Before）、異常通知（@AfterThrowing）等等，Spring 隻是換成了甄别這些注解來選擇什麼時候調用通知方法，另外，Spring 還通過切點表達式來選擇目标類和切入點。

二、CGLIB動态代理

CGLIB 動态代理需要引入第三方的庫，它通過修改代理對象生成子類的方式來實作調用攔截，代理對象不需要實作接口，但是代理類不能是 final，代理的方法也不能是 final。

/**
 * 産生代理對象的工廠類
 */
public class MyFactoryBean {

    private MyFactoryBean() {
    }

    public static UserService getInstance() {
        // target ： 目标類
        final UserService userService = new UserServiceImpl();
        // Aspect : 切面類
        final MyAspect myAspect = new MyAspect();
        // Weaving : 織入，也就是産生代理的過程
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(userService.getClass());
        enhancer.setUseCache(false);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                // 模拟 pointcut-切點
                if ("eat".equals(method.getName())) {
                    myAspect.before();
                }
                return methodProxy.invokeSuper(o, objects);
            }
        });
        return (UserService) enhancer.create();
    }

    public static void main(String[] args) {
        UserService proxyInstance = MyFactoryBean.getInstance();
        // 先洗手再吃東西
        proxyInstance.eat();
    }
}
           

三、總結

在 JDK 中實作動态代理時，要求代理類必須是接口或繼承接口的類，因為 JDK 最後生成的 proxy class 其實就是實作了代理類所代理的接口并且繼承了 java 中的 Proxy 類（繼承 Proxy 類是為了判斷該類是否為代理類），通過反射找到接口的方法，調用 InvocationHandler的invoke 方法實作攔截。

CGLIB 位元組碼增強是JDK動态代理的一個很好的補充， CGLIB 中最後生成的 proxy class 是一個繼承代理類所代理的 class，通過重寫被代理類中的非 final 的方法實作代理。

總結為：

• JDK 動态代理：代理類必須是接口或繼承接口的類。
• CGLIB 位元組碼增強： 代理類不能是 final，代理的方法也不能是 final（繼承限制） 。

關于在 Spring 的 AOP 中采用何種代理手段，我們不強加限制的話，會根據類是否有接口來差別對待：

1. 當一個類有接口的時候，就會選用 JDK 的動态代理。
2. 當一個類沒有實作接口的時候，就會選用 CGLIB 代理的方式。