目录
AnnotationAwareAspectJAutoProxyCreator:
AnnotationAwareAspectJAutoProxyCreator的注册流程:
AnnotationAwareAspectJAutoProxyCreator调用时机:
getInterceptorsAndDynamicInterceptionAdvice方法获取拦截器链:
AOP流程:
一、 创建和注册AnnotationAwareAspectJAutoProxyCreator
- 传入配置类, 创建IOC容器
- 注册配置类, 调用refresh() 刷新容器
- registerBeanPostProcessors(beanFactory) ; 注册bean的后置处理器,拦截bean的创建
- 先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
- 给容器中加其他的BeanPostProcessor
- 优先给容器注册实现了ProrityOrdered接口的BeanPostProcessor
- 再注册实现了ordered接口的BeanPostProcessor
- 注册没有实现优先级接口的BeanPostProcessor
- 创建internalAutoProxyCreator的BeanPostProcessor: AnnotationAwareAspectJAutoProxyCreator。 初始化bean时, 有如下几个操作需要注意:
- invokeAwareMethods() : 处理Aware接口的方法回调
- applyBeanPostProcessorsBeforeInitialization() : 应用后置处理器的postProcessBeforeInitialization()
- invokeInitMethod() ; 执行自定义的初始化方法
- applyBeanPostProcessorsAfterInitialization() ;执行后置处理器的applyBeanPostProcessorsAfterInitialization() 方法
- 把BeanPostProcessor注册到BeanFactory中: beanFactory.addBeanPostProcessor(postProcessor)
二、完成BeanFactory的初始化工作: finishBeanFactoryInitialization(beanFactory),创建剩下的单实例bean。
- 遍历获取容器中所有的bean, 依次创建对象: getBean(beanName): getBean --> doGetBean() ---> getSingleton()
- createBean : 创建bean。 AnnotationAwareAspectJAutoProxyCreator 在所有bean创建前会有一个拦截, InstantiationAwareBeanPostProcessor, 会调用postProcessorBeforeInstantiation() 方法
- 先从缓存中获取当前bean, 如果能获取到, 则直接使用, 否则创建bean, 并将新创建的bean缓存起来
- createBean() : AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建前先尝试返回bean实例。注意: BeanPostProcessor是在bean创建完成初始化前后调用的, InstantiationAwareBeanPostProcessor是在bean实例化之前先尝试用后置处理器返回对象。
三、AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】的作用:
这里要注意: AnnotationAwareAspectJAutoProxyCreator 是InstantiationAwareBeanPostProcessor 类型的后置处理器, 它调用的方法是: postProcessorsBeforeInstantiation()、postProcessorsAfterInstantiation()
- 每个bean创建之前, 调用postProcessorsBeforeInstantiation()。 这里关系到MathCalculator 和 LogAspect的创建
- 判断当前bean是否在adviseBeans中(这里保存了所有的增强bean)
- 判断当前bean是否是基础类型的Advice、Pointcut、 Advisor、 AopInfrastructureBean, 或者是否是切面@Aspect
- 是否需要跳过
- 获取候选的增强器(切面里的通知方法), 每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor : 用于判断每个增强器是否是AspectJPointcutAdvisor类型
- 创建对象 postProcessAfterInitialization; return wrapIfNecessary(bean, beanName , cacheKey ) ; 需要的话包装bean
- 获取当前bean的所有增强器(通知方法): Object[] specificInterceptors
- 找到候选的所有增强器(哪些通知方法是需要切入当前bean方法的)
- 获取到能在bean中使用的增强器
- 给增强器排序
- 保存当前bean在adviseBeans中
- 如果当前bean需要增强, 创建当前bean的代理对象
- 获取所有增强器
- 保存到ProxyFactory中
- 创建代理对象: spring自动决定使用jdk动态代理还是cglib动态带
- 返回当前组件中使用cglib增强的代理对象到容器中
- 以后容器中获取到的bean实例, 就是这个组件的代理对象。 执行目标方法时,代理对象就会执行通知方法的流程
- 获取当前bean的所有增强器(通知方法): Object[] specificInterceptors
- 目标方法的执行: 容器中保存了组件的代理对象, 该对象里面保存了增强器、目标对象等详细信息。
- 拦截目标方法的执行: CglibAopProxy.intercept();
- 根据 ProxyFactory对象获取将要执行的目标方法拦截器链 : List<Object> chain
- List<Object> interceptorList 保存了所有拦截器, 共5个: 一个默认的ExposeInvocationInterceptor 和 4个增强器
- 遍历所有增强器, 将其转为Interceptor ; registry.getInterceptors(advisor)
- 将增强器转为List<MethodInterceptor> : 如果是MethodInterceptor, 直接加入到集合中 ; 如果不是, 使用AdvisorAdapter将增强器转为MethodInterceptor; 转换完成,返回MethodInterceptor数组
- 如果没有拦截器链, 直接执行目标方法
- 如果有拦截器链, 把需要执行的目标对象、目标方法、拦截器链等信息传入创建一个CglibMethodInvocation对象。 并调用 Object retVal = mi.proceed();
- 拦截器链的触发过程
- 如果没有拦截器执行目标方法,或者拦截器的索引和拦截器数组一样大(到了最后一个拦截器), 执行目标方法
- 链式获取内一个拦截器, 拦截器执行invoke方法, 每一个拦截器等待下一个拦截器执行完成,返回以后再来执行; 拦截器链的机制, 保证通知方法与目标方法的执行顺讯。
基于注解的方式实现AOP需要在配置类中添加注解@EnableAspectJAutoProxy。我们就先从这个注解看一下Spring实现AOP的过程:
@EnableAspectJAutoProxy
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class) //引入AspectJAutoProxyRegister.class对象
public @interface EnableAspectJAutoProxy {
//true——使用CGLIB基于类创建代理;false——使用java接口创建代理
boolean proxyTargetClass() default false;
//是否通过aop框架暴露该代理对象,aopContext能够访问.
boolean exposeProxy() default false;
}
可以看出@EnableAspectJAutoProxy引入了AspectJAutoProxyRegister.class对象 ,AspectJAutoProxyRegister给容器中注册一个AnnotationAwareAspectJAutoProxyCreator:
AspectJAutoProxyRegistrar :
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(
AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry); //自定义注册bean,进入到AopConfigUtils类中
AnnotationAttributes enableAspectJAutoProxy =
AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class); //获取@EnableAspectJAutoProxy注解的属性信息
if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}
AopConfigUtils:
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
//注册AnnotationAwareAspectJAutoProxyCreator
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
//注册AnnotationAwareAspectJAutoProxyCreator
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) { //如果已经包含目标bean
BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
int requiredPriority = findPriorityForClass(cls);
if (currentPriority < requiredPriority) {
apcDefinition.setBeanClassName(cls.getName());
}
}
return null;
}
//注册AnnotationAwareAspectJAutoProxyCreator,cls = AnnotationAwareAspectJAutoProxyCreator
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
//将beanDefinition注册进registry中,注册名为 AUTO_PROXY_CREATOR_BEAN_NAME
//AUTO_PROXY_CREATOR_BEAN_NAME = internalAutoProxyCreator
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;
}
AnnotationAwareAspectJAutoProxyCreator:
AnnotationAwareAspectJAutoProxyCreator 的层次结构:
这里主要关注后置处理器和自动装备BeanFactory相关的方法:SmartInstantiationAwareBeanPostProcessor(后置处理器), BeanFactoryAware(自动装配BeanFactory).
AnnotationAwareAspectJAutoProxyCreator的注册流程:
1、创建IOC容器,传入配置类:new AnnotationConfigApplicationContext(ConfigOfAOP.class)
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();//调用无参构造创建对象
register(annotatedClasses); //注册配置类
refresh(); //刷新容器,初始化容器创建需要的bean
}
2、调用refresh()方法,刷新容器
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// 注册后置处理器,用于拦截bean的创建
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
3、refresh()方法调用了一个方法 registerBeanPostProcessors(beanFactory),注册后置处理器,用于拦截bean的创建。也是在这个方法中完成了AnnotationAwareAspectJAutoProxyCreator的注册。该方法的主要逻辑在PostProcessorRegistrationDelegate类中的registerBeanPostProcessors方法中:
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// 注册BeanPostProcessorChecker,当bean在BeanPostProcessor实例化过程中被创建时
//即当一个bean没有资格被所有BeanPostProcessor处理时,它记录一条信息消息。
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// BeanPostProcessors 根据优先级进行分离,实现PriorityOrdered接口、实现Ordered接口、未实现优先级接口
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);//内部beanpostprocessor
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
//先注册实现PriorityOrdered接口的 BeanPostProcessors
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
//再注册实现Ordered接口的 BeanPostProcessors
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory); //按照优先级排序
registerBeanPostProcessors(beanFactory, orderedPostProcessors); //注册
//这里注册所有常规的beanpostprocessor
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 最后,重新注册所有内部beanpostprocessor。
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
registerBeanPostProcessors中注册BeanPostProcessor的顺序是:
- 注册实现了PriorityOrdered接口的BeanPostProcessor
- 注册实现了Ordered接口的BeanPostProcessor
- 注册常规的BeanPostProcessor ,也就是没有实现优先级接口的BeanPostProcessor
- 注册Spring内部BeanPostProcessor
4、registerBeanPostProcessors方法中注册了所有的BeanPostProcessor,所以AnnotationAwareAspectJAutoProxyCreator也在这里注册完成。而从AnnotationAwareAspectJAutoProxyCreator类的层次接口可以看出,该类实现了Ordered接口。所以它是在注册实现Ordered接口的BeanPostProcessor是完成注册:
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
这里调用的是AbstractBeanFactory的getBean方法,但是它实际的业务逻辑在AbstractAutowireCapableBeanFactory的doGetBean方法中实现:
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
//实例化bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args); //创建bean实例
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
mbd.resolvedTargetType = beanType;
// 允许post-processors修改合并的bean定义。
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.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
//初始化bean实例
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper); //给bean的各种属性赋值
if (exposedObject != null) {
//初始化bean
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);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
doGetBean中的逻辑看上去很复杂,但实际上他只做了三件事:
- 创建bean :createBeanInstance(beanName, mbd, args)
- 给bean中的属性赋值:populateBean(beanName, mbd, instanceWrapper)
- 初始化bean:initializeBean(beanName, exposedObject, mbd)
初始化bean时,initializeBean方法会调用BeanPostProcessor和BeanFactory以及Aware接口的相关方法。这也是BeanPostProcessor如何发挥初始化bean的原理。
5、AbstractAutowireCapableBeanFactory的initializeBean方法:
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean); //处理Aware接口的方法回调
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 应用后置处理器的postProcessBeforeInitialization方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
invokeInitMethods(beanName, wrappedBean, mbd); //执行自定义的初始化方法
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 执行后置处理器的postProcessAfterInitialization方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
可以看出initializeBean方法主要做了四件事:
- 处理Aware接口的方法回调:invokeAwareMethods(beanName, bean);
- 应用后置处理器的postProcessBeforeInitialization方法: wrappedBean=applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
- 执行自定义的初始化方法:invokeInitMethods(beanName, wrappedBean, mbd);
- 执行后置处理器的postProcessAfterInitialization方法: wrappedBean=applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
initializeBean方法执行成功,AnnotationAwareAspectJAutoProxyCreator注册和初始化成功。
6、这时再回到第3步中,BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class)执行成功,目标bean成功注册后,将注册完成的beanPostProcessor,排序后注册到BeanFactory中
sortPostProcessors(orderedPostProcessors, beanFactory); //按照优先级排序
registerBeanPostProcessors(beanFactory, orderedPostProcessors); //注册
registerBeanPostProcessors:
private static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
for (BeanPostProcessor postProcessor : postProcessors) {
beanFactory.addBeanPostProcessor(postProcessor);
}
}
AnnotationAwareAspectJAutoProxyCreator调用时机:
上一节第2步中refresh()方法中,调用registerBeanPostProcessors(beanFactory)方法,注册完BeanPostProcessor后,还调用了方法finishBeanFactoryInitialization(beanFactory) ,完成BeanFactory初始化工作,并创建剩下的单实例bean。finishBeanFactoryInitialization(beanFactory)的执行过程:
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 初始化此上下文的转换服务。
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
//若之前没有任何bean后处理器注册,则注册一个默认的嵌入式值解析器:主要用于在注释属性值中解析
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
@Override
public String resolveStringValue(String strVal) {
return getEnvironment().resolvePlaceholders(strVal);
}
});
}
//尽早初始化LoadTimeWeaverAware bean,以便尽早注册它们的转换器。
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 停止使用临时类加载器进行类型匹配。
beanFactory.setTempClassLoader(null);
// 允许缓存所有bean定义元数据,不期望有进一步的更改。
beanFactory.freezeConfiguration();
// 实例化所有剩余的(非懒加载初始化)单例bean。
beanFactory.preInstantiateSingletons();
}
1、调用 beanFactory.preInstantiateSingletons():遍历获取容器中所有的Bean,实例化所有剩余的(非懒加载初始化)单例bean。 该方法是DefaultListableBeanFactory类中的方法:
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
// 迭代一个副本以允许init方法,而init方法反过来注册新的bean定义。
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
// 触发所有非惰性单例bean的初始
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { //非抽象、单例、非懒加载
if (isFactoryBean(beanName)) { //如果是FactoryBean类型
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
}else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}else {//不是FactoryBean类型
getBean(beanName);
}
}
}
// 为所有适用的bean触发初始化后回调…
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
smartSingleton.afterSingletonsInstantiated();
return null;
}
}, getAccessControlContext());
}else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
2、preInstantiateSingletons调用getBean方法,获取bean实例,执行过程getBean->doGetBean()->getSingleton()->createBean()
先从缓存中获取当前bean,如果能获取到,直接使用,否则创建bean。只要bean被创建就会被缓存起来。这里的调用了流程与上一节的第4步中相同。这里要说一下createBean中的 resolveBeforeInstantiation(beanName, mbdToUse)方法: 让beanpostprocessor有机会返回代理而不是目标bean实例
try {
// 让beanpostprocessor有机会返回代理而不是目标bean实例。
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
resolveBeforeInstantiation:
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// 确保此时bean类已经被解析。
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
//拿到所有后置处理器,如果是InstantiationAwareBeanPostProcessor,就执行postProcessBeforeInstantiation
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
主要看一下resolveBeforeInstantiation方法中的applyBeanPostProcessorsBeforeInstantiation 和 applyBeanPostProcessorsAfterInitialization方法,注意两个方法的后缀不同Instantiation(实例化) 和 Initialization(初始化)
applyBeanPostProcessorsBeforeInstantiation :
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) { //遍历所有BeanPostProcessor
if (bp instanceof InstantiationAwareBeanPostProcessor) { //如果是InstantiationAwareBeanPostProcessor类型
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//执行postProcessBeforeInstantiation方法
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
postProcessBeforeInstantiation方法是InstantiationAwareBeanPostProcessor接口中定义的方法,applyBeanPostProcessorsAfterInitialization方法会调用BeanPostProcessor接口中postProcessAfterInitialization方法。 而且InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的;BeanPostProcessor是在Bean对象创建完成初始化前后调用的。从AnnotationAwareAspectJAutoProxyCreator类的层次结构可以看出,该类实现了InstantiationAwareBeanPostProcessor接口,它会在所有bean实例创建前进行拦截,这也是AOP代理的关键所在。
Spring创建AOP代理:
AnnotationAwareAspectJAutoProxyCreator实现了InstantiationAwareBeanPostProcessor接口,所以每次创建bean实例前都会调用AnnotationAwareAspectJAutoProxyCreator类的postProcessBeforeInstantiation()方法。下面就看一下该方法都做了什么。
1、postProcessBeforeInstantiation()是在AbstractAutoProxyCreator类中实现的:
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
Object cacheKey = getCacheKey(beanClass, beanName);
if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
//判断当前bean是否在advisedBeans中(advisedBeans保存了所有需要增强的bean)
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
//判断当前bean是否基础类型Advice、Pointcut、Advisor、AopInfrastructureBean,或是否切面(@Aspect)
//是否需要跳过
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
//如果我们有一个自定义TargetSource,请在这里创建代理。
if (beanName != null) {
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
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;
}
postProcessBeforeInstantiation方法主要对当前类进行一些判断:
- 判断当前bean是否在advisedBeans(增强bean的集合)中----增强bean是指切入点表达式包含的类。
- 判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean,或者是否是切面(@Aspect)
- 是否需要跳过----获取候选的增强器(切面里面的通知方法)【List<Advisor> candidateAdvisors】,如果增强器是 AspectJPointcutAdvisor 类型的,则返回true(封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor类型)
判断完成后会创建切入点对象,也就是创建增强bean,bean创建完成后会调用applyBeanPostProcessorsAfterInitialization方法,继而调用后置处理器的postProcessAfterInitialization方法:
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
//调用后置处理器的postProcessAfterInitialization方法
result = beanProcessor.postProcessAfterInitialization(result, beanName);
if (result == null) {
return result;
}
}
return result;
}
postProcessAfterInitialization:
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!this.earlyProxyReferences.contains(cacheKey)) {
return wrapIfNecessary(bean, beanName, cacheKey);//包装如果需要的情况下
}
}
return bean;
}
postProcessAfterInitialization主要有调用了wrapIfNecessary(bean, beanName, cacheKey)方法:包装bean,这里会获取bean的增强器,并且生成动态代理。下面看一下wrapIfNecessary()方法:
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {//不是增强类,则返回
return bean;
}
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// 如果我们有建议,创建代理。
//获取当前bean的所有增强器
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE); //将当前bean放入advisedBeans中
//创建增强bean的代理对象
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
wrapIfNecessary方法中主要是获取当前bean的增强器调用getAdvicesAndAdvisorsForBean方法和创建增强后的bean的代理对象调用createProxy方法,下面看看这两个方法:
getAdvicesAndAdvisorsForBean方法:
@Override
protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName); //获取bean可用的增强器
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
getAdvicesAndAdvisorsForBean方法调用findEligibleAdvisors方法获取bean的增强器:
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
List<Advisor> candidateAdvisors = findCandidateAdvisors();//获取所有可用的增强器
//获取当前bean可用的增强器
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors); //对增强器进行排序
}
return eligibleAdvisors;
}
createProxy方法:
protected Object createProxy(
Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
if (!proxyFactory.isProxyTargetClass()) {
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
//获取当前bean的所有增强器
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);//将增强器保存在代理工程中
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
return proxyFactory.getProxy(getProxyClassLoader()); //创建代理对象
}
Spring是利用ProxyFactory代理工厂创建代理对象:
ProxyFactory创建代理对象:
public Object getProxy(ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
createAopProxy:
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);
}
getAopProxyFactory:
public AopProxyFactory getAopProxyFactory() {
return this.aopProxyFactory;
}
createAopProxy:
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config); //创建JDK动态代理(基于接口)
}
return new ObjenesisCglibAopProxy(config); //创建CGLIB的动态代理(基于类)
}
else {
return new JdkDynamicAopProxy(config);
}
}
到这里AOP创建代理完成。容器可以创建两种动态代理对象:JDK动态代理对象和CGLIB动态代理对象,并最终返回创建完成的代理对象。以后容器中获取到的bean就是这个组件的动态代理bean,执行目标方法的时候,代理对象就会执行通知方法的流程;
下面来看一下代理对象如何执行增强方法和目标方法。
目标方法执行:
容器中创建了目标bean的代理对象,以后从Spring中获取的bean实例都是该代理对象。对象中包含的信息如下:MathCalculator是自己创建的类,也是一个切入点类
可以看出MathCalculator的代理对象中保存了增强器、目标对象等详细信息。
mathCalculator.div(1, 1) 目标方法执行时,会先进入CglibAopProxy类的intercept方法:
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
Class<?> targetClass = null;
Object target = null;
try {
if (this.advised.exposeProxy) {
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
target = getTarget(); //目标对象,也就是切入点对象
if (target != null)
targetClass = target.getClass();
//根据targetClass(ProxyFactory)获取目标方法method的拦截器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
// 如果拦截器链为空
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
// 直接执行目标方法
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = methodProxy.invoke(target, argsToUse);
} else { //连接器链不为空
//将目标方法、拦截器链、等信息封装到CglibMethodInvocation对象中,并执行
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}finally {
if (target != null)
releaseTarget(target);
if (setProxyContext)
AopContext.setCurrentProxy(oldProxy);// 恢复旧的代理。
}
}
intercept方法主要执行逻辑:
- 获取拦截器链 List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
- 如果拦截器链为空,直接执行目标方法
- 如果拦截器链不为空,把需要执行的目标对象,目标方法,拦截器链等信息封装到一个 CglibMethodInvocation 对象,并调用该CglibMethodInvocation对象的proceed()方法,执行增强器方法和目标方法。
下面分别来看一下这三步的执行逻辑:
getInterceptorsAndDynamicInterceptionAdvice方法获取拦截器链:
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) {
MethodCacheKey cacheKey = new MethodCacheKey(method); //缓存目标方法
List<Object> cached = this.methodCache.get(cacheKey); //获取缓存中目标方法的拦截器链
if (cached == null) {//缓存中没有获取到拦截器链
cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
this, method, targetClass); //获取目标方法的拦截器链
this.methodCache.put(cacheKey, cached);
}
return cached;
}
DefaultAdvisorChainFactory类中的getInterceptorsAndDynamicInterceptionAdvice()方法:
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
Advised config, Method method, Class<?> targetClass) {
// 创建一个空集合,用于存放增强器,长度为5
List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
for (Advisor advisor : config.getAdvisors()) { //遍历所有增强器
if (advisor instanceof PointcutAdvisor) { //如果是切入点增强器
PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
MethodInterceptor[] interceptors = registry.getInterceptors(advisor); //将增强器装换成MethodInterceptor
MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
if (mm.isRuntime()) {
for (MethodInterceptor interceptor : interceptors) {
interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
}
}
else {
interceptorList.addAll(Arrays.asList(interceptors));//添加到连接器链中
}
}
}
}
else if (advisor instanceof IntroductionAdvisor) {
IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
Interceptor[] interceptors = registry.getInterceptors(advisor);//将增强器装换成MethodInterceptor
interceptorList.addAll(Arrays.asList(interceptors));
}
}
else {
Interceptor[] interceptors = registry.getInterceptors(advisor);//将增强器装换成MethodInterceptor
interceptorList.addAll(Arrays.asList(interceptors));
}
}
return interceptorList;
}
getInterceptorsAndDynamicInterceptionAdvice方法最终返回 List<Object> interceptorList,interceptorList中封装了所有的拦截器链。向集合中添加拦截器之前都会有一步操作:Interceptor[] interceptors = registry.getInterceptors(advisor),将拦截器转换成Interceptor类型。
registry.getInterceptors(advisor):
public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
Advice advice = advisor.getAdvice();
if (advice instanceof MethodInterceptor) { //如果advice增强器是MethodIntercept类型
interceptors.add((MethodInterceptor) advice);
}
for (AdvisorAdapter adapter : this.adapters) { //遍历适配器
if (adapter.supportsAdvice(advice)) { //适配器类型与增强器类型匹配
interceptors.add(adapter.getInterceptor(advisor)); //将增强器装换成MethodIntercept类型
}
}
if (interceptors.isEmpty()) {
throw new UnknownAdviceTypeException(advisor.getAdvice());
}
return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
}
看一下this.adapters里面的值:
MethodBeforeAdviceAdapter、AfterReturningAdviceAdapter、ThrowsAdviceAdapter分别对象前置通知、后置通知、异常通知。
拦截器连创建完成后返回,然后开始判断拦截器链是否为空:为空则直接执行目标方法,不为空值封装拦截器和目标bean等信息。
直接执行目标方法:
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
// 直接执行目标方法
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = methodProxy.invoke(target, argsToUse);
}
直接执行目标方法的逻辑比较简单,利用反射执行目标方法。
封装拦截器和目标bean等信息并执行目标方法:
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
这个过程分为两步:
- 将proxy(代理对象)、target(目标bean)、method(目标方法)、args(目标方法的参数)、targetClass(目标bean的类型)、chain(拦截器链)、methodProxy(用于调用原始方法)封装进CglibMethodInvocation对象中。
- 执行proceed方法,执行增强器方法和目标方法
proceed()方法:
public Object proceed() throws Throwable {
//this.currentInterceptorIndex初始值为-1,用于记录拦截器的索引
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint(); //执行目标方法
}
//从拦截器链中获取拦截器
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
//如果获取的拦截器是动态匹配方法拦截器类型
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}else { // 动态匹配失败。跳过这个拦截器并调用链中的下一个。
return proceed(); //递归调用
}
}else {
// 调用拦截器:切入点将在构造这个对象之前被静态地计算。
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
下面是拦截器链中的拦截器数据:
调用的第一个invoke(this)方法是ExposeInvocationInterceptor的invoke(this)方法:
public Object invoke(MethodInvocation mi) throws Throwable {
MethodInvocation oldInvocation = invocation.get();
invocation.set(mi);
try {
return mi.proceed(); //继续调用proceed()方法
}finally {
invocation.set(oldInvocation);
}
}
从上面的代码中可以看出proceed方法的执行逻辑:
- 判断拦截器下标和拦截器链中拦截器数量的关系,如果已经获取一个拦截器,执行目标方法并返回。
- 如果拦截器链中还有元素没有获取,则获取下一个拦截器
- 如果获取的拦截器不是动态匹配方法的拦截器类型,则调用该拦截器的invoke方法。
而拦截器的invoke方法中的参数this是指当前CglibMethodInvocation对象,所以执行拦截器时又回到proceed()方法。拦截器链中有五个拦截器,依次看一下这五个拦截器中的invoke方法:
ExposeInvocationInterceptor的invoke方法:
public Object invoke(MethodInvocation mi) throws Throwable {
MethodInvocation oldInvocation = invocation.get();
invocation.set(mi);
try {
return mi.proceed(); //继续调用proceed()方法
}finally {
invocation.set(oldInvocation);
}
}
AspectJAfterThrowingAdvice的invoke方法:
public Object invoke(MethodInvocation mi) throws Throwable {
try {
return mi.proceed();
}catch (Throwable ex) {
if (shouldInvokeOnThrowing(ex)) {
invokeAdviceMethod(getJoinPointMatch(), null, ex);
}
throw ex;
}
}
AfterReturningAdviceInterceptor的invoke方法:
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
Object retVal = mi.proceed();
this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
return retVal;
}
AspectJAfterAdvice的invoke方法:
public Object invoke(MethodInvocation mi) throws Throwable {
try {
return mi.proceed();
}finally {
invokeAdviceMethod(getJoinPointMatch(), null, null);
}
}
MethodBeforeAdviceInterceptor的invoke方法有所不同:
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );//执行拦截器方法
return mi.proceed(); //调用proceed方法
}
从上面的代码中可以看出,这五个拦截器的invoke方法执行流程:
总结:
1)、 @EnableAspectJAutoProxy 开启AOP功能
2)、 @EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator
3)、 AnnotationAwareAspectJAutoProxyCreator是一个InstantiationAwareBeanPostProcessor类型后置处理器;
4)、 容器的创建流程:
1)、registerBeanPostProcessors()注册后置处理器;创建AnnotationAwareAspectJAutoProxyCreator对象
2)、finishBeanFactoryInitialization()初始化剩下的单实例bean
1)、创建业务逻辑组件和切面组件
2)、AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程
3)、组件创建完之后,判断组件是否需要增强
是:切面的通知方法,包装成增强器(Advisor);给业务逻辑组件创建一个代理对象(cglib);
5)、执行目标方法:
1)、代理对象执行目标方法
2)、CglibAopProxy.intercept();
1)、得到目标方法的拦截器链(增强器包装成拦截器MethodInterceptor)
2)、利用拦截器的链式机制,依次进入每一个拦截器进行执行;
3)、效果:
正常执行:前置通知-》目标方法-》后置通知-》返回通知
出现异常:前置通知-》目标方法-》后置通知-》异常通知