Spring 容器启动时会创建IOC容器,在创建容器时,会调用 refresh()方法,整个容器就是通过该方法,完成所有的 bean 的创建以及初始化
protected void prepareRefresh() {
//记录时间
this.startupDate = System.currentTimeMillis();
//设置当前容器未关闭
this.closed.set(false);
//设置当前容器已激活
this.active.set(true);
if (this.logger.isInfoEnabled()) {
//打印容器刷新日志
this.logger.info("Refreshing " + this);
}
//初始化一下属性(该方法默认是空的,是提供给子类来实现的,
//假设我们有些工作需要在初始化bean以前就要加载设置等,可以通过重写这个方法来完成)
this.initPropertySources();
//校验设置的属性是否合法
this.getEnvironment().validateRequiredProperties();
//初始化一个集合属性,提供用来保存后面创建的事件,如果有事件发生会放入这个集合中
this.earlyApplicationEvents = new LinkedHashSet();
}
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//刷新bean工厂,创建一个 DefaultListableBeanFactory类型的 bean工厂
//赋值给 beanFactory 属性,对创建的这个 beanFactory 设置一个序列号
this.refreshBeanFactory();
//获取beanFactory,就上将上一步设置好序列号的的beanFactory返回回来
ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
//打印日志
if (this.logger.isDebugEnabled()) {
this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory);
}
//将创建好的 beanFactory 返回
return beanFactory;
}
就是上一步获取到的beanFactory是一个创建出来什么都没有的空工厂,此处进行设置
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
//设置类加载器
beanFactory.setBeanClassLoader(this.getClassLoader());
//设置表达式语言解析器....
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
//设置添加一个 tApplicationContextAwareProcessor 后置处理器
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//设置忽略的自动装配的接口,就是设置这些接口的实现类不能通过这些接口实现自动注入
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
//注册可以解析的自动装配,假设想要使用@Autowired 注解将Spring提供的 BeanFactory
//装配到自己,创建的某个类的属性上,就要在此处设置
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
//设置添加一个ApplicationListenerDetector后置处理器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
//添加编译时支持AspectJ
if (beanFactory.containsBean("loadTimeWeaver")) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
//向beanFactory中注册组件
if (!beanFactory.containsLocalBean("environment")) {
//注册了一个 Environment,该对象中存了一下我们默认的属性
beanFactory.registerSingleton("environment", this.getEnvironment());
}
if (!beanFactory.containsLocalBean("systemProperties")) {
//向beanFactory中注册了系统属性属性(一个Map集合)
beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean("systemEnvironment")) {
//向beanFactory中注册环境变量等相关信息(一个Map集合)
beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
}
}
该方法默认是空的,为子类通过的,假设后续开发中,在 beanFactory 创建并且有准备完成后需要执行某些操作,可以提供子类重写这个方法来实现
以上可以看为beanFactory 的创建及预准备工作==========================================
执行实现了 BeanFactoryPostProcessors 接口的beanFactory后置处理器中方法,也就是beanFactory初始化完成后要执行的方法
注意 beanFactory 后置处理器 BeanFactoryPostProcessor 与 BeanDefinitionRegistryPostProcessor的不同
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//执行beanFactory后置处理器中的方法,该方法中获取所有BeanFactoryPostProcessor,遍历判断
//对不同的BeanFactoryPostProcessor进行排序,因为先后执行的顺序不同,
//PriorityOrdered>BeanDefinitionRegistryPostProcessor>BeanFactoryPostProcessor
//然后执行后置处理器中定义的初始化 beanFactory 后要执行的方法
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
注意不同的 BeanPostProcessors,该接口下的子接口: 不同接口的执行时机不同
DestructionAwareBeanPostProcessor
InstantiationAwareBeanProcessor
SmartInstantiationAwareBeanPostProcessor
MergedBeanDefinitionPostProcessor
public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//根据类型获取 beanFactory 中所有的 BeanPostProcessor 名字
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
//添加了一个后置处理器,通过添加的这个后置处理器检查 前获取的这些后置处理器 BeanPostProcessorChecker 是一个内部类,继承了BeanPostProcessor接口
beanFactory.addBeanPostProcessor(new PostProcessorRegistrationDelegate.BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
//创建两个集合用来存放不同的BeanPostProcessor,通过这两个集合对不同的BeanPostProcessor 进行排序
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList();
List<BeanPostProcessor> internalPostProcessors = new ArrayList();
List<String> orderedPostProcessorNames = new ArrayList();
List<String> nonOrderedPostProcessorNames = new ArrayList();
String[] var8 = postProcessorNames;
int var9 = postProcessorNames.length;
String ppName;
BeanPostProcessor pp;
//遍历获取 BeanPostProcessor, 判断不同的 BeanPostProcessor 放入不同的集合中
//实现了 PriorityOrdered 的放入priorityOrderedPostProcessors集合中
//实现了PriorityOrdered 并且是MergedBeanDefinitionPostProcessor类型的放入internalPostProcessors
//实现了 Ordered 的放入 orderedPostProcessorNames 集合中
//否则放入 nonOrderedPostProcessorNames 集合中
for(int var10 = 0; var10 < var9; ++var10) {
ppName = var8[var10];
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
pp = (BeanPostProcessor)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);
}
}
//首先对 priorityOrderedPostProcessors 中的进行排序
sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
//注册,也就是创建BeanPostProcessor设置到beanFactory中
registerBeanPostProcessors(beanFactory, (List)priorityOrderedPostProcessors);
List<BeanPostProcessor> orderedPostProcessors = new ArrayList();
Iterator var14 = orderedPostProcessorNames.iterator();
//遍历orderedPostProcessorNames集合中的BeanPostProcessor 如果有
//MergedBeanDefinitionPostProcessor类型的,将这个类型的后置处理器放入internalPostProcessors集合
while(var14.hasNext()) {
String ppName = (String)var14.next();
BeanPostProcessor pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
//对orderedPostProcessors集合中的后置处理器排序
sortPostProcessors(beanFactory, orderedPostProcessors);
//注册
registerBeanPostProcessors(beanFactory, (List)orderedPostProcessors);
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList();
Iterator var17 = nonOrderedPostProcessorNames.iterator();
//继续排序,分类
while(var17.hasNext()) {
ppName = (String)var17.next();
pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
//注册nonOrderedPostProcessors集合中的后置处理器
registerBeanPostProcessors(beanFactory, (List)nonOrderedPostProcessors);
//对internalPostProcessors集合中的后置处理器进行排序
sortPostProcessors(beanFactory, internalPostProcessors);
//注册internalPostProcessors集合中的后置处理器
registerBeanPostProcessors(beanFactory, (List)internalPostProcessors);
//又添加了一个后置处理器ApplicationListenerDetector,
//该后置处理器用来判断是否是某个监听器,如果是添加到容器中
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
在 SpringMVC 中用来做国际化功能,消息解析,消息绑定,MessageSource中有getMessage()方法,一般用来取出国际化配置文件中的key的值,能按照区域信息去获取
protected void initMessageSource() {
//获取beanFactory
ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
//判断beanFactory中是否有一个id为"messageSource" 的 bean
if (beanFactory.containsLocalBean("messageSource")) {
//如果有通过id获取这个bean,赋值给 messageSource 属性
this.messageSource = (MessageSource)beanFactory.getBean("messageSource", MessageSource.class);
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource)this.messageSource;
if (hms.getParentMessageSource() == null) {
hms.setParentMessageSource(this.getInternalParentMessageSource());
}
}
if (this.logger.isDebugEnabled()) {
this.logger.debug("Using MessageSource [" + this.messageSource + "]");
}
} else {
//如果没有创建一个MessageSource组件
DelegatingMessageSource dms = new DelegatingMessageSource();
//将这个组件注册到容器中(以后获取国际化配置文件的相关信息,可以通过@Autowired在Spring
//容器中直接获取装配到自己的类的属性上,然后调用MessageSource的方法)
dms.setParentMessageSource(this.getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton("messageSource", this.messageSource);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Unable to locate MessageSource with name 'messageSource': using default [" + this.messageSource + "]");
}
}
}
protected void initApplicationEventMulticaster() {
//获取beanFactory
ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
//1.获取beanFactory中id为"applicationEventMulticaster"的事件派发器
if (beanFactory.containsLocalBean("applicationEventMulticaster")) {
this.applicationEventMulticaster = (ApplicationEventMulticaster)beanFactory.getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
} else {
//如果没有创建一个 SimpleApplicationEventMulticaster 事件派发器,
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
//注册到 Spring 容器中
beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Unable to locate ApplicationEventMulticaster with name 'applicationEventMulticaster': using default [" + this.applicationEventMulticaster + "]");
}
}
}
可以提供子类重写这个方法,在容器刷新时,做些其它操作
protected void registerListeners() {
Iterator var1 = this.getApplicationListeners().iterator();
while(var1.hasNext()) {
ApplicationListener<?> listener = (ApplicationListener)var1.next();
this.getApplicationEventMulticaster().addApplicationListener(listener);
}
//在容器中拿到所有的监听器的名字
String[] listenerBeanNames = this.getBeanNamesForType(ApplicationListener.class, true, false);
String[] var7 = listenerBeanNames;
int var3 = listenerBeanNames.length;
//遍历,将每个监听器添加到事件派发器中
for(int var4 = 0; var4 < var3; ++var4) {
String listenerBeanName = var7[var4];
this.getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
//获取早期设置的事件(派发之前的事件)
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
//如果有
if (earlyEventsToProcess != null) {
Iterator var9 = earlyEventsToProcess.iterator();
while(var9.hasNext()) {
ApplicationEvent earlyEvent = (ApplicationEvent)var9.next();
//将早期的事件派发出去
this.getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
具体查看 Spring Bean 初始化与销毁通
protected void finishRefresh() {
//初始化跟生命周期有关的后置处理器,在容器中获取LifecycleProcessor
//类型的后置处理器接口,在容器刷新完成以及关闭时执行的方法,此处是注册
//如果没有会注册一个默认的生命周期组件
this.initLifecycleProcessor();
//拿到生命周期处理器,回调onRefresh()容器刷新完成方法,
this.getLifecycleProcessor().onRefresh();
//发布容器刷新完成事件
this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));
LiveBeansView.registerApplicationContext(this);
}