首页  思维导图  详情

spring容器加载

2020-03-12 17:00:23   44  举报





AI智能生成

spring 容器初始化分解

spring

作者其他创作

大纲/内容

构造 new AnnotationConfigApplicationContext()

DefaultResourceLoader->  this.classLoader = ClassUtils.getDefaultClassLoader();

AbstractApplicationContext->this.resourcePatternResolver = getResourcePatternResolver();

GenericApplicationContext-> this.beanFactory = new DefaultListableBeanFactory(); 初始化构造beanFactory

AbstractAutowireCapableBeanFactory->ignoreDependencyInterface(BeanNameAware.class); 容器注册时,忽略实现BeanNameAware接口,setXXX方法的自动注入

AbstractAutowireCapableBeanFactory->ignoreDependencyInterface(BeanFactoryAware.class); 容器注册时,忽略实现BeanFactoryAware接口,setXXX方法的自动注入

AbstractAutowireCapableBeanFactory->ignoreDependencyInterface(BeanClassLoaderAware.class); 容器注册时,忽略实现BeanClassLoaderAware接口,setXXX方法的自动注入

AnnotationConfigApplicationContext-> this.reader = new AnnotatedBeanDefinitionReader(this) 创建基于注解的BeanDefinition读取器

registerAnnotationConfigProcessors 注册注解配置相关的处理器BeanDefinition

【ConfigurationClassPostProcessor(BeanDefinitionRegistryPostProcessor->BeanFactoryPostProcessor)】

【AutowiredAnnotationBeanPostProcessor(BeanPostProcessor)】

【CommonAnnotationBeanPostProcessor(BeanPostProcessor)】

.org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor(JPA相关)

【EventListenerMethodProcessor(BeanFactoryPostProcessor)】

【DefaultEventListenerFactory(EventListenerFactory)】

核心代码

RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, xxxxName)) ==>registry.registerBeanDefinition(beanName, definition); ====>this.beanDefinitionMap.put(beanName, beanDefinition); ====>this.beanDefinitionNames.add(beanName);

AnnotationConfigApplicationContext-> this.scanner = new ClassPathBeanDefinitionScanner(this) 创建BeanDefinition扫描器

ClassPathBeanDefinitionScanner->setEnvironment(environment);

ClassPathBeanDefinitionScanner->setResourceLoader(resourceLoader)

AnnotationConfigApplicationContext-> this.reader.register(componentClasses);  将定义配置类,注入BeanDefinition容器中

registerBean

doRegisterBean

processCommonDefinitionAnnotations 处理通用注解

AnnotationConfigUtils.applyScopedProxyMode

BeanDefinitionReaderUtils.registerBeanDefinition ===>registry.registerBeanDefinition

refresh

prepareRefresh 刷新前预处理

this.closed.set(false); this.active.set(true);

initPropertySources(); 初始化属性设置,空方法提供子类重写

getEnvironment().validateRequiredProperties();  检验属性的合法等

this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);  初始化早期事件监听器

this.earlyApplicationEvents = new LinkedHashSet<>();  初始化早期事件集合

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  获取最新的BeanFactory

refreshBeanFactory

设置Id

getBeanFactory

prepareBeanFactory(beanFactory); BeanFactory的预准备工作 对BeanFactory进行一些设置

beanFactory.setBeanClassLoader(getClassLoader()) 设置类加载器

beanFactory.setBeanExpressionResolver 设置表达式解析器

beanFactory.addPropertyEditorRegistrar

beanFactory.addBeanPostProcessor 添加Bean后置处理器

【ApplicationContextAwareProcessor（BeanPostProcessor）】

beanFactory.ignoreDependencyInterface 容器注册时,忽略实现接口,setXXX方法的自动注入

EnvironmentAware

ResourceLoaderAware

EmbeddedValueResolverAware

ApplicationEventPublisherAware

MessageSourceAware

ApplicationContextAware

beanFactory.registerResolvableDependency 容器注册时，实现以下接口，字段or参数支持自动注入

BeanFactory

ResourceLoader

ApplicationEventPublisher

ApplicationContext

beanFactory.addBeanPostProcessor 添加Bean后置处理器

【ApplicationListenerDetector(BeanPostProcessor)】

beanFactory.registerSingleton ioc容器中,注入组件实例 ==>this.singletonObjects.put(beanName, singletonObject);

getEnvironment()

getEnvironment().getSystemProperties()

getEnvironment().getSystemEnvironment()

postProcessBeanFactory(beanFactory);  BeanFactory前处理,空方法.有子类实现

invokeBeanFactoryPostProcessors(beanFactory);  执行BeanFactory后置处理器

判断beanFactory instanceof BeanDefinitionRegistry

获取beanFactoryPostProcessors

BeanDefinitionRegistryPostProcessor处理

beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); 获取处理器,基类BeanFactoryPostProcessor

排序:PriorityOrdered->Ordered->其他

invokeBeanDefinitionRegistryPostProcessors ==>postProcessor.postProcessBeanDefinitionRegistry(registry);

ConfigurationClassPostProcessor

@ComponentScan注解处理

@Import注解出来

@Bean注解处理

invokeBeanFactoryPostProcessors ==>postProcessor.postProcessBeanFactory(beanFactory);

BeanFactoryPostProcessor处理

invokeBeanFactoryPostProcessors ==>postProcessor.postProcessBeanFactory(beanFactory);

EventListenerMethodProcessor

registerBeanPostProcessors(beanFactory);  注册Bean后置处理器

beanFactory.getBean(ppName, BeanPostProcessor.class); beanFactory.addBeanPostProcessor(postProcessor) ==>this.beanPostProcessors.add(beanPostProcessor);

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

initMessageSource();

initApplicationEventMulticaster();  初始化事件多播器

onRefresh();  初始化bean,空方法,提供子类实现.

registerListeners();   注册监听器

1、从容器中拿到所有的ApplicationListener

2、将每个监听器添加到事件派发器中； getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

3、派发之前步骤产生的事件；

finishBeanFactoryInitialization(beanFactory);

preInstantiateSingletons 初始化后剩下的单实例bean

遍历所有this.beanDefinitionNames getBean(beanName); Bean不是抽象的，是单实例的，不是懒加载

doGetBean

Object sharedInstance = getSingleton(beanName);

this.singletonObjects.get(beanName);

this.earlySingletonObjects.get(beanName);

this.singletonFactories.get(beanName);

sharedInstance为空,则开始创建bean

markBeanAsCreated(beanName); 标记创建状态

final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); 获取BeanDefinition

String[] dependsOn = mbd.getDependsOn();  获取当前Bean依赖的其他Bean;如果有按照getBean()把依赖的Bean先创建出来；

createBean

mbdToUse.prepareMethodOverrides();准备覆盖方法

resolveBeforeInstantiation 解析实例化前处理  【InstantiationAwareBeanPostProcessor】

【InstantiationAwareBeanPostProcessor】-> applyBeanPostProcessorsBeforeInstantiation

【InstantiationAwareBeanPostProcessor】-> applyBeanPostProcessorsAfterInitialization

doCreateBean

instanceWrapper = createBeanInstance(beanName, mbd, args);

applyMergedBeanDefinitionPostProcessors 【MergedBeanDefinitionPostProcessor】

【MergedBeanDefinitionPostProcessor】-> postProcessMergedBeanDefinition

populateBean(beanName, mbd, instanceWrapper); bean属性赋值

【InstantiationAwareBeanPostProcessor】-> postProcessAfterInstantiation

【InstantiationAwareBeanPostProcessor】-> postProcessPropertyValues

====赋值前

applyPropertyValues开始赋值

initializeBean(beanName, exposedObject, mbd);

invokeAwareMethods

BeanNameAware->setBeanName

BeanClassLoaderAware->setBeanClassLoader

BeanFactoryAware->setBeanFactory

applyBeanPostProcessorsBeforeInitialization

遍历执行【BeanPostProcessor】-> postProcessBeforeInitialization

invokeInitMethods

InitializingBean->afterPropertiesSet

invokeCustomInitMethod 自定义初始化方法

applyBeanPostProcessorsAfterInitialization

遍历执行【BeanPostProcessor】-> postProcessAfterInitialization

registerDisposableBeanIfNecessary 注册Bean的销毁方法

添加至缓存 addSingleton(beanName, singletonObject); ==>this.singletonObjects.put(beanName, singletonObject); ==>this.singletonFactories.remove(beanName); ==>this.earlySingletonObjects.remove(beanName); ==>this.registeredSingletons.add(beanName);

bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

遍历已创建bean,执行SmartInitializingSingleton->afterSingletonsInstantiated

finishRefresh();

clearResourceCaches();  清理资源缓存

initLifecycleProcessor(); 初始化和生命周期有关的后置处理器

默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】； 如果没有new DefaultLifecycleProcessor();加入到容器；

getLifecycleProcessor().onRefresh();

拿到前面定义的生命周期处理器（BeanFactory）； 回调onRefresh()；

publishEvent(new ContextRefreshedEvent(this)); 发布容器刷新完成事件；

LiveBeansView.registerApplicationContext(this);

resetCommonCaches();