Spring5源码解析1-从启动容器开始

从启动容器开始

最简单的启动spring的代码以下：

@Configuration
@ComponentScan
public class AppConfig {
}

public class Main {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context =
				new AnnotationConfigApplicationContext(AppConfig.class);
		context.close();
	}
}
复制代码

先来看一下AnnotationConfigApplicationContext类的UML图，留个印象。

点开AnnotationConfigApplicationContext(AppConfig.class);方法查看源码：

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
	//调用默认无参构造器,里面有一大堆初始化逻辑
	this();

	//把传入的Class进行注册,Class既能够有@Configuration注解,也能够没有@Configuration注解
	//怎么注册? 委托给了 org.springframework.context.annotation.AnnotatedBeanDefinitionReader.register 方法进行注册
	// 传入Class 生成 BeanDefinition , 而后经过 注册到 BeanDefinitionRegistry
	register(annotatedClasses);

	//刷新容器上下文
	refresh();
}
复制代码

该构造器容许咱们传入一个或者多个class对象。class对象能够是被@Configuration标注的，也能够是一个普通的Java 类。

有参构造器调用了无参构造器，点开源码：

public AnnotationConfigApplicationContext() {
	//隐式调用父类构造器,初始化beanFactory,具体实现类为DefaultListableBeanFactory
	super(); // 这个代码是笔者添加的，方便定位到super方法

	//建立 AnnotatedBeanDefinitionReader,
	//建立时会向传入的 BeanDefinitionRegistry 中 注册 注解配置相关的 processors 的 BeanDefinition
	this.reader = new AnnotatedBeanDefinitionReader(this);

	this.scanner = new ClassPathBeanDefinitionScanner(this);
}
复制代码

初始化子类时会先初始化父类，会默认调用父类无参构造器。AnnotationConfigApplicationContext继承了GenericApplicationContext，在GenericApplicationContext的无参构造器中，建立了BeanFactory的具体实现类DefaultListableBeanFactory。spring中的BeanFactory就是在这里被实例化的，而且使用DefaultListableBeanFactory作的BeanFactory的默认实现。

public GenericApplicationContext() {
	this.beanFactory = new DefaultListableBeanFactory();
}
复制代码

AnnotationConfigApplicationContext的构造器中还建立了两个对象：AnnotatedBeanDefinitionReader 和 ClassPathBeanDefinitionScanner。

先说scanner的做用，经过查看源码能够发现，这个scanner只有在手动调用AnnotationConfigApplicationContext的一些方法的时候才会被使用（经过后面的源码探究也能够发现，spring并非使用这个scanner来扫描包获取Bean的）。

建立AnnotatedBeanDefinitionReader对象。spring在建立reader的时候把this当作了参数传给了构造器。也就是说，reader对象里面包含了一个this对象，也就是AnnotationConfigApplicationContext对象。AnnotationConfigApplicationContext 实现了BeanDefinitionRegistry接口。点开this.reader = new AnnotatedBeanDefinitionReader(this);源码：

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
	this(registry, getOrCreateEnvironment(registry));
}
复制代码

从传入的BeanDefinitionRegistry对象，也就是AnnotationConfigApplicationContext对象中获取Environment（共用同一个Environment），而后又接着调用另外一个构造器。点开源码：

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	Assert.notNull(environment, "Environment must not be null");
	this.registry = registry;
	this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
	//在 BeanDefinitionRegistry 中注册 注解配置相关的 processors
	AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
复制代码

在这个构造器中，执行了一个很是重要的方法AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);，顾名思义，spring经过这个方法注册了解析注解配置相关的处理器。点开源码：

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
	registerAnnotationConfigProcessors(registry, null);
}
//再点开源码
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors( BeanDefinitionRegistry registry, @Nullable Object source) {

	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
	if (beanFactory != null) {
		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
			beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
		}
		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
		}
	}

	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		//org.springframework.context.annotation.internalConfigurationAnnotationProcessor - ConfigurationClassPostProcessor.class
		//这个类很是的重要,它是一个 BeanDefinitionRegistryPostProcessor
		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
	if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
	if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition();
		try {
			def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
					AnnotationConfigUtils.class.getClassLoader()));
		} catch (ClassNotFoundException ex) {
			throw new IllegalStateException(
					"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
		}
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
	}

	return beanDefs;
}
复制代码

1. 该方法从传入的BeanDefinitionRegistry对象，也就是AnnotationConfigApplicationContext对象中获取到DefaultListableBeanFactory对象。
2. 为获取的DefaultListableBeanFactory对象设置属性
3. 往DefaultListableBeanFactory对象中注册BeanDefinition，注册的是一些spring内置的PostProcessor的BeanDefinition（关于BeanDefinition的介绍下期在讲）。注意，此时只是注册BeanDefinition，并无实例化bean。默认状况下，执行完该方法后，spring容器中所注册的BeanDefinition为：

---

源码学习笔记：github.com/shenjianeng…