Spring创建AOP代理（源码分析一）

最新推荐文章于 2024-10-06 00:07:57 发布
最新推荐文章于 2024-10-06 00:07:57 发布
阅读量237 收藏
点赞数
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53836264/article/details/123954326
版权

全文搜索AnnotationAwareAspectJAutoProxyCreator，它到底是如何完成AOP的操作呢？

我们首先看看AnnotationAwareAspectJAutoProxyCreator类的层次结构。

 在类的层次结构中，我们看到AnnotationAwareAspectJAutoProxyCreator实现了BeanPostProcessor接口，而实现BeanPostProcessor后，当spring加载这个Bean时会在实例化前调用其postProcessAfterInitialization方法，我们对AOP的分析也从此开始：

在父类AbstractAutoProxyCreator的PostProcessAfterInitialization中的代码如下:

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

        return bean;
    }

    protected Object getCacheKey(Class<?> beanClass, @Nullable String beanName) {
        if (StringUtils.hasLength(beanName)) {
            return FactoryBean.class.isAssignableFrom(beanClass) ? "&" + beanName : beanName;
        } else {
            return beanClass;
        }
    }

    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        } else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        } else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) {
            Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
            if (specificInterceptors != DO_NOT_PROXY) {
                this.advisedBeans.put(cacheKey, Boolean.TRUE);
                Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
                this.proxyTypes.put(cacheKey, proxy.getClass());
                return proxy;
            } else {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return bean;
            }
        } else {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
    }

​

函数中我们已经看到了代理创建的底雏形。当然真正开始之前还需要经过一些判断，比如是否已经处理过或者是否需要跳过bean，而真正创建代理的代码是从getAdvicesAndAdvisorsForBean开始的:

创建代理主要包含了两个步骤:

(1)获取增强方法或者增强容器）。

(2)根据获取的增强进行代理。

我们首先来看看获取增强方法的实现逻辑：

我在其子类AbstractAdvisorAutoProxyCreator跟踪源码发现:

 @Nullable
    protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
        List<Advisor> advisors = this.findEligibleAdvisors(beanClass, beanName);
        return advisors.isEmpty() ? DO_NOT_PROXY : advisors.toArray();
    }

    protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
        List<Advisor> candidateAdvisors = this.findCandidateAdvisors();
        List<Advisor> eligibleAdvisors = this.findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        this.extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            eligibleAdvisors = this.sortAdvisors(eligibleAdvisors);
        }

        return eligibleAdvisors;
    }

对于指定bean的增强方法的获取一定是包含两个步骤的，获取所有的增强以及寻找所有增强中适用于bean的增强并应用，那么findCandidateAdvisors与findAdvisorsThatCanApply便是做了这两件事情。源代码在同类下方查找即可:     获取增强器:

  protected List<Advisor> findCandidateAdvisors() {
        Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
        return this.advisorRetrievalHelper.findAdvisorBeans();
    }

    protected List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
        ProxyCreationContext.setCurrentProxiedBeanName(beanName);

        List var4;
        try {
            var4 = AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
        } finally {
            ProxyCreationContext.setCurrentProxiedBeanName((String)null);
        }

        return var4;
    }

    protected boolean isEligibleAdvisorBean(String beanName) {
        return true;
    }

    protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
        AnnotationAwareOrderComparator.sort(advisors);
        return advisors;
    }

AnnotationAwareAspectJAutoProxyCreator间接继承了AbstractAdvisorAutoProxyCreator，在实现获取增强的方法中除了保留父类的获取配置文件定义的增强外，同时添加了获取Bean的注解增加功能，其实是由this.aspectJAdvisorsBuilder.buildAspectJAdvisors()来实现的。

我能来看看代码实现:

public List<Advisor> buildAspectJAdvisors() {
        List<String> aspectNames = this.aspectBeanNames;
        if (aspectNames == null) {
            synchronized(this) {
                aspectNames = this.aspectBeanNames;
                if (aspectNames == null) {
                    List<Advisor> advisors = new ArrayList();
                    List<String> aspectNames = new ArrayList();
                    String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
                    String[] var18 = beanNames;
                    int var19 = beanNames.length;

                    for(int var7 = 0; var7 < var19; ++var7) {
                        String beanName = var18[var7];
                        if (this.isEligibleBean(beanName)) {
                            Class<?> beanType = this.beanFactory.getType(beanName);
                            if (beanType != null && this.advisorFactory.isAspect(beanType)) {
                                aspectNames.add(beanName);
                                AspectMetadata amd = new AspectMetadata(beanType, beanName);
                                if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                                    MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                                    List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                                    if (this.beanFactory.isSingleton(beanName)) {
                                        this.advisorsCache.put(beanName, classAdvisors);
                                    } else {
                                        this.aspectFactoryCache.put(beanName, factory);
                                    }

                                    advisors.addAll(classAdvisors);
                                } else {
                                    if (this.beanFactory.isSingleton(beanName)) {
                                        throw new IllegalArgumentException("Bean with name '" + beanName + "' is a singleton, but aspect instantiation model is not singleton");
                                    }

                                    MetadataAwareAspectInstanceFactory factory = new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                                    this.aspectFactoryCache.put(beanName, factory);
                                    advisors.addAll(this.advisorFactory.getAdvisors(factory));
                                }
                            }
                        }
                    }

                    this.aspectBeanNames = aspectNames;
                    return advisors;
                }
            }
        }

        if (aspectNames.isEmpty()) {
            return Collections.emptyList();
        } else {
            List<Advisor> advisors = new ArrayList();
            Iterator var3 = aspectNames.iterator();

            while(var3.hasNext()) {
                String aspectName = (String)var3.next();
                List<Advisor> cachedAdvisors = (List)this.advisorsCache.get(aspectName);
                if (cachedAdvisors != null) {
                    advisors.addAll(cachedAdvisors);
                } else {
                    MetadataAwareAspectInstanceFactory factory = (MetadataAwareAspectInstanceFactory)this.aspectFactoryCache.get(aspectName);
                    advisors.addAll(this.advisorFactory.getAdvisors(factory));
                }
            }

            return advisors;
        }
    }

至此，我们已经完成了Advisor的提取，在上面的步骤中，最为重要的就是增强器的获取。而这以功能委托给了getAdvisors方法来实现。

 public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
        Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
        String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
        this.validate(aspectClass);
        MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory = new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
        List<Advisor> advisors = new ArrayList();
        Iterator var6 = this.getAdvisorMethods(aspectClass).iterator();

        while(var6.hasNext()) {
            Method method = (Method)var6.next();
            Advisor advisor = this.getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
            if (advisor != null) {
                advisors.add(advisor);
            }
        }

        if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
            Advisor instantiationAdvisor = new ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
            advisors.add(0, instantiationAdvisor);
        }

        Field[] var12 = aspectClass.getDeclaredFields();
        int var13 = var12.length;

        for(int var14 = 0; var14 < var13; ++var14) {
            Field field = var12[var14];
            Advisor advisor = this.getDeclareParentsAdvisor(field);
            if (advisor != null) {
                advisors.add(advisor);
            }
        }

        return advisors;
    }

函数中首先完成了对增强器的获取，包括获取注解以及根据注解生成增强的步骤。

1、普通增强器的获取

普通增强器的获取通过getAdvisor方法实现，实现步骤包括对切点的注解的获取以及根据注解信息生成增强功能。

  @Nullable
    public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrderInAspect, String aspectName) {
        this.validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
        AspectJExpressionPointcut expressionPointcut = this.getPointcut(candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
        return expressionPointcut == null ? null : new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod, this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
    }

（1）切点信息的获取。所谓获取切点信息就是指定注解的表达式信息的获取，如@Before("test()")

  @Nullable
    private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
        AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
        if (aspectJAnnotation == null) {
            return null;
        } else {
            AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class[0]);
            ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
            if (this.beanFactory != null) {
                ajexp.setBeanFactory(this.beanFactory);
            }

            return ajexp;
        }
    }

未完待续~~~~~~~~~

牙买加咖啡@
关注
Spring的aop源码分析
qq_43418737的博客
05-12 1454
Spring的aop源码解析
【spring源码】AOP底层源码分析
热门推荐
aaa_bbb_ccc_123_456的博客
01-07 1万+
【spring源码】AOP底层源码分析1.测试用例2.AOP流程概述3.AOP源码分析 spring的AOP是什么不在赘述，以下内容默认大家会使用AOP，我们今天来扒源码 1.测试用例 引入必要依赖: <dependencies> <dependency> <groupId>org.springframework&l...
Spring AOP 源码系列：ProxyFactoryBean
08-05
NULL 博文链接：https://czj4451.iteye.com/blog/2051461
spring源码之代理生成
weixin_38441454的博客
04-05 523
在收集完切面，当切面不为空，则生成代理对象。 spring中有两种动态代理，一种是jdk动态代理，还有一种是cglib动态代理，默认采用的是jdk动态代理，看spring源码设计： 在@EnableAspectJAutoProxy注解中，通过属性proxyTargetClass控制采用哪种动态代理，但jdk动态代理需要类实现接口，才能被代理，那如果没有实现接口怎么被代理？ protected Object createProxy(Class<?> beanClass, @Nullable St
Spring源码-AOP具体源码
最新发布
m0_45164511的博客
10-06 997
config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)，判断是否优化、是否代理目标类、是否没有接口。满足这个条件，返回CGLIB代理对象；不满足，就返回JDK代理对象。同时还会判断，判断：targetClass.isInterface() || Proxy.isProxyClass(targetClass)，如果被代理的类是接口，那就返回JDK代理对象；
自己如何实现对象序列化_抛开Spring来说，如何自己实现Spring AOP?
weixin_39755712的博客
12-03 112
最近正好遇到了一道这样的题：抛开Spring来说，如何自己实现Spring AOP?就喜欢这样的题，能把那些天天写增删改查从来不思考的人给PK下去，今天就和大家一切学习代理模式与Spring AOP。翻开to-do，注解认证中答应大家要讲解代理模式。代理与装饰器场景描述代理，即替代之意，可替代所有功能，即和原类实现相同的规范。代理模式和装饰器模式很像，之前的装饰器讲的不是很好，这里换个例子再讲一遍...
spring-aop源码解析之环境搭建
mist蒙的博客
01-20 419
前言 在前面讲过了spring的ioc容器的创建以及bean的实例化过程，后面继续介绍了springmvc的执行流程。至此，我们在web开发中最核心的两个模块的大致运行流程我们已经有了一个模糊的印象了 但是，web开发中不仅仅只是ioc对于bean的管理以及我们的servlet的使用。在日常开发中，我们也需要做一些简单的日志，或者在crud中需要对数据库的事务进行管理，还有对于一些业务需要进行缓存也可以使用aop去统一处理，权限认证呀（一般是在filter或者interceptor中去做的），数据库
Spring 源码分析(三) —— AOP（五）创建代理
weixin_34377065的博客
03-16 170
2019独角兽企业重金招聘Python工程师标准>>> ...
五、Spring源码分析——Spring Aop
08-11
《Spring AOP 源码分析》 在深入探讨Spring AOP之前，我们先要理解AOP（面向切面编程）的基本概念。AOP是一种编程范式，它将关注点分离，使得我们可以将横切关注点（如日志、事务管理、安全检查等）与业务逻辑解耦...
spring-aop-ProxyFactoryBean 源码分析
08-06
`ProxyFactoryBean`是Spring AOP实现中的一个重要类，它用于创建代理对象，使我们能够实现动态代理以进行方法拦截。下面将深入分析`ProxyFactoryBean`的源码，探讨其工作原理和使用方式。 `ProxyFactoryBean`继承自...
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
在 Spring AOP 中，`ObjenesisCglibAopProxy` 类负责使用 CGLIB 创建代理对象，它会将一系列的 `MethodInterceptor` 注册为 `Callback`，这些 `MethodInterceptor` 执行了 AOP 的逻辑。 在 Spring AOP 的自动代理...
四、Spring源码分析——动态代理
08-11
NULL 博文链接：https://ylxy3058.iteye.com/blog/2224140
Spring中AOP源码
踩踩踩从踩的博客
01-18 645
之前的文章解析了spring中 ioc的核心流程 ，以及包括了bean定义的解析和加载 到容器中，以及 整个spring框架ioc基本流程，以及bean的生命周期 包括 单例bean 以及非懒加载bean实例的创建过程，getbean dogetbean createbean docreatebean 等流程 下去 spring 对di属性 以及 构造器注入 使用三级缓存来解决 循环依赖的问题等等。本篇文章会继续下去，解析 aop源码 ，都知道 spring 对创建实例过后 会有对
从源码层面学习Spring中AOP代理创建过程
李哈zzz的博客
04-12 943
目录 为什么Spring中存在AOP 什么是面向切面 什么是动态代理 AOP源码解读 总结 为什么Spring中存在AOP 凡是学一样东西，要知其先后。对于Spring来说，其中2大核心IoC和AoP。对于IoC来说控制反转，对于项目中的类（bean）你直接交给Spring就行了，你想使用直接从我这里拿。当项目不断的更新迭代，需要在原有的基础上不断的增加逻辑。可能没有AoP之前，对于程序员来说可能会使用代理模式来对其解耦，此时又有啥静态代理，动态代理的。那么，对于Spring的开发人员
Spring AOP源码学习：创建 AOP 代理
2401_86402594的博客
09-07 645
/ 1.首先处理引介增强（@DeclareParents）用的比较少可以忽略，有兴趣的参考：https://www.cnblogs.com/HigginCui/p/6322283.html。// 设置要代理的类，将targetSource赋值给proxyFactory的targetSource属性，之后可以通过该属性拿到被代理的bean的实例。// 5.获取切面类中的方法（也就是我们用来进行逻辑增强的方法，被@Around、@After等注解修饰的方法，使用@Pointcut的方法不处理）
Spring之动态代理源码
ooaash的博客
09-12 709
前言 在Spring之AOP的最后，我们提到了两种动态代理的方式：JDK动态代理以及cglib动态代理；JDK方式可以代理接口或者实现了接口的实现类，cglib的被代理类不能是接口/抽象类。还有一点区别在下面揭晓。 CGLIB 之前是在项目里引入spring全家桶来看源码的，所以一开始看Enhancer是在org.springframework下还以为是Spring自己重写的一套。通过jar包方式查看，发现很多相关的类都不能看到源码，就去github上拉了springframework；在spring-co
Spring AOP 的搭建与源码分析
qq_29799655的博客
04-06 833
AOP 面向切面编程一. AOP 概述AOP 的实现步骤示例 一. AOP 概述 什么是 AOP : 指定程序在运行期间动态的将某段代码功能切入到指定的位置运行,底层是通过动态代理来实现的 AOP 优点 : 降低代码的耦合,提高代码复用性,提高系统的扩展性 AOP 常见使用场景 : 例如日志记录, 性能统计, 权限控制, 事物处理等 AOP 的实现步骤 Spring 引入 AOP 需要的依赖 设...
spring-AOP源码详解
henlang的专栏
10-13 189
spring-AOP源码详解
Spring AOP详解：代理模式与源码分析
源码分析显示，Spring的AOP机制内部涉及到了拦截器链（Interceptor Chain）、通知（Advice）、连接点（Join Point）等多个概念，这些底层实现使得AOP在Spring容器中无缝集成，极大地提高了代码的可维护性和灵活性。...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值