首先阅读源码是件很痛苦的事情。第一步整合源码更痛苦，
我这里有整合好的一份，如果不嫌弃可以直接拿来用：https://github.com/ma1013789753/Spring5.1
整合完成之后，新建项目进行测试。
一，Spring启动的两种方式
1.1 基于注解：
import com.learn.day1.AppConfig;
import com.learn.day1.AppService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
//@Configuration
@Component
public class Day2Test {
/**
* 查看Spring是如何注入的
* @param args
*/
public static void main(String[] args) {
AnnotationConfigApplicationContext
context = new AnnotationConfigApplicationContext(Day2Test.class);
System.out.println(context.getBean(AppService.class));
}
@Bean
public AppService getService(){
return new AppService();
}
}1.2 基于xml文件：
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("application-day1.xml");
System.out.println(context.getBean(AppService.class));
}Springcontext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">
<!-- 扫描组件 -->
<context:component-scan base-package="com.learn"/>
<!-- 支持spring注解 -->
<context:annotation-config/>
</beans>
这里以注解方式为主：看懂后就要开始SpringBoot源码学习
二：AnnotationConfigApplicationContext：Spring上下文
由下图可知：
acx是一个读取器：ResourseLoader
acx是一个Bean工厂：BeanFacctory
acx是一个BD注册器：AliasRegistry
.....
* 独立的Spring上下文
* 可以接收@Configuration 注解的类
* 或者@Compontent 注解的类在实例化时创建了两个对象
private final AnnotatedBeanDefinitionReader reader;BD读取器
private final ClassPathBeanDefinitionScanner scanner;BD扫描器
当创建AnnotationConfigApplicationContext的执行流程
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh();
}第一步：调用this()方法：
执行 GenericApplicationContext 构造方法创建Bean工厂
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}执行 AbstractApplicationContext构造方法创建解析器 public AbstractApplicationContext() {
this.resourcePatternResolver = getResourcePatternResolver();
}执行 DefaultResourceLoader构造方法创建CalssLoader
public DefaultResourceLoader() {
this.classLoader = ClassUtils.getDefaultClassLoader();
}
第二步：初始化 AnnotatedBeanDefinitionReader
实例化对象 BeanDefinitionRegistry 其实就是个容器
实例化对象 BeanNameGenerator 名称生成器
实例化对象 ScopeMetadataResolver 生成方式解析器
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
Assert.notNull(environment, "Environment must not be null");
//当前的注册器就是指的是AnnotationConfigApplicationContext
this.registry = registry;
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}第三步：初始化 ClassPathBeanDefinitionScanner 与第二个对象基本类似，只不过职能不同
实例化对象 BeanDefinitionRegistry 其实就是AnnotationConfigApplicationContext
实例化对象 BeanNameGenerator 名称生成器
实例化对象 ScopeMetadataResolver 生成方式解析器
第四步：调用register(annotatedClasses)方法
最终调用AnnotatedBeanDefinitionReader 的doRegisterBean方法用来生成AnnotatedGenericBeanDefinition
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(instanceSupplier);
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
customizer.customize(abd);
}
//相当于一个map 通过name 获取BD
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}结果生成BeanDefinitionHolder key:name value:BeanDefinition。方便通过getKey获取
第五步：调用registerBeanDefinition方法 将BD加入到容器中
最终调用 DefaultListableBeanFactory 对象的registerBeanDefinition方法，将BD加入到BeanFactory中的map中去
截止到项目中仅仅注册了Spring需要的内部Bean，以及我们的配置类！
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
else if (existingDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (logger.isInfoEnabled()) {
logger.info("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
existingDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(existingDefinition)) {
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
removeManualSingletonName(beanName);
}
}
else {
// Still in startup registration phase
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
第五步：调用 refresh()方法刷新容器
三：Spring 核心 refresh()方法
// 容器刷新前的准备，设置上下文状态，获取属性，验证必要的属性等
prepareRefresh();
// 获取新的beanFactory，销毁原有beanFactory、为每个bean生成BeanDefinition等
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 配置标准的beanFactory，设置ClassLoader，设置SpEL表达式解析器，
// 添加忽略注入的接口，添加bean，添加bean后置处理器等
prepareBeanFactory(beanFactory);
try {
// 模板方法，此时，所有的beanDefinition已经加载，但是还没有实例化。
//允许在子类中对beanFactory进行扩展处理。比如添加ware相关接口自动装配设置，添加后置处理器等，
postProcessBeanFactory(beanFactory);
//实例化并调用所有注册的beanFactory后置处理器
// （实现接口BeanFactoryPostProcessor的bean，在beanFactory标准初始化之后执行）。
invokeBeanFactoryPostProcessors(beanFactory);
// 实例化和注册beanFactory中扩展了BeanPostProcessor的bean。
registerBeanPostProcessors(beanFactory);
// 初始化国际化工具类MessageSource
initMessageSource();
// 初始化事件广播器
initApplicationEventMulticaster();
// 模板方法，在容器刷新的时候可以自定义逻辑，不同的Spring容器做不同的事情
onRefresh();
// 注册监听器，广播early application events
registerListeners();
// 实例化剩余的Bean。
finishBeanFactoryInitialization(beanFactory);
// 初始化上下文的生命周期处理器
finishRefresh();
}5.1 prepareRefresh（）用来设置基本信息比如环境时间启动标识等
5.2 obtainFreshBeanFactory（）获取BeanFactory，设置刷新状态等 。
5.3 prepareBeanFactory（）方法 关联BeanFactory当前的是上下文 classLoader设置BeanPostProcessor等。
5.4 postProcessBeanFactory（）方法 允许在子类中对beanFactory进行扩展处理。比如添加后置处理器等。
5.5 invokeBeanFactoryPostProcessors（）方法 实例化所有Bean并调用所有注册的beanFactory后置处理器
5.6 registerBeanPostProcessors （）方法 实例化BeanPostProcessor
5.7 initMessageSource() 国际化设置
5.8 initApplicationEventMulticaster（） 初始化ApplicationContext 监听
5.9 onRefresh（）
5.10 registerListeners（） 注册监听器
5.11 finishBeanFactoryInitialization () 实例化剩余的Bean
5.12 finishRefresh（）初始化生命周期，删除缓存等
372
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
