1.实例化容器:AnnotationConfigApplicationContext
这里主要分析注解形式的源码,我们启动容器的时候,虽然只是new了一个AnnotationConfigApplicationContext对象,但是在这个过程中spring处理了很多的事情。
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
AnnotationConfigApplicationContext的类结构图:
创建AnnotationConfigApplicationContext对象
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
//调用构造函数
this();
//注册配置类
register(componentClasses);
//ioc容器刷新
refresh();
}
1.1 构造方法
(1)这是一个有参的构造方法,可以接收多个配置类,不过一般情况下,只会传入一个配置类。
(2)这个配置类有两种情况,一种是传统意义上的带上@Configuration注解的配置类,还有一种是没有带@Configuration,但是带有@Component,@Import,@ImportResouce,@Service, @ComponentScan等注解的配置类,在Spring内部把前者称为Full配置类,把后者称之为Lite配置类。
1.2 this()无参构造方法
无参构造中主要就是对读取器reader和扫描器scanner进行了实例化,reader的类型是AnnotatedBeanDefinitionReader,可以看出它是一个负责注解类型的Bean定义读取器,scanner的类型是ClassPathBeanDefinitionScanner,它仅仅是在外面手动调用.scan方法,或者调用参数为String的构造方法,传入需要扫描的包名才会用到,像这样方式传入的配置类是不会用到这个scanner对象的。
public AnnotationConfigApplicationContext() {
//调用本构造方法之前会先去调用父类GenericApplicationContext的构造函数
/**
* 创建一个读取注解的Bean定义的读取器
* 完成了spring内部BeanDefinition的注册(主要是后置处理器)
*/
this.reader = new AnnotatedBeanDefinitionReader(this);
/**
* 创建BeanDefinition扫描器,可以用来扫描包或者类,继而转换成bean定义
*
* spring默认的扫描包不是这个scanner对象,而是自己new的一个ClassPathBeanDefinitionScanner
* spring在执行工程后置处理器ConfigurationClassPostProcessor时,去扫描包时会new一个ClassPathBeanDefinitionScanner
*
* 这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法
* 例如:AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
* context.scan();
*/
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
2.实例化工厂:DefaultListableBeanFactory
上段源码中,会隐式调用父类的构造方法,即调用父类GenericApplicationContext的构造函数。在该构造方法中创建了beanFactory----DefaultListableBeanFactory,是用来生产和获得Bean。
public GenericApplicationContext() {
//为ApplicationContext spring上下文对象初始化beanFactory
//这里用的是DefaultListableBeanFactory,它是BeanFactory体系中最底层的实现,功能最多
//该类还实现了BeanDefinitionRegistry,拥有了注册beanDefinition的能力,此功能就是该类负责的
this.beanFactory = new DefaultListableBeanFactory();
}
DefaultListableBeanFactory类结构图:
这里要注意DefaultListableBeanFactory实现了BeanDefinationRegistry接口,具备了注册bean定义的能力。后面关于bean定义的注册就是该类负责的。
3.实例化BeanDefinition读取器:AnnotatedBeanDefinitionReader
3.1 注册内置的PostProcessor 2.注册相关的BeanDefinition
我们再来看AnnotationConfigApplicationContext的无参构造方法,让我们看看Spring在初始化AnnotatedBeanDefinitionReader的时候做了什么:
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
Assert.notNull(environment, "Environment must not be null");
//把ApplicationContext对象(出入的registry)赋值给AnnotatedBeanDefinitionReader
this.registry = registry;
//用户处理条件注解 @Condition
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
//注册了一些spring的内置后置处理器
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
//。。。。省略部分代码
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
/**
* 为我们容器中注册了解析我们配置类的后置处理器ConfigurationClassPostProcessor
* Bean name :org.springframework.context.annotation.internalConfigurationAnnotationProcessor
* bean名称格式为:名称为“internal(内部的) + 后置处理器类名”的类的全类名
*/
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
//在ConfigurationClassPostProcessor类中,会解析加了@Configuration的配置类,还会解析@ComponentScan、@ComponentScans
//注解扫描的包,以及解析@Import注解
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
/**
* 为我们容器中注册了处理注解 @Autowired 的后置处理器AutowiredAnnotationBeanPostProcessor
* Bean name :org.springframework.context.annotation.internalAutowiredAnnotationProcessor
*/
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));
}
// 。。。。省略部分代码
return beanDefs;
}
在AnnotatedBeanDefinitionReader的构造方法中:
(1) 判断容器中是否已经存在了ConfigurationClassPostProcessor Bean
(2)如果不存在(当然这里肯定是不存在的),就通过RootBeanDefinition的构造方法获得ConfigurationClassPostProcessor的BeanDefinition,RootBeanDefinition是BeanDefinition的子类
(3)执行registerPostProcessor方法,registerPostProcessor方法内部就是注册Bean,当然这里注册其他Bean也是一样的流程。
在debug中,我们可以看到在BeanDefinitionMap中已经注册了五个对象,这些postProcessor就是spring中非常重要的内置类。比如:ConfigurationClassPostProcessor,用于解析我们配置类;AutowiredAnnotationBeanPostProcessor,用于解析@Autowire注解,这些将在后面详细分析。
4.创建BeanDefinition扫描器:ClassPathBeanDefinitionScanner
由于常规使用方式是不会用到AnnotationConfigApplicationContext里面的scanner的,这里的scanner 仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法。所以这里就不看 scanner是如何被实例化的了。
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.scan();
5.注册配置类为BeanDefinition:register(annotatedClasses)
我们在回到最开始,我们分析下register(annotatedClasses)方法,其主要作用就是将配置类注册成bean定义。
@Override
public void register(Class<?>... componentClasses) {
Assert.notEmpty(componentClasses, "At least one component class must be specified");
this.reader.register(componentClasses);
}
public void register(Class<?>... componentClasses) {
//配置类可以传入多个,所以要进行遍历注册,这里的componentClass就是配置类的class类型
for (Class<?> componentClass : componentClasses) {
registerBean(componentClass);
}
}
<T> void doRegisterBean(Class<T> beanClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
//beanClass:指的是存储@Configration注解注释的类,即将配置类封装成bean定义
//把传入的标记了注解的类转为AnnotatedGenericBeanDefinition数据结构,里面有一个getMetadata方法,可以拿到类上的注解
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
//判断是否需要跳过注解,spring中有一个@Condition注解,当不满足条件,这个bean就会跳过
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(instanceSupplier);
//解析bean的作用域,如果没有配置的话,默认是单例
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
//解析通用注解,填充到AnnotatedGenericBeanDefinition,解析的注解为Lazy,Primary,DependsOn,Role,Description
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
/**
* 限定符处理,不是特指@Qualifier注解,也有可能是Primary,或者是Lazy,或者是其他(理论上是任何注解,这里没有判 断注解的有效性),
* 如果我们在外面,以类似这种AnnotationConfigApplicationContext annotationConfigApplicationContext =
* new AnnotationConfigApplicationContext(Appconfig.class)常规方式去初始化spring,qualifiers永远都是空的,
* 包括上面的name和instanceSupplier都是同样的道理,但是spring提供了其他方式去注册bean,就可能会传入了
*/
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);
}
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
//注册,最终会调用DefaultListableBeanFactory中的registerBeanDefinition方法注册
//DefaultListableBeanFactory会维护一系列的信息,比如beanDefinitionNames、beanDefinitionMap
//beanDefinitionNames是一个List<String>,用于保存beanName
//beanDefinitionMap.put(beanName, beanDefinition)
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
执行完此方法后可以看到,配置类的bean定义已经注册到beanDefinitionMap中。
6. refresh()
其实到这里,Spring还没有进行扫描,只是实例化了一个工厂,注册了一些内置的Bean和我们传进去的配置类,最重要的处理过程就是在refresh方法中完成的。
invokeBeanFactoryPostProcessors
finishBeanFactoryInitialization
扩展点:
BeanDefinition介绍:
类结构图(向上):
BeanMetadataElement接口:BeanDefinition元数据,返回该Bean的来源
AttributeAccessor接口:提供对BeanDefinition属性操作能力
类结构图(向下):