AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);看看AnnotationConfigApplicationContext类的构造方法都干了什么
/**
* 容器启动 传入配置类class数组
*/
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
//调用空参构造
this();
//将参数bean注册到容器中
register(componentClasses);
//刷新容器
refresh();
}1.空参构造
/**
* 空参构造
*/
public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}这里实例化了一个AnnotatedBeanDefinitionReader和一个ClassPathBeanDefinitionScanner。他们的构造方法如下：
/**
* 根据BeanDefinitionRegistry构造一个AnnotatedBeanDefinitionReader
*/
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
this(registry, getOrCreateEnvironment(registry));
}
/**
* 根据BeanDefinitionRegistry构建ClassPathBeanDefinitionScanner
*/
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
this(registry, true);
}可以看到这里传入的是一个BeanDefinitionRegistry，而AnnotationConfigApplicationContext在创建这两个对象的时候传入的是this，也就是AnnotationConfigApplicationContext对象，我们看一下这个类的定义
public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {}
public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {}发现其父类GenericApplicationContext实现了BeanDefinitionRegistry接口，所以这里能够直接用this来构造出AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner对象。附图：
2.AnnotatedBeanDefinitionReader初始化时都干了什么
/**
* 根据BeanDefinitionRegistry构造一个AnnotatedBeanDefinitionReader
*/
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
this(registry, getOrCreateEnvironment(registry));
}这里的构造方法是直接调用的另一个构造方法，我们先看一下getOrCreateEnvironment做了什么
/**
* 根据BeanDefinitionRegistry获取或者创建一个Environment
*/
private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
if (registry instanceof EnvironmentCapable) {
return ((EnvironmentCapable) registry).getEnvironment();
}
return new StandardEnvironment();
}再看一下两个参数的构造方法
/**
* 构造方法
*/
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);
//注册后置处理器
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}这里我们看一下AnnotationConfigUtils.registerAnnotationConfigProcessors这个方法干了什么
/**
* 注册基于AnnotationConfig启动容器的相关后置处理器
*/
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
registerAnnotationConfigProcessors(registry, null);
}
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
//获取registry中的DefaultListableBeanFactory
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());
}
}
//声明一个名为beanDefs的Set，用于存储这些后置处理器的BeanDefinition
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
//注册ConfigurationClassPostProcessor
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
//注册AutowiredAnnotationBeanPostProcessor
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));
}
// 注册CommonAnnotationBeanPostProcessor 必须在jsr250Present设置为true的前提下才会注册
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));
}
// 注册PersistenceAnnotationBeanPostProcessor. 必须在jpaPresent设置为true的前提下才会注册
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));
}
//注册EventListenerMethodProcessor
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));
}
//注册DefaultEventListenerFactory
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;
}这里注册了一堆的后置处理器。。。
3.ClassPathBeanDefinitionScanner初始化时都干了什么
套娃式的构造方法
/**
* 根据BeanDefinitionRegistry构建ClassPathBeanDefinitionScanner
*/
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
this(registry, true);
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment) {
this(registry, useDefaultFilters, environment,
(registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment, @Nullable ResourceLoader resourceLoader) {
//断言
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
//赋值
this.registry = registry;
/*
* 注册spring扫描类过滤器
* 加了特定注解的类会被扫描到
* 包括@Component(注意@Service等也算Component)、@ManagedBean、@Named（后面两个得有设置jar包才会添加）
*/
if (useDefaultFilters) {
registerDefaultFilters();
}
setEnvironment(environment);
setResourceLoader(resourceLoader);
}registerDefaultFilters方法处理
/**
* 注册spring扫描类过滤器
* 加了特定注解的类会被扫描到
* 包括@Component(注意@Service等也算Component)、@ManagedBean、@Named（后面两个得有设置jar包才会添加）
*/
@SuppressWarnings("unchecked")
protected void registerDefaultFilters() {
//往includeFilters中添加@Component的过滤器
//注意：@Component实际上不止它本身，例如@Repository、@Service、@Controller等属于Component
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
/*
* @ManagedBean和@Named得在有配置特定jar包的情况下才会添加，例如本文就没有添加这两个过滤器
* 这里用try catch 进行处理，发现异常忽略不做任何处理
*/
try {
//往includeFilters中添加@ManagedBean的过滤器
this.includeFilters.add(new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
}
try {
//往includeFilters中添加@Named的过滤器
this.includeFilters.add(new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
}
}4.register做了什么
/**
* 注册
*/
@Override
public void register(Class<?>... componentClasses) {
//断言
Assert.notEmpty(componentClasses, "At least one component class must be specified");
//注册
this.reader.register(componentClasses);
}
/**
* 注册bean
*/
public void register(Class<?>... componentClasses) {
//遍历注册
for (Class<?> componentClass : componentClasses) {
registerBean(componentClass);
}
}
/**
* 注册bean
*/
private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
@Nullable BeanDefinitionCustomizer[] customizers) {
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(supplier);
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));
}
}
}
if (customizers != null) {
for (BeanDefinitionCustomizer customizer : customizers) {
customizer.customize(abd);
}
}
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}