spring 注解式 aop实现, 及其运行流程源码解读

最新推荐文章于 2022-09-27 08:55:03 发布
最新推荐文章于 2022-09-27 08:55:03 发布
阅读量304 收藏
点赞数
分类专栏： 源码 spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangyun901222/article/details/104065485
版权

说明: 看源码流程时, 希望各位同学能自己跟着流程走几遍, 别人理解的终究是别人的. 只有自己真正看过才能加深理解

Aspect Class

package com.yangyun.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;

import java.util.Arrays;

/**
 * @ClassName LogAspect
 * @Description:
 * @Author 86155
 * @Date 2020/1/19 10:04
 * @Version 1.0
 **/
@Aspect // 标注为切面类
public class LogAspect {

    /**
     * @Author yangyun
     * @Description:  公共的切入点表达式; 表示在方法执行时触发CalculateService下任意方法, 任意参数, 任意返回值类型
     * @Date 2020/1/19 10:14
     * @Param [point]
     * @returnm void
     **/
    @Pointcut("execution(public * com.yangyun.aop.CalculateService.*(..))")
    public void pointCut(){

    }


    @Before("pointCut()")
    public void logStart(JoinPoint point){
        Object[] args = point.getArgs();
        System.out.println("@Before执行方法: " + point.getSignature().getName() + ", 参数{"+ Arrays.asList(args) +"}");
    }

    @After("pointCut()")
    public void logEnd(JoinPoint point){
        System.out.println("@After执行方法: " + point.getSignature().getName());
    }

    // result 为指定的接收方法的返回值
    @AfterReturning(value = "pointCut()", returning = "result")
    public void logReturning(JoinPoint point, Object result){

    }

    // exception 目标方法出现异常时接收
    @AfterThrowing(value = "pointCut()", throwing = "exception")
    public void logThrowing(JoinPoint point, Exception exception){
        System.out.println("@AfterThrowing"+point.getSignature().getName()+"异常。。。异常信息：{"+exception+"}");
    }
}

Service

package com.yangyun.aop;

import org.springframework.stereotype.Service;

/**
 * @ClassName CalculateService
 * @Description:
 * @Author 86155
 * @Date 2020/1/19 10:03
 * @Version 1.0
 **/
@Service
public class CalculateService {

    public int div(int i, int j){
        System.out.println("processing target method..");
        return i/j;
    }
}

Configuration

package com.yangyun.config;

import com.yangyun.aop.CalculateService;
import com.yangyun.aop.LogAspect;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @ClassName MainAopConfig
 * @Description:
 * @Author 86155
 * @Date 2020/1/19 10:02
 * @Version 1.0
 **/
@EnableAspectJAutoProxy // 开启基于注解版的aop功能
@Configuration
public class MainAopConfig {

    @Bean
    public CalculateService calculateService (){

        return new CalculateService();
    }

    @Bean
    public LogAspect logAspect (){
        return new LogAspect();
    }

}

aop运行流程

分析

  1. 开启基于注解的aop功能需要@EnableAspectJAutoProxy
    1. @Import(AspectJAutoProxyRegistrar.class) 给容器中导入AspectJAutoProxyRegistrar, 利用 AspectJAutoProxyRegistrar自定义给容器中注册 bean(BeanDefinitionRegistry)
    2. class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar(
	AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
	public void registerBeanDefinitions(
        // 如果必要就注册 AspectJAnnotationAutoProxyCreator
    	AopConfigUtils.
        	registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);    
    }
}

       

    3. 给容器中注册 AnnotationAwareAspectJAutoProxyCreator
  2. AnnotationAwareAspectJAutoProxyCreator, 实际上 是一个bean后置处理器
    1. internalAutowiredAnnotationProcessor = AnnotationAwareAspectJAutoProxyCreator --> AspectJAwareAdvisorAutoProxyCreator --> AbstractAdvisorAutoProxyCreator --> AbstractAutoProxyCreator --> implements SmartInstantiationAwareBeanPostProcessorg

流程

  1. 根据配置类创建 IOC 容器 
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainAopConfig.class);

     

  2. 注册配置类, 刷新容器 
    public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    this();
    register(annotatedClasses);
    refresh();
}

     

  3. registerBeanPostProcessors(beanFactory); 在所有应用bean创建之前实例化并注册BeanPostProcessor 
    1. public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
		return doGetBean(name, requiredType, null, false);
	}public static void registerBeanPostProcessors(
	ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    // 获取ioc容器已经定义了的需要创建对象的 BeanPostProcessor
	String[] postProcessorNames = 
        beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    // 添加其他 BeanPostProcessor
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    // 获取 BeanPostProcessor 对象, 并保存到容器中
    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
    // 优先注册实现了 PriorityOrdered 接口的 BeanPostProcessor
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    // 再注册实现了 Ordered 接口的 BeanPostProcessor
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);
    // 然后注册所有常规的 BeanPostProcessor
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
}

public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
    return doGetBean(name, requiredType, null, false);
}

protected <T> T doGetBean(final String name, 
	@Nullable final Class<T> requiredType,
    @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    /**
     * 从缓存中获取根据 BeanPostProcessor 名字获取对应的 BeanPostProcessor, 因为是第一次创
     * 建, 所以 sharedInstance=null
     */
    Object sharedInstance = getSingleton(beanName);
    
    // Create bean instance.
    // 实际在注册获取 BeanPostProcessor 的时候是在创建 BeanPOStProcessor 并保存
    if (mbd.isSingleton()) {
        sharedInstance = getSingleton(beanName, () -> {
            try {
                return createBean(beanName, mbd, args);
            }
            catch (BeansException ex) {
                destroySingleton(beanName);
                throw ex;
            }
        });
        bean = getObjectForBeanInstance(sharedInstance, name,beanName, mbd);
    }
}

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    // 执行创建
	Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    return beanInstance;
}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
	BeanWrapper instanceWrapper = null;
    // 如果是 singleton 移除(其实就更新, 后面会重新添加到容器)
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    // 创建 Bean
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    // 包装 bean
    final Object bean = instanceWrapper.getWrappedInstance();
    
    Object exposedObject = bean;
    try {
        // 属性赋值
        populateBean(beanName, mbd, instanceWrapper);
        // 初始化 bean, BeanPostProcessor 是在bean的初始化前后执行
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
}

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    /**
     * 判断bean是否为 Aware 接口的实现, 如果是会执行 Aware 接口方法的回调
     */
	invokeAwareMethods(beanName, bean);
    
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 应用所有后置处理器 postProcessBeforeInitialization()
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
    try {
        // 执行自定义的初始化方法
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    
    if (mbd == null || !mbd.isSynthetic()) {
        // 应用所有后置处理器 postProcessAfterInitialization()
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
}

       

    2. BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator) 创建成功
    3. registerBeanPostProcessors; 将所有BeanPostProcessor添加到BeanFactory中
  4. ================以上是创建和注册 AnnotationAwareAspectJAutoProxyCreator ==================
  5. finishBeanFactoryInitialization(beanFactory); 完成BeanFactory 初始化工作, 创建剩下的单列 bean 
    1. if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit())// 满足这些条件的单实例bean

       

      1. preInstantiateSingletons; 遍历获取所有的bean, 依次创建 bean getBean() --> doGetBean() --> getSingleton()
    2. 创建 bean

                   AnnotationAwareAspectJAutoProxyCreator 会在任何 bean 创建之前，AnnotationAwareAspectJAutoProxyCreator 返回 Bean 的代理对象

                   【BeanPostProcessor 是在 bean 创建完， 初始化前后调用】

                    【InstantiationAwareBeanPostProcessor 是在创建 bean 实例对象之前先尝试调用后置处理器返回代理对象】

                     

RootBeanDefinition mbdToUse = mbd; // bean的定义信息
// 希望后置处理器在此能返回一个代理对象, 如果能返回就使用, 不能返回在创建
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        // Make sure bean class is actually resolved at this point.
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                /**
                 * 获取所有 BeanPostProcessor, 
                  * 如果是 InstantiationAwareBeanPostProcessor
                  * 就执行 postProcessBeforeInstantiation() 
                 */
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    // 如果后置处理器不为null
                    // 执行所有后置处理器 postProcessAfterInitialization() 
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

                  Object beanInstance = doCreateBean(beanName, mbdToUse, args); 真正去创建一个 bean 实例， 流程和上面 doCreateBean 一致

  1. AnnotationAwareAspectJAutoProxyCreator 【InstantiationAwareBeanPostProcessor 】作用
    1. 在每个 Bean 创建之前， 调用 postProcessBeforeInstantiation()
      1. 判断当前 bean 是否在 advisedBeans（保存了所有需要增强 bean） 中 
        this.advisedBeans.containsKey(cacheKey)

         

      2. 判断当前 bean 是否是基础类型 Advice、Pointcut、Advisor、AopInfrastructureBean 或者是切面（是否使用@Aspect） 
        isInfrastructureClass(beanClass)
protected boolean isInfrastructureClass(Class<?> beanClass) {
    boolean retVal = Advice.class.isAssignableFrom(beanClass) ||
    Pointcut.class.isAssignableFrom(beanClass) ||
    Advisor.class.isAssignableFrom(beanClass) ||
    AopInfrastructureBean.class.isAssignableFrom(beanClass);
    if (retVal && logger.isTraceEnabled()) {
        logger.trace("Did not attempt to auto-proxy infrastructure class [" + beanClass.getName() + "]");
    }
    return retVal;
}
protected boolean isInfrastructureClass(Class<?> beanClass) {
    return (super.isInfrastructureClass(beanClass) ||
        (this.aspectJAdvisorFactory != null && 
         this.aspectJAdvisorFactory.isAspect(beanClass)));
}
public boolean isAspect(Class<?> clazz) {
    return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
}

         

      3. 是否需要跳过当前 bean 
        shouldSkip(beanClass, beanName)
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
    // TODO: Consider optimization by caching the list of the aspect names
    // 获取所有候选的增强器(切面里面的通知方法)
    // 包装后 List<Advisor>, 
    // 每一个增强器都是 InstantiationModelAwarePointcutAdvisor
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    for (Advisor advisor : candidateAdvisors) {
        // 判断是否为 AspectJPointcutAdvisor 类型, 是返回 true
        if (advisor instanceof AspectJPointcutAdvisor &&
            ((AspectJPointcutAdvisor) 
             advisor).getAspectName().equals(beanName)) {
            return true;
        }
    }
    // super.shouldSkip 永远返回false
    return super.shouldSkip(beanClass, beanName);
}

         

    2. 在每个 Bean 创建之后， 调用 postProcessAfterInitialization() 
      // 包装bean 如果需要的情况
return wrapIfNecessary(bean, beanName, cacheKey);

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;
    }
    // 获取当前bean 的所有增强器(通知方法), 获取能在当前bean使用的增强器(通知方法)
    // 找到那些方法是需要切入到当前bean方法的
    // 然后给增强器排序
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), 
                                    beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        // 保存当前bean 到缓存中
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 创建当前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;
}

protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
	@Nullable Object[] specificInterceptors, TargetSource targetSource) {
    // 创建代理工厂
    ProxyFactory proxyFactory = new ProxyFactory();
    /// 获取所有增强器
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    // 定制代理工厂
    customizeProxyFactory(proxyFactory);
    // 获取代理对象
    return proxyFactory.getProxy(getProxyClassLoader());
}

public Object getProxy(@Nullable ClassLoader classLoader) {
    return createAopProxy().getProxy(classLoader);
}
// 创建Aop代理
protected final synchronized AopProxy createAopProxy() {
    if (!this.active) {
        activate();
    }
    return getAopProxyFactory().createAopProxy(this);
}

// 创建aop 代理; spring自动根据匹配动态创建
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)) {
            // jdk 动态代理
            return new JdkDynamicAopProxy(config);
        }
        // cglib 动态代理
        return new ObjenesisCglibAopProxy(config);
    }
    else {
        return new JdkDynamicAopProxy(config);
    }
}
// 最终会返回一个 cglib增强的代理对象, 以后容器中获取到的就是这个组件的代理对象, 执行目标方法的时
// 候, 代理对象就执行通知方法流程
return wrapIfNecessary(bean, beanName, cacheKey);

       

    3. 目标方法执行 (容器中保存了组件的代理对象(cglib 增强后的对象), 这个对象里面保存了详细信息(如: 增强器, 目标对象..) ) 
      1. // 容器返回的为代理对象
CalculateService bean = context.getBean(CalculateService.class);
// 执行目标方法
bean.div(1, 1);

         

      2. 执行目标方法之前会先进入 
        CglibAopProxy.intercept()// 拦截目标方法的执行
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy 
	methodProxy) throws Throwable {
    // 1. 根据 ProxyFactory 获取目标方法的拦截器链
    List<Object> chain =
        this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, 
        targetClass);
    
    // 2. 如果拦截器链为空, 就直接调用目标方法
    if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
    	Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, 
                             args);
        retVal = methodProxy.invoke(target, argsToUse);
    } else {
        // 3. 如果有拦截器链, 把需要执行的目标对象, 目标方法, 参数和拦截器链等信息传入创建
        // 一个 CglibMethodInvocation 对象, 并调用
        retVal = new CglibMethodInvocation(proxy, target, method, args, 
                 	targetClass, chain, methodProxy).proceed();
    }

}
        // 2.1 拦截器链获取, 先从缓存中获取, 如果没有会使用 AdvisorChainFactory 根据 
// ProxyFactory 来获取并缓存
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, 
	@Nullable 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;
}
// 获取连接器链排序后返回
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
    Advised config, Method method, @Nullable Class<?> targetClass) {
 	AdvisorAdapterRegistry registry =
        GlobalAdvisorAdapterRegistry.getInstance();
        Advisor[] advisors = config.getAdvisors();
    // 连接器链,里面保存了
    // 一个默认的ExposeInvocationInterceptor, 还有其他所有通知方法
    List<Object> interceptorList = new ArrayList<>(advisors.length);   
    for (Advisor advisor : advisors) {
        // 遍历所有增强器, 包装成 MethodInterceptor 返回
    	MethodInterceptor[] interceptors = registry.getInterceptors(advisor);   
    }
    return interceptorList;
}

public MethodInterceptor[] getInterceptors(Advisor advisor) throws 
    UnknownAdviceTypeException {
    List<MethodInterceptor> interceptors = new ArrayList<>(3);
    Advice advice = advisor.getAdvice();
    // 如果实现了 MethodInterceptor 直接添加到List中
    if (advice instanceof MethodInterceptor) {
        interceptors.add((MethodInterceptor) advice);
    }
    
    // 如果没有实现MethodInterceptor, 会通过 AdvisorAdapter 进行包装成 
    // AdvisorAdapter
    for (AdvisorAdapter adapter : this.adapters) {
        if (adapter.supportsAdvice(advice)) {
            interceptors.add(adapter.getInterceptor(advisor));
        }
    }
    if (interceptors.isEmpty()) {
        throw new UnknownAdviceTypeException(advisor.getAdvice());
    }
    return interceptors.toArray(new MethodInterceptor[0]);
}

         

         

      3. 拦截器链的执行; 连接器链(将通知方法包装成增强器, 然后在执行目标方法的时候再包装成连接器<MethodInterceptor>)

        ① ExposeInvocationInterceptor(ExposeInvocationInterceptor): 默认拦截器

        ② com.yangyun.aop.LogAspect.logThrowing(AspectJAfterThrowingAdvice)

        ③ com.yangyun.aop.LogAspect.logReturning(AspectJAfterReturningAdvice)

        ④ com.yangyun.aop.LogAspect.logEnd(AspectJAfterAdvice)

        ⑤ com.yangyun.aop.LogAspect.logStart(AspectJMethodBeforeAdvice)

        <MethodBeforeAdviceInterceptor> 

        // CglibMethodInvocation..proceed(); 循环调用
public Object proceed() throws Throwable {
    // currentInterceptorIndex 当前连接器链索引,用来记录, 初始值为 -1
	if (this.currentInterceptorIndex == 
		this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint();
    }
    // 如果有List不为空, 每次执行 currentInterceptorIndex 自增 1;
    // 从第一个开始执行 ++this.currentInterceptorIndex = 0;
    Object interceptorOrInterceptionAdvice = 
        this.interceptorsAndDynamicMethodMatchers.
        get(++this.currentInterceptorIndex);
    // 此处并不匹配
    if (interceptorOrInterceptionAdvice instanceof 
        InterceptorAndDynamicMethodMatcher) {
        InterceptorAndDynamicMethodMatcher dm =
            (InterceptorAndDynamicMethodMatcher) 
            interceptorOrInterceptionAdvice;
        Class<?> targetClass = (this.targetClass != null ? this.targetClass : 
        	this.method.getDeclaringClass());
        if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) 
        {
            return dm.interceptor.invoke(this);
        }
        else {
            return proceed();
        }
    }
    else {
        // 连接器链调用
        return ((MethodInterceptor) 
            interceptorOrInterceptionAdvice).invoke(this);
    }
}
// 第一个为默认拦截器 ExposeInvocationInterceptor
// 从共享变量中获取
private static final ThreadLocal<MethodInvocation> invocation =
    new NamedThreadLocal<>("Current AOP method invocation");

public Object invoke(MethodInvocation mi) throws Throwable {
    MethodInvocation oldInvocation = invocation.get();
    invocation.set(mi);
    try {
        return mi.proceed();
    }
    finally {
        invocation.set(oldInvocation);
    }
}

// 第二个执行 AspectJAfterThrowingAdvice
public Object invoke(MethodInvocation mi) throws Throwable {
    try {
        return mi.proceed();
    }
    catch (Throwable ex) {
        if (shouldInvokeOnThrowing(ex)) {
            invokeAdviceMethod(getJoinPointMatch(), null, ex);
        }
        throw ex;
    }
}

// 第三个执行 AspectJAfterReturningAdvice
public Object invoke(MethodInvocation mi) throws Throwable {
    Object retVal = mi.proceed();
    this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), 
    	mi.getThis());
    return retVal;
}

// 第四个 AspectJAfterAdvice
public Object invoke(MethodInvocation mi) throws Throwable {
    try {
        return mi.proceed();
    }
    finally {
        invokeAdviceMethod(getJoinPointMatch(), null, null);
    }
}

// 第五个 AspectJMethodBeforeAdvice --> MethodBeforeAdviceInterceptor
public Object invoke(MethodInvocation mi) throws Throwable {
    this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
    return mi.proceed();
}

// 所有拦截器执行完 currentInterceptorIndex = 4
if (this.currentInterceptorIndex == 
    this.interceptorsAndDynamicMethodMatchers.size() - 1) {
    // 执行该方法
    return invokeJoinpoint();
}

protected Object invokeJoinpoint() throws Throwable {
    if (this.methodProxy != null) {
        return this.methodProxy.invoke(this.target, this.arguments);
    }
    else {
        return super.invokeJoinpoint();
    }
}

         

小总结

  1. @EnableAspectJAutoProxy 开启AOP 功能
  2. @EnableAspectJAutoProxy 会给容器注册组件 AnnotationAwareAspectJAutoProxyCreator 后置处理器
  3. 容器创建
    1. registerBeanPostProcessors（）注册后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象
    2. finishBeanFactoryInitialization（）初始化剩下的单实例bean
      1. 创建业务逻辑组件和切面组件
      2. AnnotationAwareAspectJAutoProxyCreator 拦截组件的创建
      3. 组件创建完成之后, 判断组件是否需要增强(针对通知方法), 将通知方法包装成增强器(Advisor), 给业务组件创建一个代理对象(cglib)
    3. 执行目标方法
      1. 容器获取代理对象并执行目标方法
      2. CglibAopProxy.intercept()
        1. 得到目标方法连接器链(增强器包装成MetodInterceptor)
        2. 利用连接器的链式机制, 依次执行拦截器
        3. 效果
          1. 正常执行：前置通知--》目标方法--》后置通知--》返回通知
          2. 出现异常：前置通知--》目标方法--》后置通知--》异常通知

学无止境, 永不止步!

更多精彩: https://github.com/SamsaraCloud/study.git

_小拇指
关注
专栏目录
Spring原理与源码分析系列（七）- Spring AOP实现过程与实战
noaman_wgs的博客
03-20 7204
二、Spring AOP 1、什么是Spring AOP Spring AOP是Spring核心框架的重要组成部分，采用Java作为AOP的实现语言。与AspectJ实现AOP方式不同之处在于，Spring AOP仅支持方法级别的拦截。 2、Spring AOP的组成 Spring AOP中主要包括：Joinpoint、Pointcut、Advice、Aspect，下面一...
Spring AOP源码解读
桐花思雨
01-23 4353
aop 是什么 AOP (Aspect-Oriented Programming，面向切面编程)，可以说是 OOP 的补充和完善。OOP 引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP 则显得无能为力。OOP 允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布
SpringAop注解源码
shanchahua123456的博客
09-07 495
分析贴 https://blog.csdn.net/jy02268879/article/details/88409710 https://www.cnblogs.com/nullllun/p/9222627.html 概述 在Bean初始化阶段，Spring为Bean生成代理对象，一个bean对象对应一个代理对象，代理对象的advisors:List中保存所有扫描到的和bean.c...
Spring基于@Aspect注解实现AOP的源码解析
u011523825的博客
09-27 773
Spring AOP @Aspect注解
spring源码剖析（五）利用AOP实现自定义Spring注解
Fighter168的专栏
04-17 7123
自定义Spring注解，利用AOP实现自定义Spring注解
spring源码解析-基于注解的SpringAOP源码解析（一）
JASON_CHEN
03-31 247
本文分析Spring的AOP模块的整体流程，分析过程需要使用一个简单的demo工程来启动Spring。 https://github.com/cjinjun/spring-framework-demo 写一个简单的接口和实现类，跟IOC源码解析那几篇文章用的同一个工程， public interface IOCService { public String helloIoc(); } ...
spring aop 自定义注解保存操作日志到mysql数据库 源码
11-25
一、适合人群 1、具备一定Java编程基础，初级开发者 ...（需要知道原理的请看spring aop源码，此处不做赘述） 3、可在现有源码上快速进行功能扩展 4、spring boot，mybatis，druid，spring aop的使用
Spring Boot中整合Jasypt 使用自定义注解+AOP实现敏感字段的加解密教程配套源码
最新发布
06-09
该源码对应个人博客【Spring Boot中整合Jasypt 使用自定义注解+AOP实现敏感字段的加解密】教程的相关源码，小伙伴可以自行下载学习！不需要积分！不需要积分！不需要积分！ 如果相关资源对您有所帮助，希望一键三连...
Spring基于注解实现AOP
04-07
本篇文章将深入探讨如何在Spring中通过注解实现AOP。 首先，了解AOP的基本概念。面向切面编程是一种编程范式，它允许程序员定义“切面”，这些切面包含了跨越多个对象的行为或责任。切点是这些行为插入到主业务逻辑...
Spring 基于注解方式实现AOP
04-19
在Spring框架中，基于注解的AOP（面向切面编程）是一种强大的工具，它允许开发者无需编写XML配置即可实现切面。这种编程方式极大地提高了代码的可读性和可维护性。下面我们将深入探讨如何使用注解来实现Spring AOP。...
spring2--aop及事务高级特性
shining曙光的博客
12-19 188
https://segmentfault.com/a/1190000022694615
基于注解的SpringAOP源码解析（一）
javaxuexilu的博客
08-14 291
准备工作本文会分析Spring的AOP模块的整体流程，分析过程需要使用一个简单的demo工程来启动Spring，demo工程我以备好，需要的童鞋自行在下方链接下载：htt...
基于注解式的SpringAOP源码解析-1-SpringAOP代码示例
way2016的博客
03-11 570
SpringAOP代码示例基于注解式的SpringAOP源码解析前言基于注解式的SpringAOP使用代码示例代码工程结构图代码处理步骤1、pom.xml导入aop模块2、定义一个业务逻辑类 MathCalculator.java3、定义一个日志切面类LogAspects.java4、将切面类和业务逻辑类加入到容器中 MainConfigOfAOP.java5、编写单元测试类进行测试 IOCTes...
Spring 14 - Spring实现AOP流程 - 方法三：使用注解实现AOP
m0_38071676的博客
07-30 91
流程： 1.标记切面@Aspect 2.标记通知类型和切入点 4.标记@Component，注册bean 例： package com.spring.qq.diy; //使用注解方式实现aop import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.st
源码剖析springAOP的执行流程（注解方式启动spring）
帝都的雁的博客
03-31 614
源于蚂蚁课堂的学习，点击这里查看 1.源码流程 2.总结 1.@EnableAspectJAutoProxy开启aop 2.底层是将AspectJAutoProxyRegistrar注入spring容器 3.AspectJAutoProxyRegistrar通过AopConfigUtil...
深入SpringAOP实现流程（源码分析）
瑞文のBlog
01-23 556
系列文章目录 SpringAOP实现 深入SpringAOP实现流程（源码分析 文章目录系列文章目录一、SpringAOP实现（源码追踪）1.@EnableAspectJAutoProxy 开启AOP2.底层引用类：@Import(AspectJAutoProxyRegistrar.class)3.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry)注册切面类4.AnnotationAwareAspectJAutoProxyCrea
Aop说明
weixin_34068198的博客
04-15 93
在xml配置中用到那个标签在开启不然不用，他会报错 1.对接口进行动态代理：创建出来的对象必须转换成接口类型 原因他创建的是实现类而不是不是接口所以实现的时候必须转换成接口 他动态实现的是实...
Spring AOP原理以及Spring源码实现分析
qq_36975405的博客
08-26 236
1.从字面的意思理解AOP.?     面向切面编程（全称Aspect Oriented programing），通过预编译的方式和动态代理（运行期）实现程序功能的一种方式，AOP      是对OOP(面向对象编程)的一种扩充。 2.AOP解决了什么问题？    在一个完善的系统中，我们常用到的监听、日志、权限、事务、缓存等等操作，在这些业务场景中我们需要对多个方法或者对多个动作调用之前或...
spring源码剖析AOP实现原理剖析
dxx707099957的博客
03-25 370
Spring的AOP实现原理，酝酿了一些日子，写博客之前信心不是很足，所以重新阅读了一边AOP的实现核心代码，而且又从网上找了一些Spring Aop剖析的例子，但是发现挂羊头买狗肉的太多，标题高大上，内容却大部分都是比较浅显的一些介绍，可能也是由于比较少人阅读这部分的核心代码逻辑把，然后写这部分介绍的人估计也是少之又少，不过说实话，Spring Aop的核心原理实现介绍确实不太好写，里面涉及的类...
深度解析Spring AOP源码执行流程
"这篇文档详细解析了Spring AOP的源码流程，主要关注在Spring容器初始化过程中自动代理创建的相关步骤。" 在Spring框架中，AOP（面向切面编程）是一种强大的工具，它允许开发者在不修改代码的情况下，对应用程序的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值