SpringBoot启动源码

达文曦
50 阅读6分钟

自动装配

SpringBootApplication

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

//将当前类标记为配置类,可以注入Bean

@SpringBootConfiguration

//自动导入代码

@EnableAutoConfiguration

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),

      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

public @interface SpringBootApplication {

流程图

image.png

SpringBootConfiguration

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

//配置类注解

@Configuration

public @interface SpringBootConfiguration {
  1. 自动装配
@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

//获取SpringBootApplication注解的配置类

@AutoConfigurationPackage

//扫描spring.factories配置类,获取自动装配bean

@Import(AutoConfigurationImportSelector.class)

public @interface EnableAutoConfiguration {
  1. AutoConfigurationPackage
 /**

 * {@link ImportBeanDefinitionRegistrar} to store the base package from the importing

 * configuration.

 */

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {



   //解析SpringBootApplication注解类的包路径,并注册到BeanDefinition

   @Override

   public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {

      register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));

   }



   @Override

   public Set<Object> determineImports(AnnotationMetadata metadata) {

      return Collections.singleton(new PackageImports(metadata));

   }



}

private final List<String> packageNames;



PackageImports(AnnotationMetadata metadata) {

   //获取AutoConfigurationPackage注解字段变量

   AnnotationAttributes attributes = AnnotationAttributes

         .fromMap(metadata.getAnnotationAttributes(AutoConfigurationPackage.class.getName(), false));

   List<String> packageNames = new ArrayList<>();

   //获取basePackages属性

   for (String basePackage : attributes.getStringArray("basePackages")) {

      packageNames.add(basePackage);

   }

   //获取basePackageClasses属性

   for (Class<?> basePackageClass : attributes.getClassArray("basePackageClasses")) {

      packageNames.add(basePackageClass.getPackage().getName());

   }

   //上面2个属性没有配置,获取当前注解所在类的包路径

   if (packageNames.isEmpty()) {

      packageNames.add(ClassUtils.getPackageName(metadata.getClassName()));

   }

   this.packageNames = Collections.unmodifiableList(packageNames);

}

public static void register(BeanDefinitionRegistry registry, String... packageNames) {

   if (registry.containsBeanDefinition(BEAN)) {

      BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);

      ConstructorArgumentValues constructorArguments = beanDefinition.getConstructorArgumentValues();

      constructorArguments.addIndexedArgumentValue(0, addBasePackages(constructorArguments, packageNames));

   }

   else {

      //注册BasePackages到beanDefinition,后续由spring加载实例化bean

      GenericBeanDefinition beanDefinition = new GenericBeanDefinition();

      beanDefinition.setBeanClass(BasePackages.class);

      beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, packageNames);

      beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

      registry.registerBeanDefinition(BEAN, beanDefinition);

   }

}
  1. AutoConfigurationImportSelector

实现ImportSelector的类，springboot会在启动的时候加载selectImports返回的class

public interface ImportSelector {



    //springboot会在启动时实例化数组返回的class

 String[] selectImports(AnnotationMetadata importingClassMetadata);



 @Nullable

   default Predicate<String> getExclusionFilter() {

      return null;

   }



}

加载spring.factories文件下的所有EnableAutoConfiguration的类路径

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {

    //判断当前环境变量是否设置允许自动装配spring.boot.enableautoconfiguration

   if (!isEnabled(annotationMetadata)) {

      return EMPTY_ENTRY;

   }

   //获取EnableAutoConfiguration注解的属性配置

   AnnotationAttributes attributes = getAttributes(annotationMetadata);

   //扫描所有jar包下的meta-inf下的spring.factories里的自动装配类列表EnableAutoConfiguration

   List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);

   //去重重复配置类

   configurations = removeDuplicates(configurations);

   //获取注解，环境变量配置的需要剔除的自动装配类

   Set<String> exclusions = getExclusions(annotationMetadata, attributes);

   //检查自动装配类里是否包含需要剔除的类，不包含，则报错

   checkExcludedClasses(configurations, exclusions);

   //删掉需要剔除的类

   configurations.removeAll(exclusions);

   //获取OnBeanCondition以及OnClassCondition，对自动装配的bean有条件依赖的进行过滤

   //读取META-INF/spring-autoconfigure-metadata.properties下类的依赖关系

   /**

       例如open-feign源码里的

       org.springframework.cloud.openfeign.FeignAutoConfiguration.ConditionalOnClass=feign.Feign

   **/

   configurations = getConfigurationClassFilter().filter(configurations);

   fireAutoConfigurationImportEvents(configurations, exclusions);

   return new AutoConfigurationEntry(configurations, exclusions);

}



@Override

public Iterable<Entry> selectImports() {

   if (this.autoConfigurationEntries.isEmpty()) {

      return Collections.emptyList();

   }

   //获取需要剔除的类

   Set<String> allExclusions = this.autoConfigurationEntries.stream()

         .map(AutoConfigurationEntry::getExclusions).flatMap(Collection::stream).collect(Collectors.toSet());

   //获取所有需要自动装配的类

   Set<String> processedConfigurations = this.autoConfigurationEntries.stream()

         .map(AutoConfigurationEntry::getConfigurations).flatMap(Collection::stream)

         .collect(Collectors.toCollection(LinkedHashSet::new));

    //再剔除一遍

   processedConfigurations.removeAll(allExclusions);

    //排序返回，由spring加载bean

   return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()

         .map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName))

         .collect(Collectors.toList());

}

至此springboot的自动装配已经全部结束

启动流程

SpringApplication

  1. SpringApplication.run

public static void main(String[] args) {

    //启动入口类

    SpringApplication.run(RecommendApiApplication.class);

}

  1. 实例化SpringApplication,设置相关属性值

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {

   this.resourceLoader = resourceLoader;

   Assert.notNull(primarySources, "PrimarySources must not be null");

   //将启动类class添加到set集合中

   this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));

   //根据class判断当前web类型,1.servlet原始web 2.REACTIVE webflux响应式

   this.webApplicationType = WebApplicationType.deduceFromClasspath();

   //从spring.factories获取ApplicationContextInitializer的实现类,并实例化

   setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

   //从spring.factories获取ApplicationListener的实现类,并实例化

   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

   this.mainApplicationClass = deduceMainApplicationClass();

}

  1. run方法主要逻辑

public ConfigurableApplicationContext run(String... args) {

    //启动耗时统计

   StopWatch stopWatch = new StopWatch();

   stopWatch.start();

   ConfigurableApplicationContext context = null;

   Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();

   configureHeadlessProperty();

   //从spring.factories获取SpringApplicationRunListener的实现,并实例化

   SpringApplicationRunListeners listeners = getRunListeners(args);

   listeners.starting();

   try {

       //读取运行参数

      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

      //创建环境并配置相关属性

      ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);

      //不深究

      configureIgnoreBeanInfo(environment);

      //banner图标打印

      Banner printedBanner = printBanner(environment);

      //创建AnnotationConfigServletWebServerApplicationContext上下文

      // 此处很关键,无参构造方法

      /**

          

public AnnotationConfigServletWebServerApplicationContext() {

   this.reader = new AnnotatedBeanDefinitionReader(this);

   this.scanner = new ClassPathBeanDefinitionScanner(this);

}

此处会将ConfigurationClassPostProcessor注册到DefaultListableBeanFactory里的

BeanDefinition里

从而调用getBeanNamesForType会取ConfigurationClassPostProcessor(见6.2invokeBeanFactoryPostProcessors)

详细实现在AnnotatedBeanDefinitionReader构造方法

      **/

      context = createApplicationContext();

      //spring.factories读取配配置

      exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,

            new Class[] { ConfigurableApplicationContext.class }, context);

      //上下文前置操作

      prepareContext(context, environment, listeners, applicationArguments, printedBanner);

      //刷新上下文

      refreshContext(context);

      afterRefresh(context, applicationArguments);

      stopWatch.stop();

      if (this.logStartupInfo) {

         new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);

      }

      listeners.started(context);

      callRunners(context, applicationArguments);

   }

   catch (Throwable ex) {

      handleRunFailure(context, ex, exceptionReporters, listeners);

      throw new IllegalStateException(ex);

   }



   try {

      listeners.running(context);

   }

   catch (Throwable ex) {

      handleRunFailure(context, ex, exceptionReporters, null);

      throw new IllegalStateException(ex);

   }

   return context;

}

  1. prepareEnvironment

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,

      ApplicationArguments applicationArguments) {

   /**

   创建环境变量

   添加servletContextInitParams,servletConfigInitParams等配置

   到MutablePropertySources,value暂时为空

   **/

 ConfigurableEnvironment environment = getOrCreateEnvironment();

   configureEnvironment(environment, applicationArguments.getSourceArgs());

   ConfigurationPropertySources.attach(environment);

   //为listeners设置environment环境变量

   listeners.environmentPrepared(environment);

   bindToSpringApplication(environment);

   if (!this.isCustomEnvironment) {

      environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,

            deduceEnvironmentClass());

   }

   ConfigurationPropertySources.attach(environment);

   return environment;

}

  1. prepareContext

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,

      SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {

   //设置上下文环境变量

   context.setEnvironment(environment);

   //注册bean以及设置相关属性

   postProcessApplicationContext(context);

   //为ApplicationContextInitializer设置上下文context

   applyInitializers(context);

   //为listener设置context

   listeners.contextPrepared(context);

   //记录启动日志

   if (this.logStartupInfo) {

      logStartupInfo(context.getParent() == null);

      logStartupProfileInfo(context);

   }

   // 添加一些单例子bean

 ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();

   beanFactory.registerSingleton("springApplicationArguments", applicationArguments);

   if (printedBanner != null) {

      beanFactory.registerSingleton("springBootBanner", printedBanner);

   }

   if (beanFactory instanceof DefaultListableBeanFactory) {

      ((DefaultListableBeanFactory) beanFactory)

            .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);

   }

   if (this.lazyInitialization) {

      context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());

   }

   // 获取启动类

 Set<Object> sources = getAllSources();

   Assert.notEmpty(sources, "Sources must not be empty");

   //将启动类bean注册到BeanDefinition

   load(context, sources.toArray(new Object[0]));

   listeners.contextLoaded(context);

}

  1. refresh方法

@Override

public void refresh() throws BeansException, IllegalStateException {

   synchronized (this.startupShutdownMonitor) {

      /**

      1.设置开始时间

      2.调用StandardServletEnvironment的initPropertySources方法

      3.校验一些关键的环境信息是否存在 

      **/

 prepareRefresh();



      /**

      1.为DefaultListableBeanFactory设置序列化id

      2.获取创建context时候创建的DefaultListableBeanFactory对象

      **/

 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();



      // 为bean设置一些属性

 prepareBeanFactory(beanFactory);



      try {

         /**

         

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {

   //添加WebApplicationContextServletContextAwareProcessor后置加载启

   beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));

   //添加忽略自动加载class

   beanFactory.ignoreDependencyInterface(ServletContextAware.class);

   registerWebApplicationScopes();

}

         

         **/

 postProcessBeanFactory(beanFactory);



         // Invoke factory processors registered as beans in the context.

         // 调用所有的BeanFactoryPostProcessors实现类，将结果存入参数beanFactory中

         //调用BeanDefinitionRegistryPostProcessor实现类(受spring管理),将需要装配的bean加载到BeanDefinition

 invokeBeanFactoryPostProcessors(beanFactory);



         // Register bean processors that intercept bean creation.

 registerBeanPostProcessors(beanFactory);



         // Initialize message source for this context.

         // 初始化消息原，比如国际化

 initMessageSource();



         // Initialize event multicaster for this context.

         // 初始化消息广播器

 initApplicationEventMulticaster();



         // Initialize other special beans in specific context subclasses.

         // 留给子类类初始化其他的bean

 onRefresh();



         // Check for listener beans and register them.

         // 注册监听器

 registerListeners();



         // Instantiate all remaining (non-lazy-init) singletons.

         // 初始化剩下的单例bean，在这里才开始真正的对bean进行实例化和初始化( 重要 )

 finishBeanFactoryInitialization(beanFactory);



         // Last step: publish corresponding event.

         // 完成刷新

 finishRefresh();

      }



      catch (BeansException ex) {

         if (logger.isWarnEnabled()) {

            logger.warn("Exception encountered during context initialization - " +

                  "cancelling refresh attempt: " + ex);

         }



         // Destroy already created singletons to avoid dangling resources.

 destroyBeans();



         // Reset 'active' flag.

 cancelRefresh(ex);



         // Propagate exception to caller.

 throw ex;

      }



      finally {

         // Reset common introspection caches in Spring's core, since we

 // might not ever need metadata for singleton beans anymore...

 resetCommonCaches();

      }

   }

}
  1. prepareBeanFactory
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {

   // 设置beanFactory的classLoader

 beanFactory.setBeanClassLoader(getClassLoader());

   beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));



   // 添加BeanPostProcessor

 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

   //添加忽略自动装配的接口列表

   beanFactory.ignoreDependencyInterface(EnvironmentAware.class);

   beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);

   beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);

   beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);

   beanFactory.ignoreDependencyInterface(MessageSourceAware.class);

   beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);



   /**

   将下面bean塞到resolvableDependencies的map里,后面使用

   **/

 beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);

   beanFactory.registerResolvableDependency(ResourceLoader.class, this);

   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);

   beanFactory.registerResolvableDependency(ApplicationContext.class, this);



    // 添加BeanPostProcessor

 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));



   // Detect a LoadTimeWeaver and prepare for weaving, if found.

 if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {

      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));

      // Set a temporary ClassLoader for type matching.

 beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));

   }



   // 注册环境变量bean

 if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {

      beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());

   }

   if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {

      beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());

   }

   if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {

      beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());

   }

}
  1. invokeBeanFactoryPostProcessors
/**

当前方法的作用

1.获取prepareContext处加载的beanFactoryPostProcessors(applyInitializers方法,最终调用

addBeanFactoryPostProcessor)

2.筛选出继承BeanDefinitionRegistryPostProcessor的类

3.分别找出接口BeanDefinitionRegistryPostProcessor的受spring管理的子类,并且继承了

PriorityOrdered和Ordered的类,排序后,执行回调方法

4.BeanDefinitionRegistryPostProcessor的子类注入BeanDefinition的过程主要在3.run方法

createApplicationContext的构造方法里实现

**/

public static void invokeBeanFactoryPostProcessors(

      ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {



   // Invoke BeanDefinitionRegistryPostProcessors first, if any.

 Set<String> processedBeans = new HashSet<>();

    //判断beanFactory是否是BeanDefinitionRegistry接口的实现类(是)

   if (beanFactory instanceof BeanDefinitionRegistry) {

      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

      //BeanFactoryPostProcessor接口实现列表

      List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();

      //BeanDefinitionRegistryPostProcessor接口实现列表

      //BeanDefinitionRegistryPostProcessor实现BeanFactoryPostProcessor

      List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();



      for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {

         if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {

            BeanDefinitionRegistryPostProcessor registryProcessor =

                  (BeanDefinitionRegistryPostProcessor) postProcessor;

            registryProcessor.postProcessBeanDefinitionRegistry(registry);

            registryProcessors.add(registryProcessor);

         }

         else {

            regularPostProcessors.add(postProcessor);

         }

      }



      // Do not initialize FactoryBeans here: We need to leave all regular beans

 // uninitialized to let the bean factory post-processors apply to them!

 // Separate between BeanDefinitionRegistryPostProcessors that implement

 // PriorityOrdered, Ordered, and the rest.

 List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();



      // 获取BeanDefinitionRegistryPostProcessor类的所有子类名称

      // 受spring管理的类

      // 此处为ConfigurationClassPostProcessor

 String[] postProcessorNames =

            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

      for (String ppName : postProcessorNames) {

          // 判断当前类是否是实现了PriorityOrdered

         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

            // 获取bean,没有则创建bean

            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));

            processedBeans.add(ppName);

         }

      }

      // 实现PriorityOrdered和BeanDefinitionRegistryPostProcessor接口的类

      // 排序

      sortPostProcessors(currentRegistryProcessors, beanFactory);

      registryProcessors.addAll(currentRegistryProcessors);

      // 执行BeanDefinitionRegistryPostProcessor实现类的postProcessBeanDefinitionRegistry

      // 方法,此处很关键

      // ConfigurationClassPostProcessor类会扫描所有注解类,并注册到BeanDefinition

      // 后期创建bean(@Controller,@Service,@Componetn等)

      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

      currentRegistryProcessors.clear();



      // 获取BeanDefinitionRegistryPostProcessor类的所有bean

 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

      for (String ppName : postProcessorNames) {

         if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {

            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));

            processedBeans.add(ppName);

         }

      }

      sortPostProcessors(currentRegistryProcessors, beanFactory);

      registryProcessors.addAll(currentRegistryProcessors);

      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

      currentRegistryProcessors.clear();



      // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.

 boolean reiterate = true;

      while (reiterate) {

         reiterate = false;

         postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

         for (String ppName : postProcessorNames) {

            if (!processedBeans.contains(ppName)) {

               currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));

               processedBeans.add(ppName);

               reiterate = true;

            }

         }

         sortPostProcessors(currentRegistryProcessors, beanFactory);

         registryProcessors.addAll(currentRegistryProcessors);

         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

         currentRegistryProcessors.clear();

      }



      // Now, invoke the postProcessBeanFactory callback of all processors handled so far.

 invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);

      invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

   }



   else {

      // Invoke factory processors registered with the context instance.

 invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);

   }



   // Do not initialize FactoryBeans here: We need to leave all regular beans

 // uninitialized to let the bean factory post-processors apply to them!

 String[] postProcessorNames =

         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);



   // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,

 // Ordered, and the rest.

 List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();

   List<String> orderedPostProcessorNames = new ArrayList<>();

   List<String> nonOrderedPostProcessorNames = new ArrayList<>();

   for (String ppName : postProcessorNames) {

      if (processedBeans.contains(ppName)) {

         // skip - already processed in first phase above

 }

      else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

         priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));

      }

      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {

         orderedPostProcessorNames.add(ppName);

      }

      else {

         nonOrderedPostProcessorNames.add(ppName);

      }

   }



   // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.

 sortPostProcessors(priorityOrderedPostProcessors, beanFactory);

   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);



   // Next, invoke the BeanFactoryPostProcessors that implement Ordered.

 List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());

   for (String postProcessorName : orderedPostProcessorNames) {

      orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

   }

   sortPostProcessors(orderedPostProcessors, beanFactory);

   invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);



   // Finally, invoke all other BeanFactoryPostProcessors.

 List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());

   for (String postProcessorName : nonOrderedPostProcessorNames) {

      nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

   }

   invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);



   // Clear cached merged bean definitions since the post-processors might have

 // modified the original metadata, e.g. replacing placeholders in values...

 beanFactory.clearMetadataCache();

}
  1. registerBeanPostProcessors
/**

当前方法的作用,

1.获取实现了BeanPostProcessor接口的并且受spring管理的类

2.获取实现PriorityOrdered的接口实现类,排序,然后注册到DefaultListableBeanfactory中

3.获取实现了Ordered的接口实现类,排序,然后注册到DefaultListableBeanfactory中

4.剩下的类注册到beanFactory中

5.beanFactory在bean创建的时候会回调当前方法



**/

public static void registerBeanPostProcessors(

      ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

   // 获取 BeanPostProcessor接口的实现类,并且受spring管理的类

   //(注册到BeanDefinition的类)

   String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);



 int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;

   beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));



   // Separate between BeanPostProcessors that implement PriorityOrdered,

 // Ordered, and the rest.

 List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();

   List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();

   List<String> orderedPostProcessorNames = new ArrayList<>();

   List<String> nonOrderedPostProcessorNames = new ArrayList<>();

   for (String ppName : postProcessorNames) {

      // 2.1获取PriorityOrdered接口的实现类

      if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

         BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

         priorityOrderedPostProcessors.add(pp);

         // 2.2同时实现了MergedBeanDefinitionPostProcessor,添加到新集合

         if (pp instanceof MergedBeanDefinitionPostProcessor) {

            internalPostProcessors.add(pp);

         }

      }

      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {

         // 3.1获取实现了Ordered的实现类

         orderedPostProcessorNames.add(ppName);

      }

      else {

        // 4.1处理剩下的类

         nonOrderedPostProcessorNames.add(ppName);

      }

   }



   // 2.3排序

 sortPostProcessors(priorityOrderedPostProcessors, beanFactory);

   // 2.4注册到beanFactory的List<BeanPostProcessor> beanPostProcessors集合中

   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);



   // 3.2同时获取实现了MergedBeanDefinitionPostProcessor,添加到新集合

 List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());

   for (String ppName : orderedPostProcessorNames) {

      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

      orderedPostProcessors.add(pp);

      if (pp instanceof MergedBeanDefinitionPostProcessor) {

         internalPostProcessors.add(pp);

      }

   }

   // 3.3排序ordered

   sortPostProcessors(orderedPostProcessors, beanFactory);

   // 3.4注册到beanFactory的集合中

   registerBeanPostProcessors(beanFactory, orderedPostProcessors);



   // 4.2获取同时实现MergedBeanDefinitionPostProcessor的类,添加到新集合

 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);

      }

   }

   //4.3注册到BeanFactory

   registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);



   // Finally, re-register all internal BeanPostProcessors.

 sortPostProcessors(internalPostProcessors, beanFactory);

   registerBeanPostProcessors(beanFactory, internalPostProcessors);



   // Re-register post-processor for detecting inner beans as ApplicationListeners,

 // moving it to the end of the processor chain (for picking up proxies etc).

 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

}
  1. finishBeanFactoryInitialization

单例bean实例化和初始化

preInstantiateSingletons源码分析

主要流程

  1. 初始化SpringApplication

    1. 添加启动类class到集合中
    2. 确定web类型
    3. 从spring.factories读取ApplicationContextInitializer和ApplicationListener,实例化加载到集合中

  2. run方法

    1. 获取spring.factories里的SpringApplicationRunListener,并实例化(getRunListeners)

    2. 创建环境变量StandardServletEnvironment, 添加servletContextInitParams,servletConfigInitParams等配置到MutablePropertySources,value暂时为空(prepareEnvironment)

    3. 创建web上下文AnnotationConfigServletWebServerApplicationContext对象,调用无参构造方法,会同时实例化AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner(createApplicationContext)

    4. AnnotatedBeanDefinitionReader的构造方法会将AutowiredAnnotationBeanPostProcessor(@AutoAware)以及ConfigurationClassPostProcessor等类注册到BeanFactory的beanDefinitionMap里(AnnotationConfigUtils.registerAnnotationConfigProcessors)

    5. 上下文前置工作,为上下文设置环境变量,调用ApplicationContextInitializer和SpringApplicationRunListener回调方法,设置applicationContext;将启动类加载到beanDefinition(prepareContext)

    6. Refresh

      1. 设置开始时间, 调用StandardServletEnvironment的initPropertySources方法(prepareRefresh)
      2. 获取创建context时候创建的DefaultListableBeanFactory对象,为DefaultListableBeanFactory设置序列化id
      3. BeanFactory准备工作,设置classLoader, 添加忽略自动装配的接口列表,注册一些单例bean等(prepareBeanFactory)

备注:

ConfigurationClassPostProcessor作用

  1. 加载受spring管理的注解
  2. 包括以下:@Controller,@Service,@Dao,@Configuration等
  3. Import注解装饰的加载bean也会被导入
  4. 最终都会加载到DefaultListableBeanFactory中的beanDefinitionMap里,后期被bean初始化
  5. ConfigurationClassPostProcessor解析过程:spring 源码解析一(bean定义) - 梦天幻 - 博客园
  6. Spring源码:refresh方法解析_超级码农0912的博客-CSDN博客

BeanDefinition

  1. GenericBeanDefinition:通用bean的解析,注册BeanDefinition的首选,实现如下

    1. ScannedGenericBeanDefinition和AnnotatedGenericBeanDefinition：存储@Component、@Service、@Controller等注解注释的类

  2. AnnotatedBeanDefinition:存储基于注解的bean信息(接口)

  3. ConfigurationClassBeanDefinition:存储@Configuration注解里的@Bean注解的bean信息

  4. RootBeanDefinition:spring创建bean的时候,会把GenericBeanDefinition和ConfigurationClassBeanDefinition转为RootBeanDefinition

    1. GenericBeanDefinition的patentName属性指定了当前类的父类,RootBeanDefinition没有parentName属性，对应的getter函数只是返回null，setter函数不提供赋值操作(不提供继承关系)
    2. 子类会覆盖父类中相同的属性，所以Spring会首先初始化父类的RootBeanDefinition，然后根据子类的GenericBeanDefinition覆盖父类中相应的属性，最终获得子类的RootBeanDefinition
avatar
文章
阅读
粉丝