Spring 源码解析

🕗 发布于 2024-03-01 12:06 spring java 后端

文章目录

前言
相关Spring的定义接口
整体代码
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh")
prepareRefresh()
obtainFreshBeanFactory()
registerBeanPostProcessors(beanFactory)
SpringAOP原码流程

前言

Spring 由17个方法构成,本文一以GenericApplicationContext为例

整体代码

public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var10) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10);
                }

                this.destroyBeans();
                this.cancelRefresh(var10);
                throw var10;
            } finally {
                this.resetCommonCaches();
                contextRefresh.end();
            }

        }
    }

StartupStep contextRefresh = this.applicationStartup.start(“spring.context.refresh”)

this.applicationStartup初始化：

private ApplicationStartup applicationStartup;

ApplicationStartup.DEFAULT ：

ApplicationStartup DEFAULT = new DefaultApplicationStartup();

在这里插入图片描述

prepareRefresh()

protected void prepareRefresh() {
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);//设置关闭状态为真
    this.active.set(true);//设置存活状态为真
    if (this.logger.isDebugEnabled()) {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Refreshing " + this);
        } else {
            this.logger.debug("Refreshing " + this.getDisplayName());
        }
    }

    this.initPropertySources();  //自身空实现，留给子类重写
    this.getEnvironment().validateRequiredProperties();
    if (this.earlyApplicationListeners == null) {
        this.earlyApplicationListeners = new LinkedHashSet(this.applicationListeners);//创建早期容器监听者
    } else {
        this.applicationListeners.clear();
        this.applicationListeners.addAll(this.earlyApplicationListeners);//创建容器监听者
    }

    this.earlyApplicationEvents = new LinkedHashSet();//创建早期事件存放容器
}

this.getEnvironment().validateRequiredProperties() 整体解析：

获取环境变量及系统变量

this.getEnvironment().validateRequiredProperties() 中 getEnvironment() ：

getEnvironment()

public ConfigurableEnvironment getEnvironment() {
    if (this.environment == null) {
        this.environment = this.createEnvironment();
    }

    return this.environment;
}

createEnvironment() ：

return new StandardEnvironment();

public class StandardEnvironment extends AbstractEnvironment {
    public static final String SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME = "systemEnvironment";
    public static final String SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME = "systemProperties";

    public StandardEnvironment() {   //空构造调用父类构造，由父类调用customizePropertySources方法
    }

    protected StandardEnvironment(MutablePropertySources propertySources) {
        super(propertySources);
    }

    protected void customizePropertySources(MutablePropertySources propertySources) {
        propertySources.addLast(new PropertiesPropertySource("systemProperties", this.getSystemProperties()));//获取系统的参数变量
        propertySources.addLast(new SystemEnvironmentPropertySource("systemEnvironment", this.getSystemEnvironment()));//获取系统环境变量
    }
}

AbstractEnvironment 构造器：

    public AbstractEnvironment() {
        this(new MutablePropertySources()); //调用下面构造方法
    }

    protected AbstractEnvironment(MutablePropertySources propertySources) {
        this.logger = LogFactory.getLog(this.getClass());
        this.activeProfiles = new LinkedHashSet();
        this.defaultProfiles = new LinkedHashSet(this.getReservedDefaultProfiles());
        this.propertySources = propertySources; //将propertySources赋值给本地propertySources变量
        this.propertyResolver = this.createPropertyResolver(propertySources);
        this.customizePropertySources(propertySources);  //调用子类StandardEnvironment的customizePropertySources
    }

总之是new 一个 StandardEnvironment 类然后调用其的customizePropertySources方法返回该 StandardEnvironment 类

this.getEnvironment().validateRequiredProperties() 中的validateRequiredProperties()：

调用的是之前返回的 StandardEnvironment的父类AbstractEnvironment propertyResolver属性的validateRequiredProperties的方法：

propertyResolver.validateRequiredProperties();

propertyResolver属性是在上面创建StandardEnvironment时候调用其父类AbstractEnvironment(MutablePropertySources propertySources)构造中创建赋值的：

this.propertyResolver = this.createPropertyResolver(propertySources);

而 createPropertyResolver(propertySources)则只是调用一个new PropertySourcesPropertyResolver(propertySources);

validateRequiredProperties()方法最终调用的是PropertySourcesPropertyResolver的validateRequiredProperties方法

而PropertySourcesPropertyResolver 的validateRequiredProperties方法本身没有实现是继承父类的 AbstractPropertyResolver实现

最终this.getEnvironment().validateRequiredProperties()实现方法是AbstractPropertyResolver.validateRequiredProperties()：

public void validateRequiredProperties() {
    MissingRequiredPropertiesException ex = new MissingRequiredPropertiesException();
    Iterator var2 = this.requiredProperties.iterator();

    while(var2.hasNext()) {
        String key = (String)var2.next();
        if (this.getProperty(key) == null) {
            ex.addMissingRequiredProperty(key);
        }
    }

    if (!ex.getMissingRequiredProperties().isEmpty()) {
        throw ex;
    }
}

从requiredProperties中遍历值并且判断是否在系统或环境变量存在该值

requiredProperties：
AbstractPropertyResolver的一个属性

private final Set<String> requiredProperties = new LinkedHashSet();

总结作用 ：
Spring容器初始化的时候，会从集合requiredProperties中取出所有key，然后获取这些key的环境变量（包括系统环境变量和进程环境变量），如果有一个key对应的环境变量为空，就会抛出异常，导致spring容器初始化失败；

实战中使用：

看了AbstractPropertyResolver类的validateRequiredProperties方法源码后，可以确定该方法能强制要求一些环境变量必须存在，否则停止spring启动，我们只要把我们认为必要的环境变量的key存入集合requiredProperties中即可，达到此目标需要解决下面两个问题：

如何将环境变量的key存入集合requiredProperties？
调用AbstractPropertyResolver类的setRequiredProperties方法，注意该方法是向集合requiredProperties中添加数据，并不会将已有数据清除；
在什么时候执行AbstractPropertyResolver类的setRequiredProperties方法设置key？
创建一个AbstractApplicationContext的子类，重写initPropertySources方法，在此方法中执行AbstractPropertyResolver类的setRequiredProperties；

创建一个自定义ApplicationContext 并重写initPropertySources方法：

    public void main() {
        CustomApplicationContext customApplicationContext = new CustomApplicationContext();
        customApplicationContext.refresh();
    }

    public  class CustomApplicationContext extends GenericApplicationContext {
        @Override
        protected void initPropertySources() {
            super.initPropertySources();
            //把"MYSQL_HOST"作为启动的时候必须验证的环境变量
            getEnvironment().setRequiredProperties("MYSQL_HOST");
        }
    }

上面写过initPropertySources实在 prepareRefresh() 时候调用：

obtainFreshBeanFactory()

获取BeanFactory并刷新

 protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        this.refreshBeanFactory();
        return this.getBeanFactory();
}

refreshBeanFactory()内容 :

 if (!this.refreshed.compareAndSet(false, true)) {
            throw new IllegalStateException("GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
 } else {
     this.beanFactory.setSerializationId(this.getId());
 }

getBeanFactory()

返回 GenericApplicationContext 中的 DefaultListableBeanFactory beanFactory 属性

beanFactory 在 GenericApplicationContext 创建的时候创建的：

public GenericApplicationContext() {
        this.customClassLoader = false;
        this.refreshed = new AtomicBoolean();
        this.beanFactory = new DefaultListableBeanFactory();
}

registerBeanPostProcessors(beanFactory)

SpringAOP原码流程

@EnableAspectJAutoProxy

首先需了解@EnableAspectJAutoProxy：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

    boolean proxyTargetClass() default false;

}

它通过@Import(AspectJAutoProxyRegistrar.class)导入了一个AspectJAutoProxyRegistrar组件:

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

        AnnotationAttributes enableAJAutoProxy \=
                attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAJAutoProxy.getBoolean("proxyTargetClass")) {
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
        }
    }

}

它实现了ImportBeanDefinitionRegistrar接口，这个接口可以向IOC容器中注册bean。由此可以推测aop利用AspectJAutoProxyRegistrar自定义给容器中注册bean；BeanDefinetion

进入registerAspectJAnnotationAutoProxyCreatorIfNecessary方法，发现它给容器中注册了一个名为org.springframework.aop.config.internalAutoProxyCreator，实例为AnnotationAwareAspectJAutoProxyCreator的类。

AnnotationAwareAspectJAutoProxyCreator的创建时机

查看AnnotationAwareAspectJAutoProxyCreator的继承关系图

在这里插入图片描述
在此需要关注两点内容：

关注后置处理器SmartInstantiationAwareBeanPostProcessor（在bean初始化完成前后做事情）
关注自动装配BeanFactory。

注意：SmartInstantiationAwareBeanPostProcessor是BeanPostProcessor的一个子接口

因此AnnotationAwareAspectJAutoProxyCreator的创建时机：

1）、传入配置类，创建ioc容器
          2）、注册配置类，调用refresh（）刷新容器；
          3）、registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建；
              1）、先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
              2）、给容器中加别的BeanPostProcessor
              3）、优先注册实现了PriorityOrdered接口的BeanPostProcessor；
              4）、再给容器中注册实现了Ordered接口的BeanPostProcessor；
              5）、注册没实现优先级接口的BeanPostProcessor；
              6）、注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；
                  创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】
                  1）、创建Bean的实例
                  2）、populateBean；给bean的各种属性赋值
                  3）、initializeBean：初始化bean；
                          1）、invokeAwareMethods()：处理Aware接口的方法回调
                          2）、applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization（）
                          3）、invokeInitMethods()；执行自定义的初始化方法
                          4）、applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization（）；
                  4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；--》aspectJAdvisorsBuilder
              7）、把BeanPostProcessor注册到BeanFactory中；
                  beanFactory.addBeanPostProcessor(postProcessor);

在上面步骤获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor中，因为AnnotationAwareAspectJAutoProxyCreator实现了SmartInstantiationAwareBeanPostProcessor接口，而SmartInstantiationAwareBeanPostProcessor是BeanPostProcessor的子接口，并且@EnableAspectJAutoProxy注册了AnnotationAwareAspectJAutoProxyCreator的BeanDefinetion进容器，所以此步骤能获取到AnnotationAwareAspectJAutoProxyCreator的BeanDefinetion

AnnotationAwareAspectJAutoProxyCreator的执行时机

AnnotationAwareAspectJAutoProxyCreator是一个后置处理器，可以猜测它在其他bean的初始化前后进行了特殊处理。我在它父类的postProcessBeforeInstantiation方法进行了断点调试，其方法调用栈如下：

在这里插入图片描述

finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean
  1）、遍历获取容器中所有的Bean，依次创建对象getBean(beanName);
  getBean->doGetBean()->getSingleton()->createBean()
  2）、createBean()创建bean
  【AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，InstantiationAwareBeanPostProcessor，  
　　　　　会调用postProcessBeforeInstantiation()】
  1）、先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；
  只要创建好的Bean都会被缓存起来
  2）、createBean（）;创建bean；
  AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例
  【BeanPostProcessor是在Bean对象创建完成初始化前后调用的】
  【InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】
  1)、resolveBeanClass()加载bean的class文件
  2）、resolveBeforeInstantiation();解析BeforeInstantiation
  希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续创建
  1）、后置处理器先尝试返回对象；
  InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation
  如果返回对象就再继续执行BeanPostProcessor#postProcessAfterInitialization，返回bean
  3）、doCreateBean(beanName, mbdToUse, args);真正的去创建一个bean实例
1）、createBeanInstance();实例化bean
populateBean();属性注入
initializeBean();初始化，执行各种生命周期方法和创建代理等

在步骤resolveBeforeInstantiation(),一般自定义的bean在此都不会获取到实例，此步骤有印象即可。

再深入解析initializeBean()方法：

initializeBean()
如果bean实现了相关的接口，就调用执行相关接口
1)、invokeAwareMethods;执行BeanNameAware BeanClassLoaderAware BeanFactoryAware接口
2）、applyBeanPostProcessorsBeforeInitialization;执行BeanPostProcessor#postProcessBeforeInitialization
3）、invokeInitMethods; 执行初始化方法
4）、applyBeanPostProcessorsAfterInitialization;BeanPostProcessor#postProcessAfterInitialization;创建代理

这里重点关注AnnotationAwareAspectJAutoProxyCreator类,其postProcessAfterInitialization方法在其父类AbstractAutoProxyCreator实现。
直接进入AbstractAutoProxyCreator#postProcessAfterInitialization,代理创建入口就在此：

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// earlyProxyReferences是一个ConcurrentHashMap，里面存放的是已经生成的代理
// 里面存放的是已经生成的代理（三级缓存可能会提前生成代理），如果有不会重复生成。
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}

进入wrapIfNecessary，这里是创建代理的关键方法：

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
// advicedBeans表示已经判断过的bean，false表示此Bean不需要进行AOP，直接返回
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
// 当前正在创建的Bean不用进行AOP，比如切面Bean
/*
  如果是基础设施类（Pointcut、Advice、Advisor 等接口的实现类），或是应该跳过的类，
  则不应该生成代理，此时直接返回 bean,也就是代理不能给自己再加代理 就是不套娃
  AspectJAwareAdvisorAutoProxyCreator#shouldSkip
 */
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}

// Create proxy if we have advice.
// 查询当前bean匹配的Advice,找切面的过程（判断当前实例化的bean是否有切面，如果有则将切面返回）返回类型为 Advisor
// postProcessBeforeInstantiation方法也会调用 ；AbstractAdvisorAutoProxyCreator实现
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
// 如果有切面，则生成bean的代理
if (specificInterceptors != DO_NOT_PROXY) {
// advisedBeans记录了某个Bean已经进行过AOP了
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 创建代理，把被代理对象bean的实例封装到SingletonTargetSource中，生成当前实例化bean的代理对象
// 传入的bean是被代理实例，SingletonTargetSource持有了被代理实例的引用（一级缓存单例池中存的就是代理对象）
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
// 将代理对象返回
return proxy;
}
// 没有代理的情况，就是false
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}

第一次进入shouldSkip方法会查询Spring容器内的所有@Aspecj相关的类，并将其相关方法注册成Advisor，并缓存起来，以便下次直接获取。

总结：

通过@EnableAspectJAutoProxy注入AnnotationAwareAspectJAutoProxyCreator,其实现了BeanFactoryAware和SmartInstantiationAwareBeanPostProcessor接口，间接实现了InstantiationAwareBeanPostProcessor和BeanPostProcessor；

在Spring容器刷新时候调用registerBeanPostProcessors方法注册进容器；

在Spring创建完成Bean，执行生命周期后置处理器BeanPostProcessor#postProcessAfterInitialization时候，会调进入AnnotationAwareAspectJAutoProxyCreator执行代理创建逻辑，并返回需要的代理。

继续深入研究wrapIfNecessary

首先判断当前类是否需要代理，或者已经被代理过，返回原类。

重点关注getAdvicesAndAdvisorsForBean方法，实现在AbstractAdvisorAutoProxyCreator类：

protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
// 找到候选的切面，就是寻找带有@Aspect注解的过程，把带有@Aspect的类封装成Advisor返回
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}

findEligibleAdvisors方法寻找当前类匹配的Advisor，进入findEligibleAdvisors方法：

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
// 找到候选的切面，就是寻找带有@Aspect注解的过程，把带有@Aspect的类封装成Advisor返回
List<Advisor> candidateAdvisors = findCandidateAdvisors(); //如果是通过@Aspect注解开启切面，子类AnnotationAwareAspectJAutoProxyCreator方法
// 判断候选的切面是否作用在当前beanClass上面，就是一个匹配的过程
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
// 针对有@Aspect注解的类添加一个默认的切面--->DefaultPointcutAdvisor，解决参数传递问题
// 进入AspectJAwareAdvisorAutoProxyCreator类的extendAdvisors()方法
extendAdvisors(eligibleAdvisors); // AspectJAwareAdvisorAutoProxyCreator
if (!eligibleAdvisors.isEmpty()) {
// 对有@Order、@Priority注解的类进行排序
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}

进入AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors:

protected List<Advisor> findCandidateAdvisors() {
// Add all the Spring advisors found according to superclass rules.
// 先找到所有Advisor类型的Bean，调用父类resolveBeforeInstantiation方法进入的话实现类是AbstractAdvisorAutoProxyCreator#findCandidateAdvisors
List<Advisor> advisors = super.findCandidateAdvisors();
// Build Advisors for all AspectJ aspects in the bean factory.
// 再从所有@Aspect中解析得到Advisor对象
if (this.aspectJAdvisorsBuilder != null) {
// 创建候选的切面，对有@Aspect注解的类进行处理（包装Advice和Pointcut，还有切面的排序）****
advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());// 核心方法-构建Advisor
}
return advisors;
}

注意寻找的方法是this.aspectJAdvisorsBuilder.buildAspectJAdvisors(),此方法就是从Spring容器中查询所有被@Aspect标注的方法，并转换成Advisor：

//GSCM  2024/1/23  解析容器中@Aspect注解标注的类构建成Advisor对象
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<>();
aspectNames = new ArrayList<>();
// 获取Spring容器中所有实例的beanName
String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this.beanFactory, Object.class, true, false);
for (String beanName : beanNames) {
if (!isEligibleBean(beanName)) {
continue;
}
// We must be careful not to instantiate beans eagerly as in this case they
// would be cached by the Spring container but would not have been weaved.
// 首先拿到实例的类型
Class<?> beanType = this.beanFactory.getType(beanName, false);
if (beanType == null) {
continue;
}
// 判断类上是否有@Aspect注解
if (this.advisorFactory.isAspect(beanType)) {
aspectNames.add(beanName);
// 获取切面的注解信息
AspectMetadata amd = new AspectMetadata(beanType, beanName);
if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
// 创建获取@Aspect注解类的实例工厂，MetadataAwareAspectInstanceFactory负责获取有@Aspect注解的实例
MetadataAwareAspectInstanceFactory factory =
new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
// 创建切面Advisor对象
List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);// 创建切面Advisor对象
// 放到缓存中
if (this.beanFactory.isSingleton(beanName)) {
this.advisorsCache.put(beanName, classAdvisors);
}
else {
this.aspectFactoryCache.put(beanName, factory);
}
advisors.addAll(classAdvisors);
}
else {
// Per target or per this.
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();
}
List<Advisor> advisors = new ArrayList<>();
for (String aspectName : aspectNames) {
List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);// 解析过一次后就从缓存中取
if (cachedAdvisors != null) {
advisors.addAll(cachedAdvisors);
}
else {
MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
advisors.addAll(this.advisorFactory.getAdvisors(factory));
}
}
return advisors;
}

在此行List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);代码中，最终将@Aspect注解的类解析成为Advisor，返回的Advisor类型同一都为InstantiationModelAwarePointcutAdvisorImpl。

进入this.advisorFactory.getAdvisors(factory)方法：

public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
// 从工厂中获取有@Aspect注解的类的反射对象Class
Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();//GXXX  2023/11/21
// 从工厂中获取有@Aspect注解的类的名称
String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
validate(aspectClass);

// We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
// so that it will only instantiate once.
// 创建工厂的装饰类，获取实例（只会获取一次）
MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

List<Advisor> advisors = new ArrayList<>();
// 这里循环没有@Pointcut注解的方法，扫描有@Before、@Around、@After注解的方法，并进行排序，getAdvisorMethods()->
for (Method method : getAdvisorMethods(aspectClass)) { // 进入本类的getAdvisorMethods()方法

// AspectJPrecedenceComparator.getAspectDeclarationOrder(Advisor).
// 获取Advisor*****(只要是有@Before、@After等注解的方法，它们分别和带有@Pointcut注解的方法组合，生成各自Advisor类)
// 封装Advisor，返回的实现类为InstantiationModelAwarePointcutAdvisorImpl
Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);// 再进入本类的getAdvisor()，根据方法生成Advisor
if (advisor != null) {
advisors.add(advisor);
}
}

// If it's a per target aspect, emit the dummy instantiating aspect.
if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
advisors.add(0, instantiationAdvisor);
}

// Find introduction fields.
for (Field field : aspectClass.getDeclaredFields()) {
Advisor advisor = getDeclareParentsAdvisor(field);
if (advisor != null) {
advisors.add(advisor);
}
}

return advisors;
}

这里遍历当前class的每个方法，为每个通知方法创建Advisor实例。

进入getAdvisor方法：

public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
int declarationOrderInAspect, String aspectName) {
validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());

// 获取AspectJExpressionPointcut对象，从注解中获取表达式
// candidateAdviceMethod就是有@Before、@After注解的方法
AspectJExpressionPointcut expressionPointcut = getPointcut(
candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
if (expressionPointcut == null) {
return null;
}

// 创建真正的Advisor切面类，里面有pointcut和advice***进入InstantiationModelAwarePointcutAdvisorImpl的构造方法
// expressionPointcut是pointcut，candidateAdviceMethod是advice
return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
this, aspectInstanceFactory, declarationOrderInAspect, aspectName);//  创建真正的切面类
}

在此针对每个目标方法创建对应的Advisor实例，具体创建逻辑在InstantiationModelAwarePointcutAdvisorImpl的构造方法中：

this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);//GSCM  2024/2/28 创建当前方法对应advice实例的具体方法

此方法继续调用this.aspectJAdvisorFactory.getAdvice()，直接看aspectJAdvisorFactory.getAdvice()：

public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
// 获取有@Aspect注解的类，就是当前被@Aspect标注的class
Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
validate(candidateAspectClass);
// 找到class上面的相关切面注解，并且包装成AspectJAnnotation对象
AspectJAnnotation<?> aspectJAnnotation =
AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
if (aspectJAnnotation == null) {
return null;
}

.........

AbstractAspectJAdvice springAdvice;

// 根据方法上切面不同注解，创建相对应的的advice实例
switch (aspectJAnnotation.getAnnotationType()) {
case AtPointcut:
if (logger.isDebugEnabled()) {
logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
}
return null;
case AtAround:
// 环绕通知，实现了MethodInterceptor接口
springAdvice = new AspectJAroundAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtBefore:
// 前置通知，实现了MethodBeforeAdvice接口，没有实现MethodInterceptor接口
springAdvice = new AspectJMethodBeforeAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtAfter:
// 后置通知，实现了MethodInterceptor接口
springAdvice = new AspectJAfterAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtAfterReturning:
// 结果通知，实现了AfterReturningAdvice接口，没有实现MethodInterceptor接口
springAdvice = new AspectJAfterReturningAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
if (StringUtils.hasText(afterReturningAnnotation.returning())) {
springAdvice.setReturningName(afterReturningAnnotation.returning());
}
break;
case AtAfterThrowing:
// 异常通知，实现了MethodInterceptor接口
springAdvice = new AspectJAfterThrowingAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
}
break;
default:
throw new UnsupportedOperationException(
"Unsupported advice type on method: " + candidateAdviceMethod);
}

// Now to configure the advice...
springAdvice.setAspectName(aspectName);
springAdvice.setDeclarationOrder(declarationOrder);
String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
if (argNames != null) {
springAdvice.setArgumentNamesFromStringArray(argNames);
}
springAdvice.calculateArgumentBindings();

return springAdvice;
}

这里就是创建了目标方法对应具体的advice并赋值给InstantiationModelAwarePointcutAdvisorImpl的instantiatedAdvice属性

被代理方法的执行流程

被Spring的Cglib代理的所有方法都会进入CglibAopProxy.DynamicAdvisedInterceptor#intercept方法；

//GSCM  2024/1/24 被cglib代理的对象调用首先进入此方法
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
Object target = null;
TargetSource targetSource = this.advised.getTargetSource();
try {
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// Get as late as possible to minimize the time we "own" the target, in case it comes from a pool...
target = targetSource.getTarget();
Class<?> targetClass = (target != null ? target.getClass() : null);
// ※获取调用执行链※
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
// Check whether we only have one InvokerInterceptor: that is,
// no real advice, but just reflective invocation of the target.
if (chain.isEmpty() && CglibMethodInvocation.isMethodProxyCompatible(method)) {
// We can skip creating a MethodInvocation: just invoke the target directly.
// Note that the final invoker must be an InvokerInterceptor, so we know
// it does nothing but a reflective operation on the target, and no hot
// swapping or fancy proxying.
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = invokeMethod(target, method, argsToUse, methodProxy);
}
else {
// We need to create a method invocation...
// 执行代理方法调用链条
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}

DynamicAdvisedInterceptor有一个重要的属性private final AdvisedSupport advised,在创建代理的时候被赋值，里面包含被代理的原生类引用及执行链；

在这里插入图片描述

转换前

在这里插入图片描述
转换后

CglibMethodInvocation
ExposeInvocationInterceptor
AspectJAroundAdvice#invoke->调用切面层aspectJAdviceMethod.invoke
MethodBeforeAdviceInterceptor#invoke
AspectJAfterAdvice#invoke
AspectJAfterThrowingAdvice#invoke

AspectJAroundAdvice
MethodBeforeAdviceInterceptor
AfterReturningAdviceAdapter
ThrowsAdviceAdapter
AspectJAfterAdvice

AspectJMethodBeforeAdvice -> MethodBeforeAdviceInterceptor

advisor、advice、adviced各自的含义

advisor 通知器包含advice和pointcut
advice 具体的某一个消息通知
adviced 用来配置代理（proxyFactory）

执行流程整理：

postProcessAfterInitialization创建代理，第一次进来会遍历Spring容器内所有的带有@Aspect注解的类，遍历其类中的每个带有@Before、@Around、@After的方法，并将切点对象解析出来与当前方法的Method对象，封装成一个InstantiationModelAwarePointcutAdvisorImpl实例,在InstantiationModelAwarePointcutAdvisorImpl中构造函数中会根据Method的信息创建一个Advice对象并引用。遍历完成将这些类缓存起来，并且生成一个bean名称对应Advice的缓存，下次直接从缓存中。拿到Advice后默认添加一个ExposeInvocationInterceptor在最前面。再创建一个代理工厂ProxyFactory区创建代理，代理工厂选择Cglib还是Jdk去创建代理类,代理类保存着目标类的引用及Advisor调用链。

Cglib代理进入DynamicAdvisedInterceptor#intercept，再根据Advisor获取调用链进行包装（如果需要的话），包装成MethodInterceptor。创建一个ReflectiveMethodInvocation类调用proceed，里面保存着一个调用次数currentInterceptorIndex,按照顺序一个个调用Advisor调用链，并且将当前类作为参数一直传递下去，每次调用一个Advisor会将currentInterceptorIndex减一，直到与Advisor调用链数量一致，说明调用链已经执行完了。
再调用真实的目标对象方法，调用完成依次弹出栈。

调用栈示例，org.gabriel.springwork.boot是自定义包：

 at org.gabriel.springwork.imported.ImportController.isSuccess(ImportController.java:16)
 at org.gabriel.springwork.imported.ImportController$$FastClassBySpringCGLIB$$7fcf3b6d.invoke(<generated>:-1)
 at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)
 at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:771)
 at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163)
 at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
 at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:62)
 at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
 at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
 at org.springframework.aop.aspectj.AspectJAfterAdvice.invoke(AspectJAfterAdvice.java:47)
 at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
 at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
 at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:56)
 at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
 at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
 at org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint.proceed(MethodInvocationProceedingJoinPoint.java:88)
 at org.gabriel.springwork.boot.config.DictAspect2.doAround(DictAspect2.java:35)
 at jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(NativeMethodAccessorImpl.java:-1)
 at jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
 at jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
 at java.lang.reflect.Method.invoke(Method.java:566)
 at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs(AbstractAspectJAdvice.java:644)
 at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod(AbstractAspectJAdvice.java:633)
 at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke(AspectJAroundAdvice.java:70)
 at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
 at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
 at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:95)
 at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
 at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
 at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:691)
 at org.gabriel.springwork.imported.ImportController$$EnhancerBySpringCGLIB$$20b0886d.isSuccess(<generated>:-1)
 at org.gabriel.springwork.boot.GabrielSpringBoot.lambda$main$0(GabrielSpringBoot.java:31)
 at org.gabriel.springwork.boot.GabrielSpringBoot$$Lambda$606.1849602253.accept(Unknown Source:-1)
 at java.util.LinkedHashMap.forEach(LinkedHashMap.java:684)
 at org.gabriel.springwork.boot.GabrielSpringBoot.main(GabrielSpringBoot.java:30)

Advisor相关实现类解析

AOP原文

原文地址：https://blog.csdn.net/qq_31906785/article/details/130200751

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：简析限流算法
下一篇：CV论文--2024.3.1

推荐系统与大模型
目前大模型在推荐系统取得巨大进展的同时也上主要一些的问题。主要有以下三点。1. Position Bias.在推荐系统的生成语言建模范式中，用户行为序列和推荐候选序列等各种信息以文本序列描述的形式输入
阅读更多2024-11-19
element-ui】使用el_upload上传文件无法动态修改action
问题：最近在使用el_upload上传文件时，发现无法动态修改action的值，进行提交时，caseId2还是默认值null。原因：el-upload的先执行上传，后执行action里的响应，也就是赋
阅读更多2024-11-19
JavaScript 如何获取本机IP地址
获取本机IP地址是前端工程师经常需要处理的问题。JavaScript 有几种方法可以获取客户端的IP地址。下面是三种获取本机IP的方法。
阅读更多2024-11-19
如何用 JavaScript 复制到剪贴板
以上就是几种在 JavaScript 中实现文本复制到剪贴板的方法。随着技术的发展，建议尽量使用最新的异步剪贴板 API，但为了兼容性，可以结合使用方法。希望本文能够帮助你更好地理解和应用这些 API
阅读更多2024-11-19
【第29章】MyBatis-Plus之分页插件
的分页插件提供了强大的分页功能，支持多种数据库，使得分页查询变得简单高效。属性名类型默认值描述overflowbooleanfalse溢出总页数后是否进行处理maxLimitLong单页分页条数限制d
阅读更多2024-11-19
weixin-java-miniapp 微信小程序登陆
1. 用户在小程序中选择使用微信授权登录功能。2. 小程序调用 `` 接口，向发起登录请求。3. 微信服务器验证小程序的合法性，如果合法，会返回一个。4. 小程序。5. 后台服务器接收到 **code
阅读更多2024-11-19
都2023年了，Servlet还有必要学习吗？一文带你快速了解Servlet
不得不说，Servlet 确实是一门古老的技术了，现在很少有公司直接使用 Servlet 来写项目了，大家都在用 SpringMVC-Spring-MyBatis / SpringBoot 做开发了，
阅读更多2024-11-19
掌握Java中集合的交集与并集操作
本文还有配套的精品资源，点击获取简介：集合操作是编程中的基础任务，涉及找出多个集合的共有元素（交集）和所有不同元素的总和（并集）。本文介绍如何在Java中利用 HashSet 和 St
阅读更多2024-11-19
Java 环境配置——Java 语言的安装、配置、编译与运行
正确配置 Java 开发环境是进行 Java 开发的第一步。通过本文的详细介绍，读者应能够在不同操作系统上安装和配置 JDK，并熟练编写、编译和运行 Java 程序。随着技术的发展，Java 生态系统
阅读更多2024-11-19
java 配置多数据源
mysql和clickhouse多数据源配置。
阅读更多2024-11-19

Spring 源码解析

文章目录

前言

相关Spring的定义接口

整体代码

StartupStep contextRefresh = this.applicationStartup.start(“spring.context.refresh”)

prepareRefresh()

obtainFreshBeanFactory()

registerBeanPostProcessors(beanFactory)

SpringAOP原码流程

@EnableAspectJAutoProxy

AnnotationAwareAspectJAutoProxyCreator的创建时机

AnnotationAwareAspectJAutoProxyCreator的执行时机

被代理方法的执行流程

相关文章