spring-aop原理解析

最新推荐文章于 2022-04-19 11:45:24 发布
最新推荐文章于 2022-04-19 11:45:24 发布
阅读量71 收藏
点赞数
分类专栏： spring 文章标签： java spring restful
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37604110/article/details/122531541
版权
1.@EnableAspectJAutoProxy原理
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

   /**
    * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
    * to standard Java interface-based proxies. The default is {@code false}.
    */
   boolean proxyTargetClass() default false;

   /**
    * Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
    * for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
    * Off by default, i.e. no guarantees that {@code AopContext} access will work.
    * @since 4.3.1
    */
   boolean exposeProxy() default false;

}

这部分主要是给AnnotationAwareAspectJAutoProxyCreator注册在IOC容器里面

@Import(AspectJAutoProxyRegistrar.class)给容器导入AspectJAutoProxyRegistrar.class

利用AspectJAutoProxyRegistrar自定义给容器中注册bean,注册了internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator. 的定义信息
其实@EnableAspectJAutoProx y就是给容器中注册了一个AnnotationAwareAspectJAutoProxyCreator

@Nullable
	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
	}

@Nullable
	private static BeanDefinition registerOrEscalateApcAsRequired(
			Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		---核心代码----
//定义RootBeanDefinition,装注册bean的定义信息   //org.springframework.aop.config.internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
		beanDefinition.setSource(source);
		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
		return beanDefinition;
	}

上面定义RootBeanDefinition,加载注册bean的定义信息,然后注册org.springframework.aop.config.internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator. 在容器里面(只是注册了BeanDefinition,没有创建对象,创建对象在下一步)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WaG2cYDO-1642349415836)(/Users/laiyanxin/Library/Application Support/typora-user-images/image-20191126220112397.png)]

从类图可以看出AnnotationAwareAspectJAutoProxyCreator实现了后置处理器和自动装配BeanFactory

2.AnnotationAwareAspectJAutoProxyCreator注册
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		this();
		register(componentClasses);
		refresh();
	}

refresh()中registerBeanPostProcessors(beanFactory)就是注册BeanPostProcessors

从上面类图可以看出AnnotationAwareAspectJAutoProxyCreator实现了BeanPostProcessors.
实现了BeanPostProcessors接口的实现类,调用通常分两部分,先注册,后调用.
这步主要是注册BeanPostProcessors,调用里面的实现方法在创建bean的时候

注册BeanPostProcessor实际上就是创建BeanPostProcessor对象的保存在容器中

具体逻辑

public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
	//1.获取ioc容器中已经定义好的需要创建对象的所有BeanPostProcessor
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
  //2.给容器中添加别的BeanPostProcessor-》BeanPostProcessorChecker 
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

  --------省略了区分BeanPostProcessor的逻辑------------------
  
		//3 优选注册实现了PriorityOrdered接口的BeanPostProcessor.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// 4再给容器中注册实现了Ordered接口的BeanPostProcessor.
 // AnnotationAwareAspectJAutoProxyCreator实现了Ordered接口
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String ppName : orderedPostProcessorNames) {
      //ppName=internalAutoProxyCreator,从beanFactory获取
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
  	//7.把BeanPostProcessor注册到BeanFactory
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);
  //里面逻辑就是beanFactory.addBeanPostProcessor(postProcessor) 注册的最后一步

		// 5再注册没实现优先接口的BeanPostProcessor.
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// Finally, re-register all internal BeanPostProcessors.
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		//把BeanPostProcessor注册到BeanFactory
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

//6因为internalAutoProxyCreator没有在从beanFactory获取,所以需要创建internalAutoProxyCreator对象
//6创建的internalAutoProxyCreator的BeanPostProcessor就是AnnotationAwareAspectJAutoProxyCreator
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
		
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
      //6.1创建bean的实例createBeanInstance
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
      //6.2populateBean给bean各种属性赋值
			populateBean(beanName, mbd, instanceWrapper);
      //6.3initializeBean初始化bean
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
	}
-----------------------------------
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
      //6.3.1。invokeAwareMethods 处理Aware接口的方法回调 
			//里面创建AnnotationAwareAspectJAutoProxyCreator对 象
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
      //6.3.2 应用后置处理器BeanPostProcessorsBeforeInitialization 
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
      //6.3.3invokeInitMethods 执行自定义初始化方法
			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()) {
      //6.3.4 应用后置处理器BeanPostProcessorsAfterInitialization
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

流程

  1. 获取ioc容器中已经定义好的需要创建对象的所有BeanPostProcessor

  2. 给容器中添加别的BeanPostProcessor-》BeanPostProcessorChecker

  3. 优选注册实现了PriorityOrdered接口的BeanPostProcessor

  4. 再给容器中注册实现了Ordered接口的BeanPostProcessor.

  5. 再注册没实现优先接口的BeanPostProcessor.

  6. 注册BeanPostProcessor实际上就是创建BeanPostProcessor对象的保存在容器中

    这次创建的internalAutoProxyCreator的BeanPostProcessor-》AnnotationAwareAspectJAutoProxyCreator

    1. 创建bean的实例createBeanInstance
    2. populateBean给bean各种属性赋值
    3. initializeBean初始化bean
      1. invokeAwareMethods 处理Aware接口的方法回调
        里面setBeanFactory创建成功AnnotationAwareAspectJAutoProxyCreator对象
      2. applyBeanPostProcessorsBeforeInitialization 应用后置处理器BeforeInitialization
      3. invokeInitMethods 执行自定义初始化方法
      4. applyBeanPostProcessorsAfterInitialization 应用后置处理器AfterInitialization

  7. 把BeanPostProcessor注册到BeanFactory
    beanFactory.addBeanPostProcessor(postProcessor)

---------------以上是创建和注册AnnotationAwareAspectJAutoProxyCreator过程-----------

3.AnnotationAwareAspectJAutoProxyCreator的调用
	@Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
  

				if (mbd.isSingleton()) {
            // 先从缓冲中获取当前bean,如果能获取到,说明bean是之前被创建过的,直接使用,否则再创建,主要创建好的bean都会被缓存起来,(单例才会被缓存)
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
			}

  1. 遍历获取容器中所有bean,依次创建对象getBean(beanName);

    ​ getBean->doGetBean->getSingleton

  2. createBean创建bean ,

    BeanPostProcessor是Bean对象创建完成初始化前后调用的
    InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回的对象

    AnnotationAwareAspectJAutoProxyCreator属于InstantiationAwareBeanPostProcessor会在任何bean创建之前先尝试返回bean的实例

    1. 先从缓冲中获取当前bean,如果能获取到,说明bean是之前被创建过的,直接使用,否则再创建,主要创建好的bean都会被缓存起来,(单例才会被缓存)
    2. createBean();创建Bean
      1. resolveBeforeInstantiation,解析BeforeInstantiation,希望后置处理器在此能返回一个代理对象,如果能返回对象就使用,如果不能就继续,里面流程在第四步
      2. doCreateBean,里面流程跟第二步2.6里面一样
    	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
    
		RootBeanDefinition mbdToUse = mbd;
    //解析bean的定义信息
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		try {
      //解析BeforeInstantiation,希望后置处理器在此能返回一个代理对象,如果能返回对象就使用,如果不能就继续
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}
		}

		try {
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
	}
4.AnnotationAwareAspectJAutoProxyCreator创建AOP代理
//1.在每一个bean创建之前,调用postProcessBeforeInstantiation
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
   Object cacheKey = getCacheKey(beanClass, beanName);

   if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
    // 1.1先判断当前bean是否在advisedBeans中(保存了所有需要增强的bean)
      if (this.advisedBeans.containsKey(cacheKey)) {
         return null;
      }
//1.2 isInfrastructureClass(beanClass)判断档期bean是否是基础类型Advice,Pointcut,Advisor,AopInfrastructureBean,或者是切面(@Aspejct) 
     //1.3是否需要跳过—》shouldSkip,永远返回false
      if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
         this.advisedBeans.put(cacheKey, Boolean.FALSE);
         return null;
      }
     
   }


   // 判断是否有自定义TargetSource,这里没什么关系
   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;
   }
1.在每一个bean创建之前,调用postProcessBeforeInstantiation

  • 先判断当前bean是否在advisedBeans中(保存了所有需要增强的bean)-》isInfrastructureClass

  • 判断当前bean 是否是基础类型Advice,Pointcut,Advisor,AopInfrastructureBean或者是切面(@Aspejct)

  • 是否需要跳过—》shouldSkip

    @Override
	protected boolean shouldSkip(Class<?> beanClass, String beanName) {
	//需要获选增强器(切面里面的通知方法)
		List<Advisor> candidateAdvisors = findCandidateAdvisors();
  //  判断每一个增强器是否是AspectJPointcutAdvisor类型,返回true\
    // 每一个封装的通知方法的增强器是InstantiationModelAwarePointcutAdvisor类型,永远返回false
		for (Advisor advisor : candidateAdvisors) {
			if (advisor instanceof AspectJPointcutAdvisor &&
					((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
				return true;
			}
		}
		return super.shouldSkip(beanClass, beanName);
	}
    • 需要获选增强器(切面里面的通知方法)List<Advisor>,每一个封装的通知方法的增强器是InstantiationModelAwarePointcutAdvisor,判断每一个增强器是否是AspectJPointcutAdvisor类型,返回true
    • 永远返回false
    2.创建代理对象

    初始化调用postProcessBeforeInstantiation之前,再调用初始化后的postProcessAfterInitialization

@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
   if (bean != null) {
      Object cacheKey = getCacheKey(bean.getClass(), beanName);
      if (this.earlyProxyReferences.remove(cacheKey) != bean) {
         return wrapIfNecessary(bean, beanName, cacheKey);
      }
   }
   return bean;
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		if (StringUtils.hasLength(beanName) && 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;
		}

		// 1.获取当前bean能使用的增强器,即通知方法
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		if (specificInterceptors != DO_NOT_PROXY) {
      //2.保存当前bean在AdcvisedBeans中,
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
      //3.如果当前bean需要增强,创建当前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;
	}

核心在于getAdvicesAndAdvisorsForBean

@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(
      Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
	//1.找到可用的增强器(通知方法)
   List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
   if (advisors.isEmpty()) {
      return DO_NOT_PROXY;
   }
   return advisors.toArray();
}

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
  //1.1找到候选的所有增强器,即我们写的所有增强方法
		List<Advisor> candidateAdvisors = findCandidateAdvisors();
  //1.2获取到能在当前bean使用的增强器(即找哪些增强方法需要切入当前bean方法的)
		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
		extendAdvisors(eligibleAdvisors);
  //1.3  给增强器排序
		if (!eligibleAdvisors.isEmpty()) {
			eligibleAdvisors = sortAdvisors(eligibleAdvisors);
		}
		return eligibleAdvisors;
	}

上面流程

  1. 获取当前bean能使用的增强器,(通知方法) Object[] specificInterceptors

    • 首先找到候选的所有增强器,即我们写的所有增强方法
    • 获取到能在当前bean使用的增强器(即找哪些增强方法需要切入当前bean方法的)
    • 给增强器排序

  2. 保存当前bean在AdcvisedBeans中,

  3. 如果当前bean需要增强,创建当前bean的代理对象

    • 获取当前bean所有增强器(增强方法)

    • 把所有增强器(保存到ProxyFactory

    • 创建代理对象由spring自动决定

      new ObjenesisCglibAopProxy(config);
      new JdkDynamicAopProxy(config);

      protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
      @Nullable 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);
      }
   }
//3,1获取当前bean所有增强器(增强方法)
   Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
  //3.2把所有增强器(保存到ProxyFactory）
   proxyFactory.addAdvisors(advisors);
   proxyFactory.setTargetSource(targetSource);
   customizeProxyFactory(proxyFactory);

   proxyFactory.setFrozen(this.freezeProxy);
   if (advisorsPreFiltered()) {
      proxyFactory.setPreFiltered(true);
   }
//3.3创建代理对象由spring自动决定,给容器返回当前组件使用cglib增强了的代理对象
  //Spring会自动决定使用jdk,cglib动态代理,也可以通过配置
  //4.给容器返回当前组件使用cglib增强了的代理对象
  //5.以后容器中获取到就是这个组件的代理对象,执行目标方法的时候,代理对象会执行通知方法的流程
   return proxyFactory.getProxy(getProxyClassLoader());
}

  4. 给容器返回当前组件使用cglib增强了的代理对象

  5. 以后容器中获取到就是这个组件的代理对象,执行目标方法的时候,代理对象会执行通知方法的流程

5.目标方法执行

IOC容器中保存了组件的代理对象(cglib增强后的对象),这个对象保存了详细信息(比如增强器,目标对象,x x x等等)

执行目标方法执行会被CglibAopProxy.intercept拦截

//1.CglibAopProxy.intercept拦截目标执行
		@Nullable
		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
		
			TargetSource targetSource = this.advised.getTargetSource();
			try {
				if (this.advised.exposeProxy) {
					oldProxy = AopContext.setCurrentProxy(proxy);
					setProxyContext = true;
				}
				
        //2.根据ProxyFactory对象获取将要执行的目标方法拦截器链
				List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
				Object retVal;
			//3.如果没有拦截器链,直接执行目标方法拦截器链每一个通知被包装成方法拦截器,利用MethodInterceptor
				if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
			
					Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
					retVal = methodProxy.invoke(target, argsToUse);
				}
				else {
          //4. 如果有拦截器链,把需要执行的目标对象,目标方法,拦截器链等信息传入一个CglibMethodInvocation并调用
					retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
				}
				retVal = processReturnType(proxy, target, method, retVal);
				return retVal;
			}
		}
  1. CglibAopProxy.intercept拦截目标执行
  2. 根据ProxyFactory对象获取将要执行的目标方法拦截器链
    1. List interceptorList 保存所有拦截器,其中一个默认的是ExposeInvocationInterceptor
    2. 遍历所有增强器,将其转为interceptor
      Interceptor[] interceptors = registry.getInterceptors(advisor)
    3. 将增强器转为List<MethodInterceptor>,如果是MethodInterceptor直接加入到集合中,如果不是,使用AdvisorAdapter适配器将增强器转为MethodInterceptor, 转换完成返回MethodInterceptor数组
  3. 如果没有拦截器链,直接执行目标方法
    拦截链就是把每一个通知方法包装为方法拦截器,利用MethodInterceptor
  4. 如果有拦截器链,把需要执行的目标对象,目标方法,拦截器链等信息传入一个CglibMethodInvocation,下一步调用proceed()方法;
//根据ProxyFactory对象获取将要执行的目标方法拦截器链
@Override
	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
			Advised config, Method method, @Nullable Class<?> targetClass) {

		AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
		Advisor[] advisors = config.getAdvisors();
    //2.1保存所有拦截器,其中一个默认的是ExposeInvocationInterceptor
		List<Object> interceptorList = new ArrayList<>(advisors.length);
		Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
		Boolean hasIntroductions = null;
		//2.2遍历所有增强器,将其转为interceptor
		for (Advisor advisor : advisors) {
          //核心代码,
					Interceptor[] interceptors = registry.getInterceptors(advisor);
      //将增强器转为List<MethodInterceptor>
					interceptorList.addAll(Arrays.asList(interceptors));
		}
		return interceptorList;
	}
//2.3.将增强器转为List<MethodInterceptor>,如果是MethodInterceptor直接加入到集合中,如果不是,使用AdvisorAdapter适配器将增强器转为MethodInterceptor, 转换完成返回MethodInterceptor数组
@Override
	public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
   
		List<MethodInterceptor> interceptors = new ArrayList<>(3);
		Advice advice = advisor.getAdvice();
    //如果是MethodInterceptor直接加入到集合中
		if (advice instanceof MethodInterceptor) {
			interceptors.add((MethodInterceptor) advice);
		}
    //如果不是,使用AdvisorAdapter将增强器转为MethodInterceptor
		for (AdvisorAdapter adapter : this.adapters) {
			if (adapter.supportsAdvice(advice)) {
				interceptors.add(adapter.getInterceptor(advisor));
			}
		}
		if (interceptors.isEmpty()) {
			throw new UnknownAdviceTypeException(advisor.getAdvice());
		}
    //转换完成返回MethodInterceptor数组
		return interceptors.toArray(new MethodInterceptor[0]);
	}
  1. 调用proceed()方法,拦截器链的触发过程
    1. 如果没有拦截器执行目标方法,或者拦截器的索引和拦截器数组-1大小一样(指定了最后一个拦截器)执行目标方法
    2. 链式获取每一个拦截器,拦截器执行invoke方法,每一个拦截器等待下一个拦截执行完成返回以后再来执行,拦截器链的机制,保证通知方法和目标方法的执行顺序
@Override
	@Nullable
	public Object proceed() throws Throwable {
		//5.1如果没有拦截器执行目标方法,或者拦截器的索引和拦截器数组-1大小一样(指定了最后一个拦截器)执行目标方法
		if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
			return invokeJoinpoint();
		}	
    
    //5,2链式获取每一个拦截器,拦截器执行invoke方法,每一个拦截器等待下一个拦截执行完成返回以后再来执行,拦截器链的机制,保证通知方法和目标方法的执行顺序
Object interceptorOrInterceptionAdvice =
			this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
	if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
		InterceptorAndDynamicMethodMatcher dm =
				(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
			return dm.interceptor.invoke(this);
		}
		else {
			return proceed();
		}
	}
	else {
		return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
	}
}

在这里插入图片描述

链式调用图

6.总结

  1. @EnableAspectJAutoProxy开启Aop功能

  2. @EnableAspectJAutoProxy给容器注册一个组件AnnotationAwareAspectJAutoProxyCreator

  3. aAnnotationAwareAspectJAutoProxyCreator是一个后置处理器

  4. 容器创建流程

    1. registerBeanPostProcessors() 注册后置处理器,创建AnnotationAwareAspectJAutoProxyCreator
    2. finishBeanFactoryInitializatiom()初始化剩下的单实例bean
      1. 创建业务逻辑组件bean(我们写的业务代码)和切面组件bean(增强类)
      2. AnnotationAwareAspectJAutoProxyCreator的后置处理器会拦截组件bean的创建
      3. 组件创建完成后,判断组件bean是否需要增强
        是:切面的通知方法包装成增强器(Advisor),给业务逻辑组件bean创建一个代理对象(cglib)

  5. 执行目标方法

    1. 代理对象执行目标方法

    2. org.springframework.aop.framework.CglibAopProxy.DynamicAdvisedInterceptor#intercept拦截目标执行

      • 得到目标方法拦截器链(增强器包装成拦截器MethodInterceptor)

      • 利用拦截器链,依次进入每一个拦截器进行执行

      • 效果
        正常执行:前置通知-》目标方法->后置通知-〉返回通知

        正常执行:前置通知-》目标方法->后置通知-〉异常通知

错觉_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring启动流程探索一、register(componentClasses)；
qq_37827889的博客
04-20 707
spring探索第一节spring启动流程开始AnnotationConfigApplicationContext(Class<?>... componentClasses)register(componentClasses);AnnotatedGenericBeanDefinition(beanClass);resolveScopeMetadataapplyScopedProxyMode spring启动流程 spring用了很多年了，也会偶尔去看下，或者说去研究下spring源码，看spri
Spring Aop源码解析
m0_37604110的博客
11-28 104
1.@EnableAspectJAutoProxy原理 点击进去可以看到 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(AspectJAutoProxyRegistrar.class) public @interface EnableAspectJAutoProxy { /...
@Column导包错误引发无法创建internalAutoProxyCreator
不积跬步，无以至千里
05-10 648
@Column导包错误 当引入spring-boot-starter-data-jpa.jar和aspectjweaver.jar的时候， @Column的红色报错消失 但是实际运行时，会出现无法启动的问题 Exception sending context initialized event to listener instance of class org.springframework.web.context.ContextLoaderListener org.springfr
SpringAOP AspectJAutoProxyCreator的创建
liuqiang211的专栏
02-03 129
Spring容器启动的时候调用 1.注册后置处理器 用于拦截bean的创建 (registerBeanPostProcessors) 2.获取所有已经定义了的后置处理器 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); org.springframework.aop.config.internalAutoProxyCreator =Annotat
【spring源码】七、后置处理器BeanPostProcessor
努力充实，远方可期
12-20 281
⑥registerBeanPostProcessors() 注册（实例化）后置处理器 我们想要了解spring在什么时候注册自动代理，即@EnableAspectJAutoProxy等一系列执行的时机。这里值得注意的是，@EnableAspectJAutoProxy的操作是在refresh()方法的invoke()阶段完成了bean定义信息的注入，而还没完成实例化。实例化是在registerBeanPostProcessor注册后置处理器阶段完成的。 public abstract class Abstra
spring5.2.x源码阅读笔记-AnnotationConfigApplicationContext构建（二）register(componentClasses)
weixin_43836063的博客
04-08 645
接上一篇，使用同样的测试用例 代码块1：register(Class<?>... componentClasses) public void register(Class<?>... componentClasses) { Assert.notEmpty(componentClasses, "At least one component class must be specified"); this.reader.register(componentClasses);
Spring AOP实现原理解析
08-28
主要为大家详细介绍了Spring AOP的实现原理，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Spring AspectJ AOP框架注解原理解析
09-07
主要介绍了Spring AspectJ AOP框架注解原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring aop 原理解析
11-02
介绍Spring AOP的原理，还有例子
Spring技术内幕 - 深入解析Spring架构与设计原理.rar
06-07
深入理解spring原理，详细介绍了IOC、AOP等基本原理与实现，解析源代码，值得推荐！
深入解析Spring AOP源码：从原理到实现，全方位掌握Java AOP编程精髓
最新发布
12-13
通过详细解析Spring AOP的源码，本文揭示了其背后的核心原理和实现机制。Spring AOP主要基于动态代理模式，它允许开发者在不改变原有代码结构的情况下，增加额外的行为。这主要通过定义“切面（Aspects）”和“通知...
Spring源码分析系列(1)之bean工厂的创建+内置bean的注册（this()+this.register(componentClasses)）
m0_60907200的博客
04-19 1028
Spring源码分析系列(1)之bean工厂的创建+内置bean的注册（this()+this.register(componentClasses)）
Spring 容器的启动过程
Java笔记虾
09-01 1982
本文来源：http://r6f.cn/b47K一. 前言Spring家族特别庞大，对于开发人员而言，要想全面征服Spring家族，得花费不少的力气。俗话说，打蛇打七寸，那么Spring家...
spring注解版register方法
sinat_41900642的博客
01-27 886
spring注解版构造函数中register方法 1.第一步 public AnnotationConfigApplicationContext(Class<?>... componentClasses) { this(); register(componentClasses);// 《==== 1. refresh(); } 2.第二步 @Override public void register(Class<?>... componentClasses) {
Spring源码解析(一)AnnotationConfigApplicationContext实例化，注册方法
qq_41184055的博客
01-09 394
解析Spring源码，首先从第一行代码看起 Config.java配置类 @Configuration @ComponentScan("com.spring") public class Config { } Test.java public class Test { public static void main(String[] args) { AnnotationConfigAppl...
Spring源码之启动过程（一）—— 容器的启动
奔跑的蜗牛_Kieasr
10-31 1227
registerAnnotationConfigProcessors()方法 所属类：org.springframework.context.annotation.AnnotationConfigUtils public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors( BeanDefinitionRegistry registry, @Nullable Object source) { ..
Spring【版本5.2.2】容器初始化过程（一）this与register
屹想天开
11-22 536
因为我还是比较喜欢转载的，人家总结的漂漂亮亮的，何苦自己在整轮子，但是关于spring容器初始化过程相关文章，是在找不到一个合适的，所以自己整理了一篇。 废话不多说，直接上代码，因为后面废话更多，如有错误，留言指正，都是学习 首先准备一个测试代码： public class IocTest2 { public static void main(String[] args) { BeanFac...
Spring 源码学习 07：ClassPathBeanDefinitionScanner
程序员小航
12-06 425
前言 AnnotationConfigApplicationContext 构造函数除了初始化一个 reader ，还有一个 scanner，下面来一起看看 ClassPathBeanDefinitionScanner 都有什么逻辑。 源码分析 this.scanner = new ClassPathBeanDefinitionScanner(this); 代码如下所示： 其中 useDefaultFilters 默认设置的 true。所以最终会执行下面三部分代码： registerDefaultFi
spring aop源码解析
05-04
Spring AOP的源码解析涉及到很多细节，包括代理的生成、通知的执行、切点的匹配等，需要深入了解Spring框架的内部实现和Java的反射机制。对于初学者而言，可以先从Spring AOP的基本概念和用法入手，了解其实现原理的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值