Spring AOP是執行時織入的，那麼執行時織入到底是怎麼實現的呢?答案就是代理物件。
代理又可以分為靜態代理和動態代理。

靜態代理：由程式設計師建立或特定工具自動生成原始碼，再對其編譯。在程式執行前，代理類的.class檔案就已經存在了。
動態代理：在程式執行時，運用反射機制動態建立而成。

靜態代理的每一個代理類只能為一個介面服務，這樣一來程式開發中必然會產生過多的代理，而且，所有的代理操作除了呼叫的方法不一樣之外，其他的操作都一樣，則此時肯定是重複程式碼。解決這一問題最好的做法是可以通過一個代理類完成全部的代理功能，那麼此時就必須使用動態代理完成。

動態代理 與靜態代理類對照的是動態代理類，動態代理類的位元組碼在程式執行時由Java反射機制動態生成，無需程式設計師手工編寫它的原始碼。動態代理類不僅簡化了程式設計工作，而且提高了軟體系統的可擴充套件性，因為Java 反射機制可以生成任意型別的動態代理類。java.lang.reflect 包中的Proxy類和InvocationHandler 介面提供了生成動態代理類的能力。

Spring AOP使用動態代理技術在執行期間織入增強的程式碼，主要有兩種代理機制：基於JDK的動態代理；基於CGLib的動態代理。JDK本身只提供介面的代理，而不支援類的代理。

代理模式

首先我們來了解代理模式的基本定義。
代理模式的英文叫做Proxy，就是一個人或者一個機構代表另一個人或者另一個機構採取行動。在一些情況下，一個客戶不想或者不能夠直接引用一個物件，而代理物件可以在客戶端和目標物件之間起到中介的作用 。

//Subject介面
public interface Subject {
    void request();
}

//目標物件RealSubject
 

public class RealSubject implements Subject{
    @Override
    public void request() {
        System.out.println("real subject execute request");
    }
}

//Proxy代理類
public class Proxy implements Subject{

    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this
 
.realSubject = realSubject;
    }

    @Override
    public void request() {
        System.out.println("before");
        try{
            realSubject.request();
        }catch (Exception e){
            System.out.println("ex:"+e.getMessage());
            throw e;
        }finally {
            System.out.println("after");
        }
    }
}

//Client客戶端
public class Client {
    public static void main(String[] args){
        Subject subject = new Proxy(new RealSubject());
        subject.request();
    }
}

這樣就會輸出:

before
real subject execute request
after

是不是達到和AOP一樣的效果了呢？AOP將真正要執行的程式碼交給RealSubject來執行，然後通過proxy來對額外的程式碼進行織入。

動態代理

上面的案例就是一個典型的靜態代理的案例，這樣有什麼缺點呢？
如果當你要代理的方法越多時，你需要重複的邏輯就越多，假設你的目標類有100個方法，那麼你的代理類就需要對這100個方法進行委託，但是又可能他們前後需要執行的邏輯時一樣的，這樣就會產生很多冗餘。
這樣，就有個更好的 動態代理的方法出現了。

動態代理也分為兩類：基於介面的代理和基於繼承的代理
兩類實現的代表是：JDK代理 與 CGlib代理

JDK代理模式

JDK動態代理主要涉及java.lang.reflect包下的兩個類：Proxy類和InvocationHandler介面。
JDK代理實現的三個要點：

1. 通過java.lang.reflect.Proxy類來動態生成代理類
2. 代理類要實現InvocationHandler介面
3. JDK代理只能基於介面進行動態代理的

//客戶端Client
public class Client {
    /*
    *newProxyInstance方法引數解析
    *ClassLoader loader：類載入器 
    *Class<?>[] interfaces：得到全部的介面 
    *InvocationHandler h：得到InvocationHandler介面的子類例項 
    */
    public static void main(String[] args){
        Subject subject = (Subject) Proxy.newProxyInstance(Client.class.getClassLoader(),new Class[]{Subject.class},new JdkProxySubject(new RealSubject()));
        subject.hello();
        subject.request();
    }
}

//代理類JdkProxySubject
public class JdkProxySubject implements InvocationHandler{

    private RealSubject realSubject;

    public JdkProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    /*
    *invoke方法方法引數解析
    *Object proxy：指被代理的物件。 
    *Method method：要呼叫的方法 
    *Object[] args：方法呼叫時所需要的引數 
    *InvocationHandler介面的子類可以看成代理的最終操作類。
    */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = null;
        try{
            //利用反射動態的來反射方法，這就是動態代理和靜態代理的區別
            result = method.invoke(realSubject,args);
        }catch (Exception e){
            System.out.println("ex:"+e.getMessage());
            throw e;
        }finally {
            System.out.println("after");
        }
        return result;
    }
}

//目標物件RealSubject
public class RealSubject implements Subject{
    @Override
    public void request() {
        System.out.println("real subject execute request");
    }

    @Override
    public void hello() {
        System.out.println("hello");
    }
}

//subject介面，這個是jdk動態代理必須的前提。
public interface Subject {
    void request();
    void hello();
}

輸出

before
hello
after
before
real subject execute request
after

我們在subject介面中新增加了一個hello()方法，然後再RealSubject中對hello()方法進行實現，但是在代理類中，我們不需要再去為hello方法再去寫一個代理方法，而是通過反射呼叫目標物件的方法，來動態的生成代理類。

總結：

1、因為利用JdkProxySubject生成的代理類實現了介面，所以目標類中所有的方法在代理類中都有。
2、生成的代理類的所有的方法都攔截了目標類的所有的方法。而攔截器中invoke方法的內容正好就是代理類的各個方法的組成體。
3、利用JDK代理方式必須有介面的存在。

CGlib代理模式

CGLib採用非常底層的位元組碼技術，可以為一個類建立子類，並在子類中採用方法攔截的技術攔截所有的父類方法的呼叫，並順勢織入橫切邏輯。
CGlib和JDK的原理類似，也是通過方法去反射呼叫目標物件的方法。

//客戶端
public class Client {
    public static void main(String[] args){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(RealSubject.class);
        enhancer.setCallback(new DemoMethodInterceptor());
        // 此刻，realSubject不是單純的目標類，而是增強過的目標類  
        RealSubject realSubject = (RealSubject) enhancer.create();
        realSubject.hello();
        realSubject.request()
    }
}

//代理物件
public class DemoMethodInterceptor implements MethodInterceptor{
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("before in cglib");
        Object result = null;
        try{
            result = proxy.invokeSuper(obj, args);
        }catch (Exception e){
            System.out.println("get ex:"+e.getMessage());
            throw e;
        }finally {
            System.out.println("after in cglib");
        }
        return result;
    }
}

//目標物件RealSubject，cglib不需要定義目標類的統一介面
public class RealSubject {

    public void request() {
        System.out.println("real subject execute request");
    }

    public void hello() {
        System.out.println("hello");
    }
}

輸出：

before in cglib
hello
after in cglib
before in cglib
real subject execute request
after in cglib

Spring兩種代理方式

若目標物件實現了介面，spring預設使用JDK的動態代理。
優點：因為有介面，所以使系統更加鬆耦合
缺點：為每一個目標類建立介面

若目標物件沒有實現任何介面，spring使用CGLIB進行動態代理。
優點：因為代理類與目標類是繼承關係，所以不需要有介面的存在。
缺點：因為沒有使用介面，所以系統的耦合性沒有使用JDK的動態代理好。

若目標物件實現了介面，但是強制cglib代理，則使用cglib代理

@SpringBootApplication
//強制使用cglib代理
@EnableAspectJAutoProxy(proxyTargetClass = tree)
public class AopDemoApplication{
    public static void main(String[] args){
        SpringApplication.run(AopDemoApplication.class,args);
    }
}