1 、 ProxyFactoryBean 把 proxy 的创建交给 AopProxy 去做。

public   class  ProxyFactoryBean  extends  AdvisedSupport 

     implements  FactoryBean, BeanFactoryAware, AdvisedSupportListener  { 

             public  Object getObject()  throws  BeansException  { 

                         // invoke AopProxy 去 创建 proxy 
                         return   this .singleton  ?  getSingletonInstance() : newPrototypeInstance();   [good code]
             }  

             // inherited from ProxyConfig 
            public   void  setAopProxyFactory(AopProxyFactory apf)  { 

                         this .aopProxyFactory  =  apf; 
            }  

             // inherited from ProxyConfig 

             public  AopProxyFactory getAopProxyFactory()  { 
                         return   this .aopProxyFactory; 
            }  

}  

 

2. 、那么 AopProxy 又如何获取？答案是从 AopProxyFactory 获得。这个 AopProxyFactory 已在 ProxyFactoryBean 掌控范围内，如上述代码所示。 AopProxyFactory interface 如下所示：

 

public   interface  AopProxyFactory  {    
            AopProxy createAopProxy(AdvisedSupport advisedSupport)  throws  AopConfigException;
}  


3、AopProxy是如何introduce Advised interface的？那要先从AopProxyFactory的implementation说起。

AopProxyFactory 的实现类目前只有 DefaultAopProxyFactory 。这个类的核心方法如下：

           

  public  AopProxy createAopProxy(AdvisedSupport advisedSupport)  throws  AopConfigException  { 

                         if  (advisedSupport.isOptimize()  ||  advisedSupport.isProxyTargetClass()  ||  

                            advisedSupport.getProxiedInterfaces().length  ==   0 )  { 

                                     if  ( ! cglibAvailable)  { 

                                                 throw   new  AopConfigException( 

                                                                         " Cannot proxy target class because CGLIB2 is not available.  "   +  

                                                                         " Add CGLIB to the class path or specify proxy interfaces. " ); 
                                }  

                                     return  CglibProxyFactory.createCglibProxy(advisedSupport); 
                      }  

                         else   { 

                                     return   new  JdkDynamicAopProxy(advisedSupport); 
                      }  

            }  

   这个方法主要是依赖 CglibProxyFactory 类和 JdkDynamicAopProxy 类。这两个类是如何代理所有的接口的呢？

这两个类都是重要接口 AopProxy 的实现类，这个接口的核心方法是

            public Object getProxy(ClassLoader classLoader) 。

其中 JdkDynamicAopProxy 实现该方法用到的获取需要代理的接口的代码如下：

          

   public  Object getProxy(ClassLoader classLoader)  { 

                         if  (logger.isDebugEnabled())  { 

                                    Class targetClass  =   this .advised.getTargetSource().getTargetClass(); 

                                    logger.debug( " Creating JDK dynamic proxy "   +  

                                                            (targetClass  !=   null   ?   "  for [ "   +  targetClass.getName()  +   " ] "  :  "" )); 
            }  

                        Class[] proxiedInterfaces  =  AopProxyUtils.completeProxiedInterfaces( this .advised); 

                         return  Proxy.newProxyInstance(classLoader, proxiedInterfaces,  this ); 
            }  

 

而 CglibProxyFactory 的 getProxy(ClassLoader classLoader) 方法如下：

          

   public  Object getProxy(ClassLoader classLoader)  { 

…… 

                        Enhancer enhancer  =   new  Enhancer();                        

…… 

            enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces( this .advised)); 

…… 

}  

 

从上面可以看出，这两个 AopProxy 实现方案在获取接口时都是通过 AopProxyUtils.completeProxiedInterfaces(this.advised) 获取的。该方法如下：

            /**

             * Get complete set of interfaces to proxy. This will always add the Advised interface

             * unless the AdvisedSupport's "opaque" flag is true.

             * @return the complete set of interfaces to proxy

             */

           

  public   static  Class[] completeProxiedInterfaces(AdvisedSupport advised)  { 

                         //  Won't include Advised, which may be necessary. 

                        Class[] specifiedInterfaces  =  advised.getProxiedInterfaces(); 

                        Class[] proxiedInterfaces  =  specifiedInterfaces; 

                         if  ( ! advised.isOpaque()  &&   ! advised.isInterfaceProxied(Advised. class ))  { 

                                     //  We need to add the Advised interface. 

                                    proxiedInterfaces  =   new  Class[specifiedInterfaces.length  +   1 ]; 

                                    proxiedInterfaces[ 0 ]  =  Advised. class ; 

                                    System.arraycopy(specifiedInterfaces,  0 , proxiedInterfaces,  1 , specifiedInterfaces.length); 

                      }  

                         return  proxiedInterfaces; 

            }  

从这可以看出，是在这强制加了对 Advised  interface 的实现。前提是是否允许代理该 interafce ，这由 isOpaque 方法确定，该方法 Return whether proxies created by this configuration should be prevented from being cast to Advised.

 

4. 顺便提一下， Advised interface 的具体实现又是怎样的，在哪呢？

4.1 在 JdkDynamicAopProxy 里，

 

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

……

                                    if (Advised.class == method.getDeclaringClass()) {

                                                // service invocations on ProxyConfig with the proxy config

                                                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);

                                    }

……

}

注意第一个参数是 this.advised ， 其实就是 ProxyFactoryBean 本身，注意在我发表的其天的 Spring 文章里也曾提到， ProxyFactoryBean extends AdvisedSupport ，

而 AdisedSupport extends ProxyConfig implements Advised ，也就是说 Advised 的默认实现就是 AdisedSupport 。

 

4.2 在 Cglib2AopProxy 里（如果不熟 Cglib ，建议先看看其天有关的 Cglib 资料），

 

 

            public Object getProxy(ClassLoader classLoader) {

……

Enhancer enhancer = new Enhancer();

……

enhancer.setCallbackFilter(new ProxyCallbackFilter(this.advised));

……

Callback[] callbacks = getCallbacks(rootClass);

……

……

……

}

private Callback[] getCallbacks(Class rootClass) throws Exception {

……

                        Callback[] mainCallbacks = new Callback[]{

                                    aopInterceptor, // for normal advice

                                    targetInterceptor, // invoke target without considering advice, if optimized

                                    new SerializableNoOp(), // no override for methods mapped to this

                                    targetDispatcher, this.advisedDispatcher,

                                    new EqualsInterceptor(this.advised)

                        };

……

}

 

private class ProxyCallbackFilter implements CallbackFilter {

public int accept(Method method) {

                                    if (method.getDeclaringClass() == Advised.class) {

                                                if (logger.isDebugEnabled()) {

                                                            logger.debug("Method " + method + " is declared on Advised - using DISPATCH_ADVISED");

                                              }

                                                return DISPATCH_ADVISED;// DISPATCH_ADVISED 值为 4.

                                    }

……

}

}

 

private final transient AdvisedDispatcher advisedDispatcher = new AdvisedDispatcher();

 

            /**

             * Dispatcher for any methods declared on the Advised class.

             */

            private class AdvisedDispatcher implements Dispatcher, Serializable {

 

                        public Object loadObject() throws Exception {

                                    return advised;

                      }

            }

 

注意 Dispatcher extends Callback interface 。