- 一、基本组件结构介绍
- 二、注解方式IOC容器加载源码解析
- 1、注解方法启动类
- 2、AnnotationConfigApplicationContext 的构造方法
- 2.1、创建bean工厂-beanFactory
- 2.1.1、注册默认后置处理器
- 2.1.2、自定义扫描包功能
- 2.2、注册配置类（Config.class）
- 2.3、容器刷新
- 2.3.1、prepareRefresh();刷新前预处理
- 2.3.2、obtainFreshBeanFactory();获取最新的bean工厂（beanFactory）
- 2.3.3、prepareBeanFactory(beanFactory);注册bean工厂的类加载器和部分后置处理器
- 2.3.4、postProcessBeanFactory(beanFactory);bean工厂的后置处理器（子类实现）
- 2.3.5、invokeBeanFactoryPostProcessors(beanFactory);执行bean工厂的后置处理器
- 2.3.6、registerBeanPostProcessors(beanFactory);实例化并注册所有后置处理器
- 2.3.7、initMessageSource();初始化MessageSource组件
- 2.3.8、initApplicationEventMulticaster();初始化事件多播器（用来广播事件）
- 2.3.9、onRefresh();扩展方法，空实现
- 2.3.10、registerListeners();注册监听器
- 2.3.11、finishBeanFactoryInitialization(beanFactory);实例化所有剩余的（非惰性）单例bean
- 2.3.12、finishRefresh();最后一步：发布相应的事件
- 2.3.12.1、初始化生命周期处理器
- 使用监听器
- 1、注册事件
- 2、注册监听器
- 3、发布事件
- 4、使用
- 2.3.13、异常情况
- 2.3.13.1、destroyBeans();销毁单例bean
- 2.3.13.2、cancelRefresh(ex);设置容器激活状态为否
- 三、bean的加载源码解析
- 1、完成bean工厂的初始化
- 2、实例化所有剩余（非懒加载）单例对象
- 2.1、getMergedLocalBeanDefinition(beanName);获取合并bean定义信息
- 2.2、getSingleton()获取单例bean
- 3、getBean(beanName);获取bean对象
- xxxPostProcessor：后置处理器（各种组件可以bean实例化前后、初始化前后自定义执行操作）
- xxxAware：可以将spring容器中对应的对象注入进来
- xxxRegistry：对bean或beanDefinition的注册（添加、删除、是否存在等）
配置类
@ComponentScan("com.xc.lifecycle.entity")
@Configuration
public class Config {
@Bean()
public Book book(){
return new Book();
}
}
启动类
public class Client {
public static void main(String[] args) {
//创建注解容器，入参为配置类
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
//获取某个bean
Book book = context.getBean("book", Book.class);
System.out.println(book);
//关闭容器
context.close();
}
}
2、AnnotationConfigApplicationContext 的构造方法
2.1、创建bean工厂-beanFactory
this()；调用AnnotationConfigApplicationContext 的无参构造方法
调用当前类的无参构造，还会调用父类的无参构造，先看下父类无参构造做的事情。
接下来继续查看AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner的创建
调用AnnotatedBeanDefinitionReader的有参构造方法
注册默认后置处理器
public static SetregisterAnnotationConfigProcessors( BeanDefinitionRegistry registry, @Nullable Object source) { //获取之前创建好的DefaultListableBeanFactory对象，beanFactory实例 DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry); //为beanFactory添加两属性 if (beanFactory != null) { if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) { beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE); } if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) { beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver()); } } //创建8长度集合 Set beanDefs = new linkedHashSet<>(8); //查询beanDefinitionMap是否有 //internalConfigurationAnnotationProcessor =ConfigurationClassPostProcessor //（内部注解配置后置处理器） if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class); def.setSource(source); //注册到beanDefinitionMap中，并添加到beanDefs集合中 beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)); } //注册internalAutowiredAnnotationProcessor = 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)); } // JSR-250，是java定义的一些注解，spring支持这注解。大致有：@PostConstruct@PreDestroy@Resource //注册internalCommonAnnotationProcessor = 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)); } // spring注册支持jpa注解的beanFactory后置处理器 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)); } //注册事件监听后置处理器 //internalEventListenerProcessor = 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)); } //注册事件监听工厂 //internalEventListenerFactory = 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; }
查看一共注册的beanDefinition
1. internalConfigurationAnnotationProcessor = ConfigurationClassPostProcessor 注解配置后置处理器
2. internalAutowiredAnnotationProcessor = AutowiredAnnotationBeanPostProcessor @Autowired注解后置处理器
3. internalCommonAnnotationProcessor = CommonAnnotationBeanPostProcessor java注解@Resource等注解后置处理器
4. internalEventListenerProcessor = EventListenerMethodProcessor 事件监听后置处理器
5. internalEventListenerFactory = DefaultEventListenerFactory 事件监听工厂
查看ClassPathBeanDefinitionScanner的构造函数
没太大用，主要为了扩展AnnotationConfigApplicationContext添加一个自助扫描的包的功能；一般用不到
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
context.scan("com.xc.lifecycle.pojo");
2.2、注册配置类（Config.class）
register(componentClasses);
bean的注册：AnnotationConfigApplicationContext registry.registerBeanDefinition(…)
将bean添加到beanDefinitionMap中，若有别名，再用别名添加一个相同的对象
至此，配置类注册到beanDefinitionMap中了。
准备此上下文以进行刷新，设置其启动日期和活动标志，以及执行属性源的任何初始化。
protected void prepareRefresh() {
//设置启动时间
this.startupDate = System.currentTimeMillis();
//容器是否关闭
this.closed.set(false);
//容器是否激活
this.active.set(true);
//根据日志开启级别打印日志
if (logger.isDebugEnabled()) {
if (logger.isTraceEnabled()) {
logger.trace("Refreshing " + this);
}
else {
logger.debug("Refreshing " + getDisplayName());
}
}
// 空实现，子类实现。AnnotationConfigApplicationContext容器的子容器初始化工作。
initPropertySources();
//校验必须的一些属性
getEnvironment().validateRequiredProperties();
// 保存容器预处理的事件
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new linkedHashSet<>(this.applicationListeners);
}
else {
// Reset local application listeners to pre-refresh state.
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
// 设置早期事件（以前的事件）
// 将在Multicast可用后发布
this.earlyApplicationEvents = new linkedHashSet<>();
}
2.3.2、obtainFreshBeanFactory();获取最新的bean工厂（beanFactory）
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 设置类加载器：存在则直接设置/不存在则新建一个默认类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 设置EL表达式解析器（Bean初始化完成后填充属性时会用到）
beanFactory.setBeanexpressionResolver(new StandardBeanexpressionResolver(beanFactory.getBeanClassLoader()));
// 设置属性注册解析器PropertyEditor
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 将当前的ApplicationContext对象交给ApplicationContextAwareProcessor类来处理，
// 从而在Aware接口实现类中的注入context
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//跳过以下6个属性的自动注入
//因为在ApplicationContextAwareProcessor中已经完成了手动注入
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 注册监听后置处理器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 添加编译时AspectJ的支持
// 当容器检查到定义了名称为loadTimeWeaver的bean时
// 会注册一个LoadTimeWeaverAwareProcessor到容器中
// 这个后置处理器用来处理LoadTimeWeaverAware接口的
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 注册当前容器环境environment组件Bean
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
// 注册系统配置systemProperties组件Bean
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
// 注册系统环境systemEnvironment组件Bean
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
2.3.4、postProcessBeanFactory(beanFactory);bean工厂的后置处理器（子类实现）
空实现
AbstractApplicationContext抽象类子类去实现。
查看子类：
getBeanFactoryPostProcessors()：返回bean工厂后置处理器列表，这里是个空集合
- BeanFactoryPostProcessor（bean工厂后置处理器）通过postProcessBeanFactory()对bean工厂做一些操作
- BeanFactoryPostProcessor子类BeanDefinitionRegistryPostProcessor（bean定义后置处理器），多定义了一个方法postProcessBeanDefinitionRegistry()对BeanDefinaition做一些增删改操作（故此子类优先执行）
- 这些操作都在实例化前，实例化后就没有意义了
接下来回归正题，进入invokeBeanFactoryPostProcessors()方法，执行所有bean公共后置处理器
public static void invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, ListbeanFactoryPostProcessors) { // 执行beans集合 Set processedBeans = new HashSet<>(); //如果有BeanDefinitionRegistryPostProcessors-bean定义后置处理器，先执行。 //（后执行BeanFactoryPostProcessor-bean工厂后置处理器） if (beanFactory instanceof BeanDefinitionRegistry) { BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; // 用于存放入参bean定义后置处理器集合 List regularPostProcessors = new ArrayList<>(); // 用于存放bean定义后置处理器集合 List registryProcessors = new ArrayList<>(); //这里处理入参的bean定义后置处理器，入参的数据是自定义传入的，不怎么用，这里不说了 for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor; registryProcessor.postProcessBeanDefinitionRegistry(registry); registryProcessors.add(registryProcessor); } else { regularPostProcessors.add(postProcessor); } } // 用于保存本次要执行的bean定义后置处理器（当前bean定义后置处理器） List currentRegistryProcessors = new ArrayList<>(); // 首先，先执行实现了PriorityOrdered的bean定义后置处理器 // 找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { // 校验是否实现了PriorityOrdered接口 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { // 获取ppName对应的bean实例, 添加到currentRegistryProcessors中 // beanFactory.getBean();获取bean，获取不到创建。后续单独将 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); //将要被执行的加入processedBeans，避免后续重复执行 processedBeans.add(ppName); } } //进行排序(之前注册默认处理器时候，添加过排序策略属性 ) // beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE); sortPostProcessors(currentRegistryProcessors, beanFactory); // 添加到bean定义后置处理器 registryProcessors.addAll(currentRegistryProcessors); // 将所有bean定义后置处理器遍历执行它的方法 postProcessBeanDefinitionRegistry() // --对beanBefinition的增删改 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); // 执行完毕后, 清空currentRegistryProcessors currentRegistryProcessors.clear(); // 接下来，先执行实现了Ordered的bean定义后置处理器 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { // 校验是否实现了Ordered接口，并且还未执行过 if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) { currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); } } sortPostProcessors(currentRegistryProcessors, beanFactory); registryProcessors.addAll(currentRegistryProcessors); invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); currentRegistryProcessors.clear(); // 最后，执行剩下的bean定义后置处理器，什么排序接口都没有实现 boolean reiterate = true; while (reiterate) { reiterate = false; postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { // 跳过已经执行过的 if (!processedBeans.contains(ppName)) { currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); // 如果有bean定义后置处理器被执行, 则有可能会产生新的bean定义后置处理器 // 因此这边将reiterate赋值为true, 代表需要再循环查找一次 reiterate = true; } } sortPostProcessors(currentRegistryProcessors, beanFactory); registryProcessors.addAll(currentRegistryProcessors); invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); currentRegistryProcessors.clear(); } // 现在统一执行bean定义后置处理器的postProcessBeanFactory方法 //(BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor) invokeBeanFactoryPostProcessors(registryProcessors, beanFactory); // 现在统一执行入参bean定义后置处理器的postProcessBeanFactory方法 invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory); } else { // 如果没有bean定义后置处理器，直接执行参数传入的bean定义后置处理器 invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory); } // 到这里 , 入参beanFactoryPostProcessors和容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕, // 下面开始处理容器中的所有BeanFactoryPostProcessor String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false); ...与上面代码一模一样，下面总集说 }
总结：
- 先遍历执行所有bean定义后置处理器，再执行bean工厂后置处理器
- 后置处理器根据是否实现PriorityOrdered、Ordered接口和order值来排序决定先后执行
- 每次执行，检查跳过之前执行过的后置处理器
处理流程方面和bean工厂后置处理器大致一样
// 实例化所有的BeanPostProcessor并将其注册到BeanFactory中
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 获取beanFactory中所有的BeanPostProcessor类型的bean的名字,此处为空
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// 当BeanPostProcessor实例化过程中有bean被创建,则注册一个BeanPostProcessorChecker记录信息
// 也就是说一个bean没有资格被所有的BeanPostProcessor处理
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 对所有的BeanPostProcessor根据实现不同的接口(PriorityOrdered,Ordered等)进行分离
// 用于存放实现了PriorityOrdered.class的后处理器集合
List priorityOrderedPostProcessors = new ArrayList<>();
// 用于存放实现了PriorityOrdered.class并且是MergedBeanDefinitionPostProcessor类型的后处理器集合
List internalPostProcessors = new ArrayList<>();
// 用于存放实现了Ordered.class的后处理器集合
List orderedPostProcessorNames = new ArrayList<>();
// 用于存放其它情况的后处理器集合
List nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 首先,注册实现了ProorityOrdered.class接口的BeanPostProcessor
// 排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 注册(将BeanPostProcessor加入到BeanFactory中beanFactory.addBeanPostProcessor(postProcessor))
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 其次注册实现了Ordered.class接口的BeanPostProcessor
List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 然后,注册剩余的所有普通的BeanPostProcessor
List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 最后,重新注册所有内部的BeanPostProcessor
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
//先删除再注册ApplicationListenerDetector（主要是为了移动到处理器链的末尾）
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
2.3.7、initMessageSource();初始化MessageSource组件
可以做国际化功能，已经注入bean工厂。MESSAGE_SOURCE_BEAN_NAME = messageSource；
留给子容器或者AbstractApplicationContext子类重写这个方法，在容器刷新的时候可以自定义逻辑；
protected void registerListeners() {
// 添加实现ApplicationListener作为侦听器的bean。
// 不会影响其他侦听器，可以将它们添加为非bean。
// 先注册静态指定的监听器
for (ApplicationListener listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// 在事件多播器上添加监听 并没有执行
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// 发布早期的时间,并且将 earlyApplicationEvents 设置为空
Set earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
2.3.11、finishBeanFactoryInitialization(beanFactory);实例化所有剩余的（非惰性）单例bean
第三章节单讲
2.3.12、finishRefresh();最后一步：发布相应的事件protected void finishRefresh() {
// 清理缓存信息
clearResourceCaches();
// 初始化生命周期处理器
initLifecycleProcessor();
// 将刷新事件传播到生命周期处理器
getLifecycleProcessor().onRefresh();
// 发布容器刷新完毕事件到相应的监听器
publishEvent(new ContextRefreshedEvent(this));
// 略
LiveBeansView.registerApplicationContext(this);
}
2.3.12.1、初始化生命周期处理器
Bean对象可以实现Lifecycle接口，以便这些Bean可以在容器自身的生命周期驱动下进行start和stop过程。
public class MyApplicationEvent extends ApplicationEvent {
private static final long serialVersionUID = 5366526231219883438L;
private String message;
public MyApplicationEvent(Object source, String message) {
super(source);
this.message = message;
}
public String getMessage() {
return message;
}
}
2、注册监听器
@Component public class MyApplicationListener implements ApplicationListener3、发布事件{ @Override public void onApplicationEvent(MyApplicationEvent event) { System.out.println("MyApplicationListener 收到消息: " + event.getMessage()); } }
@Component
public class MyAnnotationApplicationListener {
@EventListener(classes = MyApplicationEvent.class)
public void myApplicationEventListener(MyApplicationEvent event) {
System.out.println("使用注解的方式, 收到事件: " + event.getMessage());
}
}
4、使用
因为 AnnotationConfigApplicationContext 实现了 ApplicationContext ， 而 ApplicationContext 实现了 ApplicationEventPublisher，所以这块可以传入当前 context。
public class Client {
public static void main(String[] args) {
//创建注解容器，入参为配置类
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
MyApplicationEvent event = new MyApplicationEvent(context,"呼叫。。。");
context.publishEvent(event);
//关闭容器
context.close();
}
}
输出：
finishBeanFactoryInitialization(beanFactory);实例化所有剩余的（非惰性）单例bean
1、完成bean工厂的初始化protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 初始化此上下文的转换服务
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// 如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：主要用于注解属性值的解析。
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 初始化所有LoadTimeWeaverAware Bean实例对象
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
beanFactory.setTempClassLoader(null);
// 冻结所有bean定义，注册的bean定义不会被修改或进一步后处理，因为马上要创建 Bean 实例对象了
beanFactory.freezeConfiguration();
// 实例化所有剩余（非懒加载）单例对象
beanFactory.preInstantiateSingletons();
}
2、实例化所有剩余（非懒加载）单例对象
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// 创建beanDefinitionNames的副本beanNames用于后续的遍历，以允许init等方法注册新的bean定义
List beanNames = new ArrayList<>(this.beanDefinitionNames);
// 所有非懒加载单例bean的初始化
for (String beanName : beanNames) {
// 获取合并后的bean定义信息
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// bean定义对应的Bean实例：不是抽象类 && 是单例 && 不是懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 判断beanName对应的bean是否为FactoryBean
if (isFactoryBean(beanName)) {
// 通过getBean(&beanName)拿到的是FactoryBean本身；
// 通过getBean(beanName)拿到的是FactoryBean创建的Bean实例
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
// 判断bean是否实现了FactoryBean
if (bean instanceof FactoryBean) {
final FactoryBean factory = (FactoryBean) bean;
//判断这个FactoryBean是否希望急切的初始化
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction)
((SmartFactoryBean) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean) factory).isEagerInit());
}
if (isEagerInit) {
// 如果希望急切的初始化，则通过beanName获取bean实例
getBean(beanName);
}
}
}
else {
// 如果beanName对应的bean不是FactoryBean，只是普通Bean，通过beanName获取bean实例
getBean(beanName);
}
}
}
// 在所有bean实例化后，遍历所有beanName
// 触发所有SmartInitializingSingleton实例化后后置处理器方法afterSingletonsInstantiated();
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction
2.1、getMergedLocalBeanDefinition(beanName);获取合并bean定义信息
protected RootBeanDefinition getMergedBeanDefinition(
String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
throws BeanDefinitionStoreException {
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
// 这里containingBd=null，所有，先从合并bean定义信息中获取
if (containingBd == null) {
mbd = this.mergedBeanDefinitions.get(beanName);
}
//获取不到
if (mbd == null) {
// 如果bd的parentName为空，代表bd没有父定义，无需与父定义进行合并操作，
// 如果是RootBeanDefinition，则克隆一个；如果不是则new一个
if (bd.getParentName() == null) {
// Use copy of given root bean definition.
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
mbd = new RootBeanDefinition(bd);
}
}
else {
// 存在父定义，需要与父定义合并
BeanDefinition pbd;
try {
// 获取父定义的beanName,可能是别名
String parentBeanName = transformedBeanName(bd.getParentName());
// 如果父定义的beanName与该bean的beanName不同
if (!beanName.equals(parentBeanName)) {
// 获取父定义的MergedBeanDefinition（因为父定义也可能有父定义，也就是bd的爷爷定义...）
// 递归调用获取合并bean定义信息
pbd = getMergedBeanDefinition(parentBeanName);
}
else {
// 如果父定义的beanName与bd的beanName相同
// 只有在存在父BeanFactory的情况下，才允许父定义beanName与自己相同，否则就是将自己设置为父定义
BeanFactory parent = getParentBeanFactory();
if (parent instanceof ConfigurableBeanFactory) {
// 如果父BeanFactory是ConfigurableBeanFactory，
// 则通过父BeanFactory获取父定义的MergedBeanDefinition
pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
}
else {
throw new NoSuchBeanDefinitionException(parentBeanName,
"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
"': cannot be resolved without an AbstractBeanFactory parent");
}
}
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
}
// 使用父定义pbd构建一个新的RootBeanDefinition对象
mbd = new RootBeanDefinition(pbd);
// 使用bd覆盖父定义
mbd.overrideFrom(bd);
}
// 如果没有配置scope，则设置成默认的singleton
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
}
// 这里 containingBd 为空
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
// 将beanName与mbd放到mergedBeanDefinitions缓存，以便之后可以直接使用
if (containingBd == null && isCacheBeanmetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
return mbd;
}
}
举个例子
2.2、getSingleton()获取单例bean两个bean，childBean和rootBean，childBean的父bean是rootBean。和继承有点像，子类如果没有赋值某个属性，会继承父类的，比如这里的name=张三。
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//从单例对象缓存中获取beanName对应的单例对象
Object singletonObject = this.singletonObjects.get(beanName);
//如果单例对象缓存中没有，并且该beanName对应的单例bean正在创建中
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从早期单例对象缓存中获取单例对象（之所称成为早期单例对象，是因为earlySingletonObjects里
// 的对象的都是通过提前曝光的ObjectFactory创建出来的，还未进行属性填充等操作）
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果在早期单例对象缓存中也没有，并且允许创建早期单例对象引用
if (singletonObject == null && allowEarlyReference) {
// 从单例工厂缓存中获取beanName的单例工厂
ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 如果存在单例对象工厂，则通过工厂创建一个单例对象
singletonObject = singletonFactory.getObject();
// 将通过单例对象工厂创建的单例对象，放到早期单例对象缓存中
this.earlySingletonObjects.put(beanName, singletonObject);
// 移除该beanName对应的单例对象工厂，
// 因为该单例工厂已经创建了一个实例对象，并且放到earlySingletonObjects缓存了
// 所以，后续获取beanName的单例对象，
// 可以通过earlySingletonObjects缓存拿到，不需要在用到该单例工厂
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject; //返回对象
}
该段代码是 Spring 解决循环引用的核心代码
解决循环引用逻辑：使用构造函数创建一个 “不完整” 的 bean 实例（之所以说不完整，是因为此时该 bean 实例还未初始化），并且提前曝光该 bean 实例的 ObjectFactory（提前曝光就是将 ObjectFactory 放到 singletonFactories 缓存），通过 ObjectFactory 我们可以拿到该 bean 实例的引用，如果出现循环引用，我们可以通过缓存中的 ObjectFactory 来拿到 bean 实例，从而避免出现循环引用导致的死循环。这边通过缓存中的 ObjectFactory 拿到的 bean 实例虽然拿到的是 “不完整” 的 bean 实例，但是由于是单例，所以后续初始化完成后，该 bean 实例的引用地址并不会变，所以最终我们看到的还是完整 bean 实例。
另外引入4个重要缓存：
- singletonObjects 缓存：beanName -> 单例 bean 对象。
- earlySingletonObjects 缓存：beanName -> 单例 bean 对象，该缓存存放的是早期单例 bean 对象，可以理解成还未进行属性填充、初始化。
- singletonFactories 缓存：beanName -> ObjectFactory。
- singletonsCurrentlyInCreation 缓存：当前正在创建单例 bean 对象的 beanName 集合。
protectedT doGetBean(final String name, @Nullable final Class requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { //解析beanName，主要是解析别名、去掉FactoryBean的前缀“&” final String beanName = transformedBeanName(name); Object bean; // 从缓存中获取beanName对应的实例 Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { // 如果beanName的实例存在于缓存中 if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } // 返回beanName对应的实例对象（主要用于FactoryBean的特殊处理，普通Bean会直接返回sharedInstance本身） bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // 4.scope为prototype的循环依赖校验：如果beanName已经正在创建Bean实例中， // 而此时我们又要再一次创建beanName的实例，则代表出现了循环依赖，需要抛出异常。 // 例子：如果存在A中有B的属性，B中有A的属性，那么当依赖注入的时候， // 就会产生当A还未创建完的时候因为对于B的创建再次返回创建A，造成循环依赖 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // 获取parentBeanFactory（父容器) BeanFactory parentBeanFactory = getParentBeanFactory(); //如果parentBeanFactory存在，并且beanName在当前BeanFactory不存在Bean定义， //则尝试从parentBeanFactory中获取bean实例 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } // 尝试在parentBeanFactory中获取bean对象实例 else if (args != null) { return (T) parentBeanFactory.getBean(nameToLookup, args); } else if (requiredType != null) { return parentBeanFactory.getBean(nameToLookup, requiredType); } else { return (T) parentBeanFactory.getBean(nameToLookup); } } if (!typeCheckOnly) { // 如果不是仅仅做类型检测，而是创建bean实例， // 这里要将beanName放到alreadyCreated缓存,做记录 markBeanAsCreated(beanName); } try { //将bean和父bean合并 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); //检查MergedBeanDefinition checkMergedBeanDefinition(mbd, beanName, args); // 拿到当前bean依赖的bean名称集合，在实例化自己之前，需要先实例化自己依赖的bean String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { //遍历当前bean依赖的bean名称集合 for (String dep : dependsOn) { //3.2、检查dep是否依赖于beanName，即检查是否存在循环依赖 if (isDependent(beanName, dep)) { //如果是循环依赖则抛异常 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } //3.3、将dep和beanName的依赖关系注册到缓存中 registerDependentBean(dep, beanName); try { //获取dep对应的bean实例，如果dep还没有创建bean实例，则创建dep的bean实例 getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } // 针对不同的scope进行bean的创建 if (mbd.isSingleton()) { //3.4、单例bean创建（新建了一个ObjectFactory，并且重写了getObject方法） sharedInstance = getSingleton(beanName, () -> { try { //3.5、创建Bean实例 return createBean(beanName, mbd, args); } catch (BeansException ex) { // Explicitly remove instance from singleton cache: It might have been put there // eagerly by the creation process, to allow for circular reference resolution. // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName); throw ex; } }); // 3.6、返回beanName对应的实例对象 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { // 多例的bean创建 Object prototypeInstance = null; try { // 创建实例前的操作（将beanName保存到prototypesCurrentlyInCreation缓存中） beforePrototypeCreation(beanName); // 创建Bean实例 prototypeInstance = createBean(beanName, mbd, args); } finally { //创建实例后的操作（将创建完的beanName从prototypesCurrentlyInCreation缓存中移除） afterPrototypeCreation(beanName); } //beanName对应的实例对象 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { // 其他scope的bean创建，可能是request之类的 // 根据scopeName，从缓存拿到scope实例 String scopeName = mbd.getScope(); final Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { //其他scope的bean创建（新建了一个ObjectFactory，并且重写了getObject方法） Object scopedInstance = scope.get(beanName, () -> { beforePrototypeCreation(beanName); try { return createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } }); bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException ex) { throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider " + "defining a scoped proxy for this bean if you intend to refer to it from a singleton", ex); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } } // 检查所需类型是否与实际的bean对象的类型匹配 if (requiredType != null && !requiredType.isInstance(bean)) { try { // 类型不对，则尝试转换bean类型 T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType); if (convertedBean == null) { throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } return convertedBean; } catch (TypeMismatchException ex) { if (logger.isTraceEnabled()) { logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex); } throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } } return (T) bean; }
…未完待续
