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 代理的方式。