Spring容器启动步骤

最新推荐文章于 2024-03-07 01:36:35 发布

每个人都有一段故事

最新推荐文章于 2024-03-07 01:36:35 发布

阅读量542

点赞数 1

分类专栏： Spring

本文链接：https://blog.csdn.net/qq_40272613/article/details/104439845

版权

Spring 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1. 使用AnnotationConfigApplicationContext创建并启动Spring容器

在这里插入图片描述

2.AnnotationConfigApplicationContext创建启动容器时this()所做的工作

AnnotationConfigApplicationContext继承GenericApplicationContext
GenericApplicationContext继承AbstractApplicationContext
AbstractApplicationContext继承DefaultResourceLoader

第一步：创建默认的类加载器，先获取当前线程的类加载器，如果当前线程没有拿到类加载器的话就获取ClassUtils对应的类加载器
在这里插入图片描述

第二步：初始化GenericApplicationContext的父类AbstractApplicationContext

1.初始化生成当前容器的唯一id以及当前容器的名称displayName
String id = ObjectUtils.identityToString(this);
String displayName = ObjectUtils.identityToString(this);
2.初始化空List集合容器beanFactoryPostProcessors用来存放容器刷新时候需要的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> beanFactoryPostProcessors =new ArrayList<BeanFactoryPostProcessor>()
3.初始化容器启动标志active，这里容器还未刷新所以为false
AtomicBoolean active = new AtomicBoolean();
4.初始化容器刷新启动线程锁startupShutdownMonitor
Object startupShutdownMonitor = new Object();
5.初始化空Set集合容器applicationListeners用来存放容器的监听器ApplicationListener<?>
Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<ApplicationListener<?>>();
6.创建PathMatchingResourcePatternResolver资源解析器，用来解析路径资源加载。
在这里插入图片描述
第三步：初始化父类GenericApplicationContext

1.初始化容器是否刷新标志refreshed，此时默认时false
2.初始化创建beanFactory=new DefaultListableBeanFactory()，这里主要工作是：

初始化创建autowireCandidateResolver，用来检查一个bean是否是autowire的候选类，就是是否别的地方有@Autowired注解引用这个类
AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();
初始化创建Map容器对象resolvableDependencies，用来存放已经解决了的autowire类
Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<Class<?>, Object>(16);
初始化创建Map容器对象beanDefinitionMap，用来存放跟BeanDefinition的名字跟BeanDefinition对应信息
Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);
初始化创建Map容器对象allBeanNamesByType，用来存放bean的类型跟所有bean的所有名字映射，包括别名跟自动生成的bean名称，这里存放非单例跟单例的bean
Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<Class<?>, String[]>(64);
初始化创建Map容器对象singletonBeanNamesByType，用来存放bean的类型跟所有bean的所有名字映射
Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<Class<?>, String[]>(64);
初始化创建List容器对象beanDefinitionNames，用来存放所有的bean名字，存放顺序是按照注册顺序
List<String> beanDefinitionNames = new ArrayList<String>(256);
初始化创建Set容器对象manualSingletonNames，用来存放所有的手动注册的单例bean名字，存放顺序是按照注册顺序
Set<String> manualSingletonNames = new LinkedHashSet<String>(16);

第四步: 初始化AnnotationConfigApplicationContext

初始化创建reader=new AnnotatedBeanDefinitionReader(this)，主要做了一下工作：
- 先获取当前Environment环境,没有的话就调用getOrCreateEnvironment(registry)获取并把environment设置给this当前对象
- 初始化创建bean的名称生成器beanNameGenerator，用来生成加入到容器里面的bean的名称
  BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
- 初始化创建scope作用域解析器scopeMetadataResolver，用来解析@Scope注解
  ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
- 设置registry为传入进来的AnnotationConfigApplicationContext配置类
- 初始化创建conditionEvaluator用来解析@Conditional注解
  this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
- registerAnnotationConfigProcessors，完成的事情主要有以下：
  1. 给beanFactory设置dependencyComparator，存放@Order接口里面顺序比较器
    beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE)
  2. 给beanFactory设置autowireCandidateResolver覆盖原先初始化的默认autowire候选类解析器
    beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
  3. 创建并给容器中添加注解配置管理相关的processor的BeanDefinition
    String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME ="org.springframework.context.annotation.internalConfigurationAnnotationProcessor";
  4. 创建并给容器中添加支持@Autowired注入的processor的BeanDefinition
    String AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME ="org.springframework.context.annotation.internalAutowiredAnnotationProcessor";
  5. 创建并给容器中添加解析@Required注解的processor的BeanDefinition
    String REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME ="org.springframework.context.annotation.internalRequiredAnnotationProcessor";
  6. 创建并给容器中添加支持JSR-250注解的processor的BeanDefinition
    String COMMON_ANNOTATION_PROCESSOR_BEAN_NAME ="org.springframework.context.annotation.internalCommonAnnotationProcessor";
  7. 创建并给容器中添加支持JPA注解的processor的BeanDefinition,从环境中获取是否存在JPA需要，有就加入
    String PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME ="org.springframework.context.annotation.internalPersistenceAnnotationProcessor";
  8. 创建并给容器中添加支持@EventListener注解的processor的BeanDefinition
    String EVENT_LISTENER_PROCESSOR_BEAN_NAME ="org.springframework.context.event.internalEventListenerProcessor";
  9. 创建并给容器中添加EventListenerFactory管理类BeanDefinition
    String EVENT_LISTENER_FACTORY_BEAN_NAME ="org.springframework.context.event.internalEventListenerFactory";
初始化创建scanner = new ClassPathBeanDefinitionScanner(this)，主要做了以下工作:
1. 初始化beanDefinitionDefaults
  BeanDefinitionDefaults beanDefinitionDefaults = new BeanDefinitionDefaults();
2. 初始化beanNameGenerator,bean的名字生成器
  BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
3. 初始化scopeMetadataResolver,解析@Scope注解
  ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
4. 初始化设置registry等于传入的registry
5. 初始化默认的过滤机制includeFilters,默认的是扫描@Component注解
6. 初始化设置environment
7. 初始化设置resourceLoader

3.AnnotationConfigApplicationContext创建启动容器时register(annotatedClasses)所做的工作

1.调用上一步创建好了的reader去注册配置类
2. for循环注册配置类
3. 调用registerBean方法，这里的主要工作如下：
4. 根据annotatedClasses创建AnnotatedGenericBeanDefinition对象，AnnotatedGenericBeanDefinition是BeanDefinition的间接实现类
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass)
大致工作如下：
* 设置beanClass为当前配置类
* 根据beanClass创建标准的注解元数据描述对象
this.metadata = new StandardAnnotationMetadata(beanClass, true);
这里主要的工作是获取配置类上的所有注解，比如说@Configuration、@Import注解等
5. 从上一步根据配置类创建生成的AnnotatedGenericBeanDefinition对象中获取解析出来的注解元数据StandardAnnotationMetadata对象，利用conditionEvaluator解析判断当前配置类中是否存在@Conditional注解，如果存在就判断里面的Condition条件是否成立。成立或者不存在@Conditional注解则继续下一步
this.conditionEvaluator.shouldSkip(abd.getMetadata())
6. 创建生成作用域描述元数据scopeMetadata，默认的是singleton单例,并设置生成的AnnotatedGenericBeanDefinition对象作用域名称为scopeMetada.getScopeName()
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
7. 利用beanNameGenerator生成beanName
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
8. 解析配置类上面普通定义注解processCommonDefinitionAnnotations
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
这里的主要工作是：

判断配置类上是否存在@Lazy注解，存在则将生成的AnnotatedGenericBeanDefinition对象的lazyInit属性设置为@Lazy注解的value值
判断配置类上是否存在@Primary注解，存在则将生成的AnnotatedGenericBeanDefinition对象的primary属性设置为true
判断配置类上是否存在@Dependson注解，存在则将生成的AnnotatedGenericBeanDefinition对象的dependson属性设置为@Dependson的value值
判断生成的AnnotatedGenericBeanDefinition对象是否是AbstractBeanDefinition的子类或者实现类，是的话将其转化成AbstractBeanDefinition的类型。判断该对象上是否存在@Role注解，存在的话则将该对象的role属性设置为@Role注解的value值；判断该对象上是否存在@Description注解，如果存在，则将该对象上的description属性设置为@Description的value值

9.根据创建的AnnotatedGenericBeanDefinition对象创建definitionHolder
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
10.根据scopeMeta决定是否生成definitionHolder的代理类
11.向beanFactory注册配置类的定义信息
this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
12.向beanFactory注册类的别名信息
在这里插入图片描述

4.AnnotationConfigApplicationContext创建启动容器时refresh()所做的工作

第一步：prepareRefresh()容器刷新准备，主要工作：

清除scanner的Map容器metadataReaderCache存放的数据
容器刷新前准备

第二步：ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();获取beanFactory工厂
在这里插入图片描述

refreshBeanFactory(),设置bean工厂的刷新状态reshfreshed为true,设置bean工厂的序列化id

2.ConfigurableListableBeanFactory beanFactory = getBeanFactory();获取已经创建好类的beanFactory

第三步：prepareBeanFactory(beanFactory);准备好beanFactory

beanFactory.setBeanClassLoader(getClassLoader());设置类加载器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));设置表达式解析器

2.beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));向beanFactory手动注册BeanPostProcessor实现类ApplicationContextAwareProcessor对象。用来解析处理EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware接口实现类
EnvironmentAware环境感知接口，实现这个接口用来获取当前容器的Environment；EmbeddedValueResolverAware值解析器感知接口，实现这个接口用来获取当前容器的值解析器EmbeddedValueResolver;
ResourceLoaderAware资源加载器感知接口，实现这个接口用来获取当前容器里的资源加载器ResourceLoader;
ApplicationEventPublisherAware事件发布器感知接口，实现这个接口用来获取容器中ApplicationEventPublisher事件发布器；
MessageSourceAware消息源感知接口，实现这个接口用来获取容器中MessageSource消息源
ApplicationContextAware应用上下文感知接口，实现这个接口用来获取当前容器上下文ApplicationContext
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
设置@Autowired需要忽略的接口类型

在这里插入图片描述

beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
将BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext设置为已经解决的依赖

7. beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this))；手动添加BeanPostProcessor的实现类ApplicationListenerDetector对象，用来处理ApplicationListener
8. 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())); }
检测beanFactory中是否有LOAD_TIME_WEAVER_BEAN_NAME，如果有则添加BeanPostProcessor的实现类LoadTimeWeaverAwareProcessor对象，并创建设置tempClassLoader
9. if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); }
如果beanFactory容器中不存在环境对象，则获取当前环境对象注册到单例bean容器中
10. if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); }
如果当前beanFactory不存在系统属性对象，则获取当前环境中的系统属性对象注册到单例bean容器中
11.if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment()); }
如果当前beanFactory中不存在系统环境变量对象，则获取当前环境中的系统环境变量对象注册到单例bean容器中

第四步：postProcessBeanFactory(beanFactory);给AbstractApplicationContext的实现类自定义添加标准化启动之外的BeanPostProcessor
在这里插入图片描述

第五步：invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryProcessor

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());执行beanFactoryPostProcessor
1. Set<String> processedBeans = new HashSet<String>();创建Set集合去存已经处理过的BeanFactoryPostProcessor
2. List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();创建List集合存放普通的BeanFactoryPostProcessor
3. List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();创建List集合存放BeanDefinitionRegistryPostProcessor(BeanFactoryPostProcessor的子类的一种,优先于普通的BeanDefinitionPostProcessor执行)
4. List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();创建List集合存放当前的BeanDefinitionRegistryPostProcessor
5. String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);根据BeanDefinitionRegistryPostProcessor类型去DefaultListableBeanFactory中的beanDefinitionNames集合获取对应类型的beanName。DefaultListableBeanFactory的getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);方法的流程大致是：
  - 迭代遍历beanDefinitionNames中元素
  - 如果不是别的bean的别名，先去AbstractBeanFactory父类中定义的mergedBeanDefinitions中找是否已经存在了对应的BeanDefinition,如果不存在就去beanDefinitionMap中查找对应beanName的BeanDefinition，然后将该BeanDefinition克隆之后或者根据该BeanDefinition重新创建RootBeanDefinition，然后将对应的beanName跟新的BeanDefinition加入到mergedBeanDefinitions中
  - 判断根据beanName找到的bean定义是否匹配BeanDefinitionRegistryPostProcessor类型，如果匹配则把beanName加入到符合条件的结果集合中；如果根据beanName找到的bean定义是FactoryBean,如果是FactoryBean就看一下它创建的真实对象是否匹配BeanDefinitionRegistryPostProcessor类型，如果匹配则把&beanName(&是标注FactoryBean)加入到符合条件的结果集合中
6. 循环遍历上面找到的postProcessorNames,查看当前BeanDefinitionRegistryPostProcessor是否是PriorityOrdered的实现类，如果是的话就创建bean的实例并把它添加到currentRegistryProcessors中，并且将beanName添加到processedBeans中
7. sortPostProcessors(currentRegistryProcessors, beanFactory);获取beanFactory中的Ordered系列接口的排序比较器对currentRegistryProcessors进行排序
8. registryProcessors.addAll(currentRegistryProcessors);记录所有的BeanDefinitionRegistryPostProcessor
9. invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);执行所有的BeanDefinitionRegistryPostProcessor ,这里主要是执行ConfigurationClassPostProcessor的processConfigBeanDefinitions方法，解析配置类，主要工作如下：
  1. List<BeanDefinitionHolder> configCandidates = new ArrayList<BeanDefinitionHolder>();创建一个List数组用来接收配置类
  2. String[] candidateNames = registry.getBeanDefinitionNames();获取当前beanFactory容器中所有的beanDefinitionNames
  3. 遍历上面获取的beanDefinitionNames集合candidateNames,根据beanDefinitionName去beanFactory中的beanDefinitionMap中获取对应的beanDefinition，判断beanDefinition上是否有@Configuration注解，有的话就是配置类，将配置类加入到第一步中的配置类数组configCandidates中。接下来再对配置类进行排序，看配置类是否贴有@Order注解，如果有则拿到@Order注解的优先级值进行排序，没有的话就将该配置类的优先级设置为最低优先级。排序完之后主要工作就是解析已经排序好的配置类。创建ConfigurationClassParser配置类解析对象，迭代解析配置类对象，先查看配置类上是否存在@Conditional注解，如果有就判断是否满足Condition,不满足则不解析该配置类，满足的话进行解析。
    1. 解析配置类是否里面存在别的类；
    2. 解析@PropertySource注解；
    3. 解析@ComponentScan注解；
    4. processImports方法解析@Import注解,这里做的主要是获取@Import注解中导入的类，然后循环迭代这些类，如果是ImportSelector的实现类，那么创建对象并转化成ImportSelector类型，执行ParserStrategyUtils.invokeAwareMethods(selector, this.environment, this.resourceLoader, this.registry)。如果当前类实现类Aware接口，判断当前类是否实现了BeanClassLoaderAware接口，实现了就执行实现的setBeanClassLoader方法将当前容器中的BeanClassLoader设置进去；判断当前类是否实现了BeanFactoryAware接口，如果实现了就执行实现的setBeanFactory接口，将BeanFactory设置进去；判断当前类是否实现类EnvironmentAware接口，实现了就执行实现的setEnvironment方法，将容器中的Environment对象设置进去；判断当前类是否实现了ResourceLoaderAware接口，实现了就执行实现的setResourceLoader方法，将当前容器中的ResourceLoader设置进去，判断当前ImportSelector是否是DeferredImportSelector延时加载实现类，如果是将该类的对象设置到配置类的延时加载ImportSelector集合deferredImportSelectors中，不是的话执行ImportSelector的实现方法selectImports,获取导入的类的全限定名，递归重走processImports解析方法，一般最后导入的类都是解析成配置类。如果当前类是ImportBeanDefinitionRegistrar的实现类，那么重复上面的操作查看当前类是否是Aware接口，是的话执行对应Aware接口的实现方法，并将当前类信息加入到当前配置类进行管理。如果当前类不是上面的两中类型的实现类就将当前类注册成配置类，因此如果说一个类不用@Configuration进行标注其实也可以通过@Import注解进行导入并且该类也会按照配置类处理流程进行处理，包括会对类上的其它注解比如@PropertySource以及@Bean注解进行解析
    5. 解析@ImportResource注解；
    6. 解析@Bean注解，获取配置类的所有方法，循环遍历所有方法，记录下贴有@Bean注解的方法，并将@Bean方法信息记录到配置类的Set容器beanMethods中；
    7. 获取当前配置类的接口，查看接口中的默认方法是否存在@Bean注解，如果存在，就将该默认方法也加入到beanMethods中；
    8. 解析当前配置类的父类，如果没有父类则解析完成，如果有父类则递归解析父类，直到没有父类为止。
    9. 将解析的配置类保存到ConfigurationClassParser配置类解析对象中
    10. 执行processDeferredImportSelectors(); 方法解析延时加载的ImportSelector对象
  4. this.reader.loadBeanDefinitions(configClasses);加载配置类信息
    1. TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();创建该对象辅助conditionEvaluator解析@Conditional注解的对象
    2. 判断当前配置类是否是@Import注解导入的，如果该配置类是导入的，那么判断导入这个配置类的那个配置类上面是否存在@Conditional注解，如果有则判断Condition是否成立，如果不成立，那么将这个配置类设置为跳过，如果导入这个配置类的那个配置类不存在@Conditional注解或者Condition条件成立,那么再判断这个配置类上是否存在@Conditional注解，成立的话就加载这个配置类，不成立的非导入配置类就从beanFactory的beanDefinitionMap移除相关的bean定义
    3. registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass configClass)向beanFactory注册符合条件的@Import导入的配置类定义
    4. loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod)查看当前配置类是否存在@Bean方法，如果存在就先判断该方法是否满足@Conditional条件，满足条件就解析该方法上的@Bean注解，并且根据当前配置类创建一个新的配置类对象用来存放@Bean方法，设置新的配置类的factoryBeanName为当前配置类，factoryMethodName为@Bean标注的方法名，然后AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata)方法解析这个方法上的一些基本的注解，获取@Bean的initMethod值设置到新的配置类的initMethod属性，获取@Bean的destroyMethd值设置到新的配置类destroyMethod属性，最后向beanFactory的beanDefinitionMap添加一个新的BeanDefinition,key是@Bean标注的方法名，value是这个新创建的配置类BeanDefinition
    5. loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());加载@ImportResource导入的xml配置，创建BeanDefinition添加到beanFactory的beanDefinitionMap
    6. loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());加载从@Import注解导入的ImportBeanDefinitionRegistrar的实现类定义信息，执行ImportBeanDefinitionRegistrar的registerBeanDefinitions方法向beanFactory的beanDefinitionMap注册bean的定义
  5. 清除metadataReaderFactory的缓存，里面就是根据类加载器的加载的类定义
10. 获取当前beanFactory中实现了Ordered接口的BeanDefinitionRegistryPostProcessors，对所有符合条件的BeanDefinitionRegistryPostProcessors排序，执行符合条件的BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法
11. 执行所有的没有实现PriorityOrdered 、Ordered的BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法
12. 执行所有的BeanDefinitionRegistryPostProcessor中的BeanDefinitionRegistryPostProcessor方法
13. 执行所有的除了上面执行了的BeanDefinitionRegistryPostProcessor类型的BeanFactoryPostProcessor，区分出实现了PriorityOrdered接口跟Ordered接口以及普通的BeanFactoryPostProcessor。对实现了PriorityOrdered、Ordered的BeanFactoryPostProcessor进行排序，先执行实现了PriorityOrdered的BeanFactoryPostProcessor中的postProcessBeanFactory方法，再执行实现了Ordered的BeanFactoryPostProcessor中的postProcessBeanFactory方法，最后执行普通的BeanFactoryPostProcessor中的postProcessBeanFactory方法的方法
14. beanFactory.clearMetadataCache();清除所有根据beanName创建的BeanDefinition的缓存容器mergedBeanDefinitions
检测当前beanFactory是否存在loadTimeWeaver，有的话就执行以下操作：
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));

第六步：registerBeanPostProcessors(beanFactory);注册所有BeanPostProcessor

beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));向beanFactory的beanPostProcessors中再注册一个BeanPostProcessorChecker
迭代beanFactory中的postProcessorNames，根据postProcessorName从beanFactory中获取对应的BeanPostProcessor，区分出实现了PriorityOrdered接口跟Ordered接口以及未实现这两个接口的普通BeanPostProcessor以及MergedBeanDefinitionPostProcessor类型的BeanPostProcessor
对实现PriorityOrdered接口的BeanPostProcessor进行排序，将所有的BeanPostProcessor添加到beanFactory的beanPostProcessors中
对实现了Ordered接口的BeanPostProcessor进行排序，将所有的BeanPostProcessor添加到beanFactory的beanPostProcessors中
将所有普通的BeanPostProcessor添加到beanFactory的beanPostProcessors中
先对所有的MergedBeanDefinitionPostProcessor类型的BeanPostProcessor进行排序，再将所有的MergedBeanDefinitionPostProcessor类型的BeanPostProcessor添加到beanFactory的beanPostProcessors中
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));再重新向beanFactory添加ApplicationListenerDetector类型的BeanPostProcessor，用于监听ApplicationListener

第七步：initMessageSource(); 为这个容器初始化信息源

DelegatingMessageSource dms = new DelegatingMessageSource();创建委托信息源
this.messageSource = dms;将信息源对象设置为上面创建的
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);向beanFactory注册该创建的信息源对象单例

第八步: initApplicationEventMulticaster();为这个容器初始化事件多播器

this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);创建一个简单的事件多播器
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);向beanFactory注册该创建的事件事件多播器对象

第九步：onRefresh(); Initialize other special beans in specific context subclasses.

第十步：registerListeners() 把实现了ApplicationListener接口的bean注册成Listener绑定到多播器

String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);从beanFactory中的beanDefinitionNames以及manualSingletonNames中获取类型是ApplicationListener的BeanName集合
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);迭代上一步获取的ApplicationListener的beanName集合，将beanName设置到多播器的applicationListenerBeans集合中
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;获取早期容器事件
getApplicationEventMulticaster().multicastEvent(earlyEvent);获取多播器处理早期事件

第十一步：finishBeanFactoryInitialization(beanFactory); 初始化所有的非懒加载的单例

beanFactory.addEmbeddedValueResolver 如果当前容器中没有嵌入式值解析器的话，就添加一个StringValueResolver值解析器到容器中
如果beanFactory中有LoadTimeWeaverAware类型的beanDefinition那么就从beanFactory中获取所有的该类型的beanName，调用getBean方法创建单例bean，这个类型的bean用来支持AspectJ织入
beanFactory.freezeConfiguration() 冻结beanFactory的所有bean definitions，不再允许后置处理器进行处理

4.beanFactory.preInstantiateSingletons();初始化其它的单例bean
1. List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);获取容器中所有的beanDefinitionNames
2. 触发所有的非懒加载单例初始化，迭代上一步获取到的beanNames，从mergedBeanDefinitions中根据对应的beanName获取对应的RootBeanDefinition
3. 如果RootBeanDefinition不是abstract修饰并且是单例以及非延时加载的，那么再去判断beanName对应的RootBeanDefinition是否是FactoryBean
4. 如果不是FactoryBean类型调用getBean(beanName)
5. getBean(beanName)方法doGetBean( final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)方法
6. doGetBean方法流程：
  1. 先处理当前beanName
  2. Object sharedInstance = getSingleton(beanName);检查容器的单例对象容器中是否已经存在该beanName对应的单例，因为容器启动的时候有手动添加进去的单例
  3. 如果根据beanName获取的单例对象不为null，那么就执行bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);，如果单例对象是FactoryBean类型的话那就获取当前单例FactoryBean对象的getObject方法获取创建的对象并返回，否则直接返回当前单例对象，已经手动创建了的单例这一步其实没有多大意义
  4. 如果根据beanName获取的单例对象为null, 调用getBean(beanName)方法，判断当前类定义是否依赖其它的类，也就是是否贴了@Dependons注解，如果依赖其它的类查看依赖的那个类是否是依赖当前类，如果是就报循环依赖的错误，不是那么就调用getBean方法先创建依赖的类的单例对象
  5. getBean方法里面再调用了doGetBean方法，doGetBean里面调用getSingleton方法创建单例对象，getSingleton方法里面又调用了createBean方法创建单例对象
  6. createBean方法创建单例对象方法先执行bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);在对象创建之前执行InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法，postProcessBeforeInstantiation这个方法可以生成代理对象替代原先的那个对象，这里因为postProcessBeforeInstantiation会返回值，因此不需要配置BeanFactoryAware等接口使用。
  7. 如果上一步作用之后返回的bean不为null,再执行bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);,调用所有的后置处理器的postProcessAfterInitialization方法对上一步生成的代理类对象进行处理，然后返回该代理对象
  8. Object beanInstance = doCreateBean(beanName, mbdToUse, args);如果上面不生成代理代理对象，那么就调用doCreateBean创建单例对象
  9. doCreateBean方法步骤：
    1. BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args)创建单例对象的包装对象BeanWrapper。
    2. 这里如果beanDefinition的factoryMethodName属性不为null，也就是说如果当前BeanDefintion是对应的@Bean方法要创建的对象的BeanDefintion，那么就调用instantiateUsingFactoryMethod(beanName, mbd, args)创建单例对象；
    3. 如果beanDefinition的factoryMethodName属性为null的话就调用instantiateBean(beanName, mbd);创建单例对象。
    4. instantiateBean方法里面调用beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);调用对象的空差构造器创建对象，然后BeanWrapper bw = new BeanWrapperImpl(beanInstance);创建对象的BeanWrapper的对象返回
    5. final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);获取上一步创建的BeanWrapper对象中包装的真正的单例对象
    6. Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);获取包装的真正单例对象的Class
    7. applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 获取所有的BeanPostProcessor中MergedBeanDefinitionPostProcessor类型的BeanPostProcessor，调用MergedBeanDefinitionPostProcessor(主要有InitDestroyAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、AutowiredAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor、ApplicationListenerDetector)的postProcessMergedBeanDefinition方法。InitDestroyAnnotationBeanPostProcessor解析beanDefinition上面的@PostConstruct注解，保存到一个集合，解析@PreDestroy注解，保存到一个集合。如果当前beanType的父类，如果有父类，再循环解析重复上面的解析操作。将解析之后的@PostConstruct注解跟@PreDestroy注解信息通过new LifecycleMetadata(clazz, initMethods, destroyMethods)创建一个LifecycleMetadata对象。CommonAnnotationBeanPostProcessor解析@Resource注解，如果有父类那么再解析父类，最后通过new InjectionMetadata(clazz, elements);创建InjectionMetadata对象。AutowiredAnnotationBeanPostProcessor解析@Autowired注解，如果有父类那么再解析父类，最后new InjectionMetadata(clazz, elements)创建InjectionMetadata对象。RequiredAnnotationBeanPostProcessor解析@Required注解
    
    8. 解决循环依赖问题，调用addSingletonFactory方法将创建好的单例封装成ObjectFactory对象加入到beanFactory的中
    1. populateBean(beanName, mbd, instanceWrapper);设置bean的属性，比如说字段值，这里还会有InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation判断，然后是处理@Autowired字段,根据名称注入的话调用getBean(beanName)获取bean的实例，并将值设置到对应的字段
    2. 执行 initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd)方法。
      1. 然后方法里面又先执行invokeAwareMethods(beanName, bean);方法，当前bean是Aware接口的话，如果是BeanNameAware的实现类，执行实现的setBeanName 方法，如果当前类是BeanClassLoaderAware的接口实现类，执行实现的setBeanClassLoade方法，如果当前类是BeanFactoryAware接口，执行实现的setBeanFactory方法
      2. 执行wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)方法,执行所有的BeanPostProcessor的postProcessBeforeInitialization的方法，可以用来生成当前bean的子类对象或者给bean设置一些属性值
    3. invokeInitMethods(beanName, wrappedBean, mbd);执行当前实例的初始化方法
      1. 如果当前bean是InitializingBean接口的实现类，((InitializingBean) bean).afterPropertiesSet();,那么执行实现的afterPropertiesSet方法
      2. 执行当前bean对象的initMethod，这里还会对该initMethod判断是否是InitializingBean的的afterPropertiesSet又作为了initMethod方法，如果不是的话就执行initMethod
    4. wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);执行BeanPostProcessor的postProcessAfterInitialization方法，这里也可以给bean设置属性或者是创建返回一个包含原先bean信息的新的对象
7. addSingleton(beanName, singletonObject);将创建的单实例bean交给spring进行管理，移除原先存放的singletonFactories的中的该实例
8. 迭代所有的生成完了的单例，如果是SmartInitializingSingleton类型的实现类，执行它的afterSingletonsInstantiated方法，比如说EventListener注解的解析就是在这一步完成的
  
  第十二步骤：finishRefresh()；结束容器刷新

在这里插入图片描述

每个人都有一段故事

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring容器启动步骤

1. 使用AnnotationConfigApplicationContext创建并启动Spring容器2.AnnotationConfigApplicationContext创建启动容器时this()所做的工作AnnotationConfigApplicationContext继承GenericApplicationContextGenericApplicationContext继承Ab...
复制链接

扫一扫