现在的位置: 首页 > 综合 > 正文

spring源码学习之路—AOP初探（六） spring源码学习之路—AOP初探（六）spring源码学习之路—深入AOP（终）

2017年11月02日 ⁄ 综合 ⁄ 共 25667字 ⁄ 字号 小 中 大 ⁄ 评论关闭
 

spring源码学习之路---AOP初探（六）

分类： spring源码学习2013-05-19
03:17 389人阅读 评论(0) 收藏 举报

            作者：zuoxiaolong8810（左潇龙），转载请注明出处。

            最近工作很忙，但当初打算学习spring源码的事已经基本告一段落，只是一直没时间写这些记录性的文字。

            本次鄙人学习spring的源码，有点囫囵吞枣的感觉，其实这样并非就不好，spring作为一个应用平台，自然不是那么好研究透彻的，而且也不太可能有人把spring的源码全部清楚的过上一遍，哪怕是spring的缔造者。不过最主要的原因是我们确实没有必要把源码全部过一遍。

            在看spring源码的过程中，学习到了很多东西，这就足够了，而且现在如果在使用spring的过程中出现任何问题，不会再像以前一样有时候会束手无策，甚至把全部希望寄托于度娘，这其实是不正确的思想。从源码出发，可以发现，其实以前觉得无头绪的问题，现在都会迎刃而解。这就是研究源码最大的收获吧。  

            言归正传，来说说AOP。AOP的中文翻译是面向切面编程，与面向对象，面向接口，面向服务等概念看起来挺相似的。其实最近一直看有关JAVA的书籍，多多少少也对于这些有些理解，所谓面向切面，即是使用切面与其它事物产生关系。面向对象强调一切皆对象，也可以说面向接口是一切皆接口，面向服务则是一切皆服务，而切面也是一样，一切皆切面。

            为什么这么说，面向对象就不说了，就拿面向接口来说吧，强调的就是我们操纵的都是一些接口，所以我们永远不会依赖于实现，面向切面的思想，其实也很类似，即我们操纵的都是一些切面，不会依赖于流程。也正是因为如此，所以我们可以优雅的解决WEB应用中一些原本很棘手或者不好处理的问题。

            以上都是一些理论性的东西，也都是鄙人自己最近的感悟，虽然不知对错，但我觉得这种感悟很重要。

            下面我们具体说说AOP，目前由AOP联盟给出了AOP的标准，AOP联盟的规范只是提供了几个接口定义，为了统一AOP的标准，下面来看看主要的几个接口。

            Advice接口：

            这是一个空接口，里面没有任何方法，只是用来标识一个通知，在spring中，所有的advice都是此接口的扩展，比如BeforeAdvice，AfterAdvice等。

            Interceptor接口：

            Advice的子接口，这个接口和advice都不直接使用，一般是要扩展以后去实现特殊的拦截。

            Joinpoint接口：

            代表了一个运行时的连接点。

            Invocation接口：

            代表了程序中的一个调用，可以被拦截器Interceptor拦截。

            下面还有几个接口，不再一一介绍，从下一层继承开始，interpretor的继承体系已经开始依赖于invocation。这从某种意义上来说，advice是依赖于joinpoint的，但这并非绝对。

            下面给出这几个接口的UML图，关系比较清晰。

            

                 下面介绍下spring中的AOP核心接口。

                 Advice体系：

                 Spring采用AOP联盟的Advice作为超级接口，扩展了很多子接口，比如BeforeAdvice，AfterAdvice等等，稍后以AfterReturningAdvice为例，讨论下spring的通知体系。

                 Pointcut接口：

                 spring采用Pointcut作为切点的抽象，其中有一个方法返回一个MethodMatcher，作用很明显，就是说切点决定了要切入哪些方法。这里其实是定义了一个匹配规则。比如正则匹配，可以只匹配前缀为save的方法等等。

                Advisor：

                通知器或者说通知者，我们从现实角度来说，通知者当然需要知道要通知什么。所以Advisor依赖于Advice，而Advisor旗下的子接口PointAdvisor还依赖于Pointcut，也就是说这个接口更确切的定位应该是包含了要通知谁和要通知什么，也就是说要能获得Advice和Pointcut。

                下面我们先用一个例子说明spring的AOP是如何工作的，在spring的bean中有一种特殊的bean，叫FactoryBean。这并不是一个普通的bean，而是用来产生bean的一个bean。这样说起来有点绕口，但这个接口就是用来做这个事的，它是为了实现一系列特殊加工过的bean而产生的接口。

                比如AOP中，我们其实就是要对一个bean进行增强，进行加工，让它在运行的过程中可以做一些特殊的事情。

                ProxyFactoryBean就是一个为了AOP实现的特殊的FactoryBean，它的作用很明显就是产生proxy的bean，也就是被我们增强过的bean，在这里给出它的源码。

[java] view
plaincopy

  1. public class ProxyFactoryBean extends ProxyCreatorSupport  
  2.         implements FactoryBean<Object>, BeanClassLoaderAware, BeanFactoryAware {  
  3.   
  4.     /** 
  5.      * This suffix in a value in an interceptor list indicates to expand globals. 
  6.      */  
  7.     public static final String GLOBAL_SUFFIX = "*";  
  8.   
  9.   
  10.     protected final Log logger = LogFactory.getLog(getClass());  
  11.   
  12.     private String[] interceptorNames;  
  13.       
  14.     private String targetName;  
  15.   
  16.     private boolean autodetectInterfaces = true;  
  17.   
  18.     private boolean singleton = true;  
  19.   
  20.     private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();  
  21.   
  22.     private boolean freezeProxy = false;  
  23.   
  24.     private transient ClassLoader proxyClassLoader = ClassUtils.getDefaultClassLoader();  
  25.   
  26.     private transient boolean classLoaderConfigured = false;  
  27.   
  28.     private transient BeanFactory beanFactory;  
  29.   
  30.     /** Whether the advisor chain has already been initialized */  
  31.     private boolean advisorChainInitialized = false;  
  32.   
  33.     /** If this is a singleton, the cached singleton proxy instance */  
  34.     private Object singletonInstance;  

               在这里，一样没有贴出全部的源码，我们主要关心它的属性，其中interpretorNames和targetName就是这个类最主要的属性，前者代表的是需要加强哪些东西以及需要怎样加强，也就是advice和pointcut。而后者代表的则是我们针对谁来做这些加强，即我们的目标对象。

               这里面的增强比较灵活，我来说一下需要的属性。

               1.首先interpretorNames是必须赋予的属性，这个属性指定了通知器或者是通知的名字。如果传入的是通知Advice，则会被自动包装为通知器。

               2.targetName是我们要增强的目标对象，这个对象如果有实现的接口，则会采用JDK的动态代理实现，否则将需要第三方的jar包cglib。

               下面给出一段代码，来测试一下这种增强方式。首先我们需要一个bean.xml的配置文件，去配置这些属性。这样就将IOC和AOP结合起来使用了。

[html] view
plaincopy

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  5.   
  6.     <bean id="testAdvisor" class="com.springframework.aop.test.TestAdvisor"></bean>  
  7.     <bean id="testTarget" class="com.springframework.aop.test.TestTarget"></bean>  
  8.     <bean id="testAOP" class="org.springframework.aop.framework.ProxyFactoryBean">  
  9.         <property name="targetName">  
  10.             <value>testTarget</value>  
  11.         </property>  
  12.         <property name="interceptorNames">  
  13.             <list>  
  14.                 <value>testAdvisor</value>  
  15.             </list>  
  16.         </property>  
  17.     </bean>  
  18.   
  19. </beans>  

下面我们看看目标对象的源码。

[java] view
plaincopy

  1. public class TestTarget{  
  2.   
  3.     public void test() {  
  4.         System.out.println("target.test()");  
  5.     }  
  6.   
  7.     public void test2(){  
  8.         System.out.println("target.test2()");  
  9.     }  
  10. }  

很简单，只有两个普通的方法，下面我们看通知器的源码。

[java] view
plaincopy

  1. public class TestAdvisor implements PointcutAdvisor{  
  2.   
  3.     public Advice getAdvice() {  
  4.         return new TestAfterAdvice();  
  5.     }  
  6.   
  7.     public boolean isPerInstance() {  
  8.         return false;  
  9.     }  
  10.   
  11.     public Pointcut getPointcut() {  
  12.         return new TestPointcut();  
  13.     }  
  14.   
  15. }  

我使用的是包含了切点的通知器，所以在这里我们还要给出通知和切点，我写了两个简单的通知和切点。

[java] view
plaincopy

  1. public class TestAfterAdvice implements AfterReturningAdvice{  
  2.   
  3.     public void afterReturning(Object returnValue, Method method,  
  4.             Object[] args, Object target) throws Throwable {  
  5.         System.out.println("after " + target.getClass().getSimpleName() + "." + method.getName() + "()");  
  6.     }  
  7.   
  8. }  

下面是切点，切点的描述是我们只增强test方法，不增强test2方法。

[java] view
plaincopy

  1. public class TestPointcut implements Pointcut{  
  2.   
  3.     public ClassFilter getClassFilter() {  
  4.         return ClassFilter.TRUE;  
  5.     }  
  6.   
  7.     public MethodMatcher getMethodMatcher() {  
  8.         return new MethodMatcher() {  
  9.               
  10.             public boolean matches(Method method, Class<?> targetClass, Object[] args) {  
  11.                 if (method.getName().equals("test")) {  
  12.                     return true;  
  13.                 }  
  14.                 return false;  
  15.             }  
  16.               
  17.             public boolean matches(Method method, Class<?> targetClass) {  
  18.                 if (method.getName().equals("test")) {  
  19.                     return true;  
  20.                 }  
  21.                 return false;  
  22.             }  
  23.               
  24.             public boolean isRuntime() {  
  25.                 return true;  
  26.             }  
  27.         };  
  28.     }  
  29.   
  30. }  

好了，下面我们的准备工作都已经做好了。来看一下见证奇迹的时刻吧，我们使用IOC容器来帮我们完成增强，以下这段代码的运行需要cglib，测试代码如下：

[java] view
plaincopy

  1. public class TestAOP {  
  2.   
  3.     public static void main(String[] args) {  
  4.         ApplicationContext applicationContext = new FileSystemXmlApplicationContext("classpath:beans.xml");  
  5.         TestTarget target = (TestTarget) applicationContext.getBean("testAOP");  
  6.         target.test();  
  7.         System.out.println("------无敌分割线-----");  
  8.         target.test2();  
  9.     }  
  10.       
  11. }  

输入结果会发现，在target.test方法执行后，我们增强的afterReturningAdvice已经起作用了，但是我们将切点定义在了test方法，所以test2方法并没有被增强。

  这一章主要是和各位一起感受一下springAOP的神奇，下一章，将会是spring学习之路的最后一章，我会和各位一起看一下上述我们的增强过程是如何完成的。

 

spring源码学习之路---深入AOP（终）

分类： spring源码学习 java2013-05-22
14:28 239人阅读 评论(0) 收藏 举报

                 作者：zuoxiaolong8810（左潇龙），转载请注明出处。

                上一章和各位一起看了一下springAOP的工作流程，当我们给出AOP相关的配置以后，直接从IOC容器中拿出来的就是已经加强过的bean。这说明spring在这个过程中一定做了什么。

                本章我们就一起来看一下spring是如何完成对bean的增强的，首先我们来看一下，FactoryBean接口中一个方法的定义。

[java] view
plaincopy

  1. public interface FactoryBean<T> {  
  2.   
  3.     /** 
  4.      * Return an instance (possibly shared or independent) of the object 
  5.      * managed by this factory. 
  6.      * <p>As with a {@link BeanFactory}, this allows support for both the 
  7.      * Singleton and Prototype design pattern. 
  8.      * <p>If this FactoryBean is not fully initialized yet at the time of 
  9.      * the call (for example because it is involved in a circular reference), 
  10.      * throw a corresponding {@link FactoryBeanNotInitializedException}. 
  11.      * <p>As of Spring 2.0, FactoryBeans are allowed to return <code>null</code> 
  12.      * objects. The factory will consider this as normal value to be used; it 
  13.      * will not throw a FactoryBeanNotInitializedException in this case anymore. 
  14.      * FactoryBean implementations are encouraged to throw 
  15.      * FactoryBeanNotInitializedException themselves now, as appropriate. 
  16.      * @return an instance of the bean (can be <code>null</code>) 
  17.      * @throws Exception in case of creation errors 
  18.      * @see FactoryBeanNotInitializedException 
  19.      */  
  20.     T getObject() throws Exception;  

                 getObject这个方法，就是用来获取被这个factorybean加强后的对象的，上一章测试的过程中，最终就是调用了这个方法，来完成了对bean的加强。我们来跟踪一下上一次测试的代码，看看到底是在什么地方调用的。这里再次贴出来上次测试的代码，方便解释。

[java] view
plaincopy

  1. public class TestAOP {  
  2.   
  3.     public static void main(String[] args) {  
  4.         ApplicationContext applicationContext = new FileSystemXmlApplicationContext("classpath:beans.xml");  
  5.         TestTarget target = (TestTarget) applicationContext.getBean("testAOP");  
  6.         target.test();  
  7.         System.out.println("------无敌分割线-----");  
  8.         target.test2();  
  9.     }  
  10.       
  11. }  

其实整个过程也就两行代码，第一行代码，是我们对IOC容器的初始化，这时其实并没有发生对bean的增强，原因就是这个时候只是完成了对ProxyFactoryBean的初始化，也就是相当于我们已经new出来了一个ProxyFactoryBean，但是此时并没有调用接口方法，去获得加强后的bean。

               下面我们去跟进第二行获取testAOP的代码，来看一下究竟。首先我们会找到AbstractApplicationContext中的getBean方法，但是这个类并不负责bean的实例化工作，而是交给了bean工厂，我们跟踪bean工厂的方法，能找到上述第二行其实是调用了如下这个方法。

[java] view
plaincopy

  1. @SuppressWarnings("unchecked")  
  2.     protected <T> T doGetBean(  
  3.             final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)  
  4.             throws BeansException {  
  5.   
  6.         final String beanName = transformedBeanName(name);  
  7.         Object bean;  
  8.   
  9.         // Eagerly check singleton cache for manually registered singletons.  
  10.         Object sharedInstance = getSingleton(beanName);  
  11.         if (sharedInstance != null && args == null) {  
  12.             if (logger.isDebugEnabled()) {  
  13.                 if (isSingletonCurrentlyInCreation(beanName)) {  
  14.                     logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +  
  15.                             "' that is not fully initialized yet - a consequence of a circular reference");  
  16.                 }  
  17.                 else {  
  18.                     logger.debug("Returning cached instance of singleton bean '" + beanName + "'");  
  19.                 }  
  20.             }  
  21.             bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);  
  22.         }  
  23.   
  24.         else {  
  25.             // Fail if we're already creating this bean instance:  
  26.             // We're assumably within a circular reference.  
  27.             if (isPrototypeCurrentlyInCreation(beanName)) {  
  28.                 throw new BeanCurrentlyInCreationException(beanName);  
  29.             }  
  30.   
  31.             // Check if bean definition exists in this factory.  
  32.             BeanFactory parentBeanFactory = getParentBeanFactory();  
  33.             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {  
  34.                 // Not found -> check parent.  
  35.                 String nameToLookup = originalBeanName(name);  
  36.                 if (args != null) {  
  37.                     // Delegation to parent with explicit args.  
  38.                     return (T) parentBeanFactory.getBean(nameToLookup, args);  
  39.                 }  
  40.                 else {  
  41.                     // No args -> delegate to standard getBean method.  
  42.                     return parentBeanFactory.getBean(nameToLookup, requiredType);  
  43.                 }  
  44.             }  
  45.   
  46.             if (!typeCheckOnly) {  
  47.                 markBeanAsCreated(beanName);  
  48.             }  
  49.   
  50.             final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);  
  51.             checkMergedBeanDefinition(mbd, beanName, args);  
  52.   
  53.             // Guarantee initialization of beans that the current bean depends on.  
  54.             String[] dependsOn = mbd.getDependsOn();  
  55.             if (dependsOn != null) {  
  56.                 for (String dependsOnBean : dependsOn) {  
  57.                     getBean(dependsOnBean);  
  58.                     registerDependentBean(dependsOnBean, beanName);  
  59.                 }  
  60.             }  
  61.   
  62.             // Create bean instance.  
  63.             if (mbd.isSingleton()) {  
  64.                 sharedInstance = getSingleton(beanName, new ObjectFactory() {  
  65.                     public Object getObject() throws BeansException {  
  66.                         try {  
  67.                             return createBean(beanName, mbd, args);  
  68.                         }  
  69.                         catch (BeansException ex) {  
  70.                             // Explicitly remove instance from singleton cache: It might have been put there  
  71.                             // eagerly by the creation process, to allow for circular reference resolution.  
  72.                             // Also remove any beans that received a temporary reference to the bean.  
  73.                             destroySingleton(beanName);  
  74.                             throw ex;  
  75.                         }  
  76.                     }  
  77.                 });  
  78.                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);  
  79.             }  
  80.   
  81.             else if (mbd.isPrototype()) {  
  82.                 // It's a prototype -> create a new instance.  
  83.                 Object prototypeInstance = null;  
  84.                 try {  
  85.                     beforePrototypeCreation(beanName);  
  86.                     prototypeInstance = createBean(beanName, mbd, args);  
  87.                 }  
  88.                 finally {  
  89.                     afterPrototypeCreation(beanName);  
  90.                 }  
  91.                 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);  
  92.             }  
  93.   
  94.             else {  
  95.                 String scopeName = mbd.getScope();  
  96.                 final Scope scope = this.scopes.get(scopeName);  
  97.                 if (scope == null) {  
  98.                     throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");  
  99.                 }  
  100.                 try {  
  101.                     Object scopedInstance = scope.get(beanName, new ObjectFactory() {  
  102.                         public Object getObject() throws BeansException {  
  103.                             beforePrototypeCreation(beanName);  
  104.                             try {  
  105.                                 return createBean(beanName, mbd, args);  
  106.                             }  
  107.                             finally {  
  108.                                 afterPrototypeCreation(beanName);  
  109.                             }  
  110.                         }  
  111.                     });  
  112.                     bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);  
  113.                 }  
  114.                 catch (IllegalStateException ex) {  
  115.                     throw new BeanCreationException(beanName,  
  116.                             "Scope '" + scopeName + "' is not active for the current thread; " +  
  117.                             "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",  
  118.                             ex);  
  119.                 }  
  120.             }  
  121.         }  
  122.   
  123.         // Check if required type matches the type of the actual bean instance.  
  124.         if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {  
  125.             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());  
  126.         }  
  127.         return (T) bean;  
  128.     }  

这是一个重载方法，后面三个参数两个为null，一个为false。下面注意，在这面这一行的时候，我们已经获取到了实例。

[java] view
plaincopy

  1. Object sharedInstance = getSingleton(beanName);  

            所以分支在碰到第一个if判断时，会直接进入if块而不是else块，在这里提醒一下，这个是获取的单例的bean实例，而这个sharedInstance并不是TestTarget，而是ProxyFactoryBean的实例。好了，接下来相信你已经明白了，我们该进入getObjectForBeanInstance这个方法了，来看这个方法。

[java] view
plaincopy

  1. protected Object getObjectForBeanInstance(  
  2.         Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {  
  3.   
  4.     // Don't let calling code try to dereference the factory if the bean isn't a factory.  
  5.     if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {  
  6.         throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());  
  7.     }  
  8.   
  9.     // Now we have the bean instance, which may be a normal bean or a FactoryBean.  
  10.     // If it's a FactoryBean, we use it to create a bean instance, unless the  
  11.     // caller actually wants a reference to the factory.  
  12.     if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {  
  13.         return beanInstance;  
  14.     }  
  15.   
  16.     Object object = null;  
  17.     if (mbd == null) {  
  18.         object = getCachedObjectForFactoryBean(beanName);  
  19.     }  
  20.     if (object == null) {  
  21.         // Return bean instance from factory.  
  22.         FactoryBean factory = (FactoryBean) beanInstance;  
  23.         // Caches object obtained from FactoryBean if it is a singleton.  
  24.         if (mbd == null && containsBeanDefinition(beanName)) {  
  25.             mbd = getMergedLocalBeanDefinition(beanName);  
  26.         }  
  27.         boolean synthetic = (mbd != null && mbd.isSynthetic());  
  28.         object = getObjectFromFactoryBean(factory, beanName, !synthetic);  
  29.     }  
  30.     return object;  
  31. }  

方法的刚开始是两个卫语句，第一个判断如果是想获得factorybean本身，却又不是factorybean则抛出异常，第二个则是正常的获得factorybean。但是我们都不属于这两种情况。所以在经过getCachedObjectForFactoryBean获取无果和getCachedObjectForFactoryBean获取到bean定义以后，就进入了getObjectFromFactoryBean方法。

[java] view
plaincopy

  1. protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, boolean shouldPostProcess) {  
  2.         if (factory.isSingleton() && containsSingleton(beanName)) {  
  3.             synchronized (getSingletonMutex()) {  
  4.                 Object object = this.factoryBeanObjectCache.get(beanName);  
  5.                 if (object == null) {  
  6.                     object = doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);  
  7.                     this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));  
  8.                 }  
  9.                 return (object != NULL_OBJECT ? object : null);  
  10.             }  
  11.         }  
  12.         else {  
  13.             return doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);  
  14.         }  
  15.     }  

进入以后，由于proxyFactorybean是单例bean，所以会进入到if块不是else块，接下来系统再次尝试从cache中获得，自然是无果。接下来依然会进入到和else一样的方法doGetObjectFromFactoryBean，先不说这个方法，看后面，获得以后就会放入cache，然后直接将对象返回。所以如果重复调用，下一次就会从cache当中取出来直接返回。好了，接下来我们进去doGetObjectFromFactoryBean方法。

[java] view
plaincopy

  1. private Object doGetObjectFromFactoryBean(  
  2.         final FactoryBean factory, final String beanName, final boolean shouldPostProcess)  
  3.         throws BeanCreationException {  
  4.   
  5.     Object object;  
  6.     try {  
  7.         if (System.getSecurityManager() != null) {  
  8.             AccessControlContext acc = getAccessControlContext();  
  9.             try {  
  10.                 object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {  
  11.                     public Object run() throws Exception {  
  12.                             return factory.getObject();  
  13.                         }  
  14.                     }, acc);  
  15.             }  
  16.             catch (PrivilegedActionException pae) {  
  17.                 throw pae.getException();  
  18.             }  
  19.         }  
  20.         else {  
  21.             object = factory.getObject();  
  22.         }  
  23.     }  
  24.     catch (FactoryBeanNotInitializedException ex) {  
  25.         throw new BeanCurrentlyInCreationException(beanName, ex.toString());  
  26.     }  
  27.     catch (Throwable ex) {  
  28.         throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);  
  29.     }  
  30.   
  31.       
  32.     // Do not accept a null value for a FactoryBean that's not fully  
  33.     // initialized yet: Many FactoryBeans just return null then.  
  34.     if (object == null && isSingletonCurrentlyInCreation(beanName)) {  
  35.         throw new BeanCurrentlyInCreationException(  
  36.                 beanName, "FactoryBean which is currently in creation returned null from getObject");  
  37.     }  
  38.   
  39.     if (object != null && shouldPostProcess) {  
  40.         try {  
  41.             object = postProcessObjectFromFactoryBean(object, beanName);  
  42.         }  
  43.         catch (Throwable ex) {  
  44.             throw new BeanCreationException(beanName, "Post-processing of the FactoryBean's object failed", ex);  
  45.         }  
  46.     }  
  47.   
  48.     return object;  
  49. }  

此处判断了一下当前是否设置了安全管理器，我们并没有设置，所以将直接调用ProxyFactoryBean的getObject方法，也就是对bean增强的地方。下面我们着重来看一下是如何对bean进行增强的。首先我们进入到ProxyFactoryBean的getObject方法来看一下。

[java] view
plaincopy

  1. public Object getObject() throws BeansException {  
  2.         initializeAdvisorChain();  
  3.         if (isSingleton()) {  
  4.             return getSingletonInstance();  
  5.         }  
  6.         else {  
  7.             if (this.targetName == null) {  
  8.                 logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +  
  9.                         "Enable prototype proxies by setting the 'targetName' property.");  
  10.             }  
  11.             return newPrototypeInstance();  
  12.         }  
  13.     }  

此处主要是先初始化了一下通知器链，然后就会根据是否单例做相应的动作，我们看一下初始化通知器链的进行。

[java] view
plaincopy

  1. private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {  
  2.         if (this.advisorChainInitialized) {  
  3.             return;  
  4.         }  
  5.   
  6.         if (!ObjectUtils.isEmpty(this.interceptorNames)) {  
  7.             if (this.beanFactory == null) {  
  8.                 throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +  
  9.                         "- cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));  
  10.             }  
  11.   
  12.             // Globals can't be last unless we specified a targetSource using the property...  
  13.             if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) &&  
  14.                     this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {  
  15.                 throw new AopConfigException("Target required after globals");  
  16.             }  
  17.   
  18.             // Materialize interceptor chain from bean names.  
  19.             for (String name : this.interceptorNames) {  
  20.                 if (logger.isTraceEnabled()) {  
  21.                     logger.trace("Configuring advisor or advice '" + name + "'");  
  22.                 }  
  23.   
  24.                 if (name.endsWith(GLOBAL_SUFFIX)) {  
  25.                     if (!(this.beanFactory instanceof ListableBeanFactory)) {  
  26.                         throw new AopConfigException(  
  27.                                 "Can only use global advisors or interceptors with a ListableBeanFactory");  
  28.                     }  
  29.                     addGlobalAdvisor((ListableBeanFactory) this.beanFactory,  
  30.                             name.substring(0, name.length() - GLOBAL_SUFFIX.length()));  
  31.                 }  
  32.   
  33.                 else {  
  34.                     // If we get here, we need to add a named interceptor.  
  35.                     // We must check if it's a singleton or prototype.  
  36.                     Object advice;  
  37.                     if (this.singleton || this.beanFactory.isSingleton(name)) {  
  38.                         // Add the real Advisor/Advice to the chain.  
  39.                         advice = this.beanFactory.getBean(name);  
  40.                     }  
  41.                     else {  
  42.                         // It's a prototype Advice or Advisor: replace with a prototype.  
  43.                         // Avoid unnecessary creation of prototype bean just for advisor chain initialization.  
  44.                         advice = new PrototypePlaceholderAdvisor(name);  
  45.                     }  
  46.                     addAdvisorOnChainCreation(advice, name);  
  47.                 }  
  48.             }  
  49.         }  
  50.   
  51.         this.advisorChainInitialized = true;  
  52.     }  

可以看到，其中针对我们配置的interpretorNames进行了循环，我们并非是配置的全局通知器，所以会进入else块，然后因为我们配置的testAdvisor默认是单例的，所以会从bean工厂中去获取这个实例，此时TestAdvisor已经实例化完成的，我们只是去取一下而已。然后就会进入addAdvisorOnChainCreation方法。这个方法不再一一贴进来，各位有兴趣的可以自己去看一下，就是把通知器加到了通知链当中。

              值得注意的是在这个过程中，触发了一个这样的方法this.advisorAdapterRegistry.wrap(next)。这个方法就是用来包装通知器的，如果不是advisor而是advice，就会包装一下返回。

              好了，接着刚才的过程，初始化通知器链完成以后，就会进入getSingletonInstance方法，这是用来获取单例实例的，而真正的加强也是在这里发生的，我们来看一下。

[java] view
plaincopy

  1. private synchronized Object getSingletonInstance() {  
  2.     if (this.singletonInstance == null) {  
  3.         this.targetSource = freshTargetSource();  
  4.         if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {  
  5.             // Rely on AOP infrastructure to tell us what interfaces to proxy.  
  6.             Class targetClass = getTargetClass();  
  7.             if (targetClass == null) {  
  8.                 throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");  
  9.             }  
  10.             setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));  
  11.         }  
  12.         // Initialize the shared singleton instance.  
  13.         super.setFrozen(this.freezeProxy);  
  14.         this.singletonInstance = getProxy(createAopProxy());  
  15.     }  
  16.     return this.singletonInstance;  
  17. }  

此时第一次获取，单例实例为null，所以会进入if块，首先刷新targetSource，因为我们的Target类没有实现targetSource接口，所以会由spring帮我们产生一个targetSource适配，这里是使用的适配器的模式，有兴趣可以进去看一下，我们此处不关注这个。接下来，会去判断代理接口，并且设置代理接口，但是我们的target未实现任何接口，所以此处interfaces仍然为空的，所以最后一步createAopProxy时，会帮我们创建cglib的proxy。最终由cglib生成代理返回。

执行下国际惯例，说完以后总要稍微总结一下，主要说几点：

1.在IOC容器初始化的过程中，并没有发生增强的动作，而是初始化了proxyFactoryBean。

2.如果配置中不指定，所有bean默认都是单例和非延迟加载的，也就是说所有的bean都将在第一次IOC容器初始化时全部实例化，所以上一章中所配置的三个bean都是在IOC容器初始化时进行的实例化。

3.springAOP代理有两种方式，一种是JDK提供的动态代理，一种是cglib字节码生成的技术，当要代理的类有实现的接口的时候，就会针对接口进行代理，否则就会采用cglib直接生成字节码产生子类。

              到此处，我们已经基本上完全跟了一遍整个bean增强的过程，也大概了解了springAOP的大概原理，相信各位心中应该有个大概的印象了，其实springAOP增强的原理已经浮现出来了，接下来再研究下去，可能会收获甚微，还是要结合平时的应用和自己的兴趣去体会，始终不赞同一头扎进去就埋头苦干的作风。

              好了，spring源码学习之路就圆满结束了，虽说时间不长，但收获甚大。各位如果有兴趣，相信现在也完全有能力自己去看源码了，以后有问题，不要找度娘了，找源码吧。

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞