原創文章，轉載請註明出處

本節介紹AopProxyUtils，這個工具類方法本身很少，但是涉及到很多AOP相關重要介面，所以本節主要會對涉及到的介面進行初步的介紹；

Class<?> ultimateTargetClass(Object candidate)
獲取一個代理物件的最終物件型別，先做一個測試（測試的準備工作參考https://www.jianshu.com/p/a4a815f42cd2）：

@Test
public void testUltimateTargetClass() {
    // class cn.wolfcode.springboot.utilstest.MyComponent
    System.out.println(AopProxyUtils.ultimateTargetClass(component));
    // class cn.wolfcode.springboot.utilstest.EmployeeServiceImpl
    System.out.println(AopProxyUtils.ultimateTargetClass(service));
}
 

分別獲取了代理物件的最終物件型別；我們來看看該方法的實現：

public static Class<?> ultimateTargetClass(Object candidate) {
    Assert.notNull(candidate, "Candidate object must not be null");
    //current用於判斷；
    Object current = candidate;
    Class<?> result = null;
    //直到當前獲得的物件不是TargetClassAware型別，TargetClassAware後面介紹；
    while (current instanceof TargetClassAware) {
        //獲得當前物件（一個代理物件）代理的目標物件（這個物件可能還是一個代理物件）型別；
        result = ((TargetClassAware) current).getTargetClass();
        Object nested = null;
        //如果當前獲取的目標物件是一個Advised型別物件;
        if (current instanceof Advised) {
            //通過getTargetSource方法獲取代理目標；
            TargetSource targetSource = ((Advised) current).getTargetSource();
            //如果代理目標物件是一個SingletonTargetSource；
            if (targetSource instanceof SingletonTargetSource) {
                //獲取當前代理物件的真正目標物件（可能還是一個代理物件）
                nested = ((SingletonTargetSource) targetSource).getTarget();
            }
        }
        current = nested;
    }
    //如果獲取到的目標物件是一個cglib代理物件，獲取父類型別（才是目標型別）
    if (result == null) {
        result = (AopUtils.isCglibProxy(candidate) ? candidate.getClass().getSuperclass() : candidate.getClass());
    }
    return result;
}
 

其實這段程式碼本身不難，但是這裡面涉及到了很多SpringAOP中的介面，比如TargetClassAware，Advised，TargetSource，SingletonTargetSource等；這些介面都是SpringAOP中的一些重要介面，在這裡我們做一個簡單介紹，更多的內容後面單開文章介紹；

我們先看下TargetClassAware，Advised和TargetSource三個介面：
TargetClassAware：所有的Aop代理物件或者代理工廠（proxy factory)都要實現的介面，該介面用於暴露出被代理目標物件型別；

TargetSource：該介面代表一個目標物件，在aop呼叫目標物件的時候，使用該介面返回真實的物件。比如該介面的一個實現：PrototypeTargetSource，那就是每次呼叫都返回一個全新的物件例項；

Advised：該介面用於儲存一個代理的相關配置（簡單理解為這個物件儲存了怎麼建立一個代理物件的資訊），比如這個代理配置相關的攔截器，建議(advisor)或者增強器（advice)；所有的代理物件都實現了該介面（我們就能夠通過一個代理物件獲取這個代理物件怎麼被代理出來的相關資訊）；

我們可以來做個測試：

@Test
public void testUltimateTargetClass2() {
    /**
     * interface cn.wolfcode.springboot.utilstest.IEmployeeService interface
     * cn.wolfcode.springboot.utilstest.IAddition interface
     * org.springframework.aop.SpringProxy interface
     * org.springframework.aop.framework.Advised interface
     * java.io.Serializable
     */
    System.out.println(StringUtils.collectionToDelimitedString(
            ClassUtils.getAllInterfacesAsSet(service), "\r\n"));
    /**
     * interface org.springframework.aop.SpringProxy interface
     * org.springframework.aop.framework.Advised interface
     * org.springframework.cglib.proxy.Factory
     */
    System.out.println(StringUtils.collectionToDelimitedString(
            ClassUtils.getAllInterfacesAsSet(component), "\r\n"));
}

可以看到，不管是JDKproxy，還是cglib proxy，代理出來的物件都實現了org.springframework.aop.framework.Advised介面；

三個介面的關係為：

介面中的方法我們先不研究，我們明確一個點來輔助我們理解這個關係，那就是Advised介面中的getTargetSource返回的就是TargetSource。意思就是Advised和TargetSource介面雖然在繼承關係上，都是繼承了TargetClassAware介面，看似平級關係，實際上確實組合關係：

@Test
public void testUltimateTargetClass3() {
    if (service instanceof Advised) {
        TargetSource ts = ((Advised) service).getTargetSource();
        //class org.springframework.aop.target.SingletonTargetSource
        System.out.println(ts.getClass());
    }
}

可以看到，得到的最終是一個SingletonTargetSource，那麼就是說這種TargetSource就是每次呼叫，都返回相同物件；

而Advised裡面包含的Advisor和Advice，我們後面再詳細介紹；
希望通過這個介紹，對這三個介面有更深入的理解；

Class<?>[] completeProxiedInterfaces(AdvisedSupport advised)
很牛逼的方法來了，判斷一個advised真正需要代理的目標介面列表。簡單理解，比如在spring使用JDK proxy做代理的時候，這個方法返回的型別列表就是真正需要交給Proxy.newProxyInstance方法的介面列表，我們先來簡單看看這個流程在Spring中的實現：

public Object getProxy(ClassLoader classLoader) {
    Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

這段程式碼摘取自JdkDynamicAopProxy，這個就是我們常常說的Spring中針對實現了介面的物件，使用JDK的動態代理完成的真正程式碼，可以看到，傳給newProxyInstance方法第二個引數的介面列表，就是通過completeProxiedInterfaces方法獲取的。足見該方法的重要性；

該方法具體的實現我們這裡先不介紹，因為涉及到另一個AOP中重要的類：AdvisedSupport，該類是Spring中用於蒐集代理配置的物件（是不是感覺這句話很熟，是的，這個類就是實現了上面介紹的Advised介面，但是注意，代理出來的類可以轉成Advised，但是不是AdvisedSupport）；

Class<?>[] proxiedUserInterfaces(Object proxy) 
該方法用於獲取一個代理物件中的使用者定義的介面，即非（Advised介面體系）之外的其他介面；

@Test
public void testProxiedUserInterfaces() {
    /**
     * interface cn.wolfcode.springboot.utilstest.IEmployeeService interface
     * cn.wolfcode.springboot.utilstest.IAddition interface
     * org.springframework.aop.SpringProxy interface
     * org.springframework.aop.framework.Advised interface
     * java.io.Serializable
     */
    System.out.println(StringUtils.collectionToDelimitedString(
            ClassUtils.getAllInterfacesAsSet(service), "\r\n"));

    /**
     * interface cn.wolfcode.springboot.utilstest.IEmployeeService interface
     * cn.wolfcode.springboot.utilstest.IAddition
     */
    System.out.println(StringUtils.arrayToDelimitedString(
            AopProxyUtils.proxiedUserInterfaces(service), "\r\n"));

}

可以看到，只得到了使用者定義的介面，Spring自動增加的系統介面沒有包含；
這個方法的實現也很有意思：

public static Class<?>[] proxiedUserInterfaces(Object proxy) {
    //得到所有介面
    Class<?>[] proxyInterfaces = proxy.getClass().getInterfaces();
    int nonUserIfcCount = 0;
    //如果是代理，一定實現了SpringProxy；
    if (proxy instanceof SpringProxy) {
        nonUserIfcCount++;
    }
    //如果是代理，可能實現了Advised；
    if (proxy instanceof Advised) {
        nonUserIfcCount++;
    }
    Class<?>[] userInterfaces = new Class<?>[proxyInterfaces.length - nonUserIfcCount];
    //拷貝proxyInterfaces中從第0位~第proxyInterfaces.length - nonUserIfcCount個
    //去掉尾巴上的nonUserIfcCount個；
    System.arraycopy(proxyInterfaces, 0, userInterfaces, 0, userInterfaces.length);
    Assert.notEmpty(userInterfaces, "JDK proxy must implement one or more interfaces");
    return userInterfaces;
}

boolean equalsProxiedInterfaces(AdvisedSupport a, AdvisedSupport b)
判斷兩個（即將）代理出來的物件是否擁有相同介面；

boolean equalsAdvisors(AdvisedSupport a, AdvisedSupport b)
判斷兩個（即將）代理出來的物件是否擁有相同的建議者（Advisor）；

boolean equalsInProxy(AdvisedSupport a, AdvisedSupport b)
判斷兩個（即將）代理出來的物件是否相同；

小結

AopProxyUtils中的方法不多，但是其中的ultimateTargetClass和completeProxiedInterfaces方法確是Spring AOP中比較重要的方法，也給了我們一個入手觀察Spring AOP真正實現過程的一個突破口；我認為這個，才是AopProxyUtils給我們的價值；