Spring切面笔记

ゝ一世哀愁。 2022-10-15 12:49 107阅读 0赞

### 文章目录 ###

*   *  Aop原理
     *  @Aspect 和 Advisor不一样吗?
     *  Bean完全符合切面条件，但无法生成切面?
     *   *  创建Bean
         *  封装代理对象
         *  advisor创建过程中，不接受新的代理需求

## Aop原理 ##

首先会封装好advisor(pointcut+advice)，在生成bean的时候会加入可用切面的信息，在每次调用方法的时候，才会形成一个chain，然后再执行advice，达到效果。

备注：在创建bean的时候，会在initializeBean里面织入切面（org.springframework.validation.beanvalidation.MethodValidationPostProcessor就是方法级别的切面）

## @Aspect 和 Advisor不一样吗? ##

@Aspect和Advisor ：前者是注解形式标识一个类为切面类，后者是实现了Advisor。两者生效的时机一致，均在bean创建时织入advice。@Aspect会被封装为一个Advisor。但是@Aspect的match是不一样的，所以可以匹配真实bean，而不仅限于代理Bean。

备注：ReflectiveAspectJAdvisorFactory\#getAdvisors会创建Advisor

## Bean完全符合切面条件，但无法生成切面? ##

1.  在创建普通bean之前，会先创建PostProcessor
2.  一般会先触发创建advisor，**在创建advisor时，会先实例化advisor的factory**。
    
    所以，比如配置类有定义advisor的beanMethod，就会导致这个configuration先生成实例、注入属性（populateBean AutowiredAnnotationBeanPostProcessor, 此时处理primary）、注入到spring中，最后再创建advisor
3.  创建advisor过程中，可能触发创建更多的bean，导致有些bean过早被创建。这些**被提前创建的bean，因为advisor正在创建中，就无法添加切面**了。

### 创建Bean ###

AbstractAutowireCapableBeanFactory\#doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    			throws BeanCreationException { 
    
    		// Instantiate the bean.
    		BeanWrapper instanceWrapper = null;
    		if (mbd.isSingleton()) { 
    			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    		}
    		if (instanceWrapper == null) { 
    		    //创建bean
    			instanceWrapper = createBeanInstance(beanName, mbd, args);
    		}
    		final Object bean = instanceWrapper.getWrappedInstance();
    		Class<?> beanType = instanceWrapper.getWrappedClass();
    		if (beanType != NullBean.class) { 
    			mbd.resolvedTargetType = beanType;
    		}
    
    		// Allow post-processors to modify the merged bean definition.
    		synchronized (mbd.postProcessingLock) { 
    			if (!mbd.postProcessed) { 
    				try { 
    					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    				}
    				catch (Throwable ex) { 
    					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    							"Post-processing of merged bean definition failed", ex);
    				}
    				mbd.postProcessed = true;
    			}
    		}
    
    		// Eagerly cache singletons to be able to resolve circular references
    		// even when triggered by lifecycle interfaces like BeanFactoryAware.
    		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    				isSingletonCurrentlyInCreation(beanName));
    		if (earlySingletonExposure) { 
    			if (logger.isTraceEnabled()) { 
    				logger.trace("Eagerly caching bean '" + beanName +
    						"' to allow for resolving potential circular references");
    			}
    			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    		}
    
    		// Initialize the bean instance.
    		Object exposedObject = bean;
    		try { 
    		    //填充属性
    		    //自动注入：AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition
    			populateBean(beanName, mbd, instanceWrapper);
    			//添加切面: org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessBeforeInstantiation
    			exposedObject = initializeBean(beanName, exposedObject, mbd);
    		}
    		catch (Throwable ex) { 
    			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { 
    				throw (BeanCreationException) ex;
    			}
    			else { 
    				throw new BeanCreationException(
    						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
    			}
    		}
    ......
    
    		// Register bean as disposable.
    		try { 
    			registerDisposableBeanIfNecessary(beanName, bean, mbd);
    		}
    		catch (BeanDefinitionValidationException ex) { 
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    		}
    
    		return exposedObject;
    	}

### 封装代理对象 ###

AbstractAutoProxyCreator\#postProcessBeforeInstantiation

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) { 
    		Object cacheKey = getCacheKey(beanClass, beanName);
    
    		if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) { 
    			if (this.advisedBeans.containsKey(cacheKey)) { 
    				return null;
    			}
    			if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) { 
    				this.advisedBeans.put(cacheKey, Boolean.FALSE);
    				return null;
    			}
    		}
    
    		// Create proxy here if we have a custom TargetSource.
    		// Suppresses unnecessary default instantiation of the target bean:
    		// The TargetSource will handle target instances in a custom fashion.
    		TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
    		if (targetSource != null) { 
    			if (StringUtils.hasLength(beanName)) { 
    				this.targetSourcedBeans.add(beanName);
    			}
    			//寻找切面
    			Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
    			//创建切面
    			Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
    			this.proxyTypes.put(cacheKey, proxy.getClass());
    			//返回代理对象
    			return proxy;
    		}
    
    		return null;
    	}

### advisor创建过程中，不接受新的代理需求 ###

BeanFactoryAdvisorRetrievalHelper\#findAdvisorBeans

public List<Advisor> findAdvisorBeans() { 
    		// Determine list of advisor bean names, if not cached already.
    		String[] advisorNames = this.cachedAdvisorBeanNames;
    		if (advisorNames == null) { 
    			// Do not initialize FactoryBeans here: We need to leave all regular beans
    			// uninitialized to let the auto-proxy creator apply to them!
    			advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
    					this.beanFactory, Advisor.class, true, false);
    			this.cachedAdvisorBeanNames = advisorNames;
    		}
    		if (advisorNames.length == 0) { 
    			return new ArrayList<>();
    		}
    
    		List<Advisor> advisors = new ArrayList<>();
    		for (String name : advisorNames) { 
    			if (isEligibleBean(name)) { 
    			    //如果advisor正在被创建，直接略过
    				if (this.beanFactory.isCurrentlyInCreation(name)) { 
    					if (logger.isTraceEnabled()) { 
    						logger.trace("Skipping currently created advisor '" + name + "'");
    					}
    				}
    				else { 
    					try { 
    						advisors.add(this.beanFactory.getBean(name, Advisor.class));
    					}
    					catch (BeanCreationException ex) { 
    						Throwable rootCause = ex.getMostSpecificCause();
    						if (rootCause instanceof BeanCurrentlyInCreationException) { 
    							BeanCreationException bce = (BeanCreationException) rootCause;
    							String bceBeanName = bce.getBeanName();
    							if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) { 
    								if (logger.isTraceEnabled()) { 
    									logger.trace("Skipping advisor '" + name +
    											"' with dependency on currently created bean: " + ex.getMessage());
    								}
    								// Ignore: indicates a reference back to the bean we're trying to advise.
    								// We want to find advisors other than the currently created bean itself.
    								continue;
    							}
    						}
    						throw ex;
    					}
    				}
    			}
    		}
    		return advisors;
    	}