Spring框架中最重要的两个部分就是IOC与AOP，接下来咱们就从源码的角度来摸索以下spring容器是怎么样创建的。下面的分析是基于注解的，没有写xml配置文件。
1、根据配置类构造容器
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
首先我们先传入配置类，AnnotationConfigApplicationContext会调用下面这个构造方法
/**
*它要做的事情就是根据给定的扫描包得到Bean的定义，然后自动刷新容器
*主要的要做事情在于refresh()方法里面
*/
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh();
}
2、主要方法refresh()探索
咱们进入到refresh()方法里面看看执行了哪些操作，可以粗略看这一段代码就好，详细分析在后面。
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
首先我们分析
prepareRefresh()方法，它是容器刷新前的预处理protected void prepareRefresh() { //这里记录下容器启动时间，设置容器启动状态为true,关闭状态为false this.startupDate = System.currentTimeMillis(); this.closed.set(false); this.active.set(true); if (logger.isInfoEnabled()) { logger.info("Refreshing " + this); } //初始化一些属性设置,留给子类实现，子类自定义个性化的属性设置方法； initPropertySources(); //检验容器属性的合法性 getEnvironment().validateRequiredProperties(); //保存容器的一些早期事件 this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>(); }
接下来是
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()方法,这里是为了获取一个BeanFactory，请看代码protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { refreshBeanFactory(); /* 这里执行的逻辑就是刷新，或者说为容器创建BeanFactory,到最后创建一个默认工厂 this.beanFactory = new DefaultListableBeanFactory()，并且为它设置ID */ ConfigurableListableBeanFactory beanFactory = getBeanFactory(); /* 这里就是获取上一步创建出来的BeanFactory */ if (logger.isDebugEnabled()) { logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory); } return beanFactory; //返回创建好的BeanFactory }
这里可以说说
BeanFactory有什么作用，简单说，就是根据BeanDefination来创建Bean.接下来是prepareBeanFactory(beanFactory)方法，我们要对创建出来的BeanFactory进行一些设置了，代码有点长但还不算复杂，挑重点看吧。protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { // Tell the internal bean factory to use the context's class loader etc. beanFactory.setBeanClassLoader(getClassLoader()); beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); //为beanFactory设置类加载器、表达式解析器等 // Configure the bean factory with context callbacks. beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); //添加一些后置处理器，后置处理器在bean构造前后执行，是对bean的增强 beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); //设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx； // BeanFactory interface not registered as resolvable type in a plain factory. // MessageSource registered (and found for autowiring) as a bean. beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class, this); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); beanFactory.registerResolvableDependency(ApplicationContext.class, this); //注册可以解析的自动装配；我们能直接在任何组件中自动注入： // BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext // Register early post-processor for detecting inner beans as ApplicationListeners. beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); //又是再添加后置处理器 // Detect a LoadTimeWeaver and prepare for weaving, if found. if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); // Set a temporary ClassLoader for type matching. beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } //这一段逻辑不太懂先过，也不是特别重要的，先放过它 // Registerx default environment beans. //以单例模式先在BeanFactory注册用的到组件，environment、systemProperties、systemEnvironment //总的来说这个方法就是为beanFactory进行配置，添加组件，打扮它，让它在后面更好地创建主角--bean if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); } if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); } if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment()); } }
接下来这个方法就轻松点了，
postProcessBeanFactory(beanFactory),BeanFactory准备工作完成后进行的后置处理工作，也是一种后置处理器，面向BeanFactory的，它是子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置。子类对BeanFactory还有什么设置可以重写这个方法来实现。
接下来这个方法有点长，内容太多了就不贴代码了，自行看源码吧，这里就用文字简述下流程。
BeanFactoryPostProcessor：BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的。
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());首先进去后第一个执行的是上面的方法，可以看出参数是beanFactory，getBeanFactoryPostProcessors()，字面上理解是得到beanFactory的所有BeanFactoryPostProcessors并且执行。我们再进去看看。
里面有两个很重要的东西，两个接口：
BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor,再重新讲讲这两个东东是啥西西吧
BeanFactoryPostProcessor：beanFactory的后置处理器，在BeanFactory标准初始化之后调用，来定制和修改BeanFactory的内容，此时所有的bean定义已经保存加载到beanFactory，但是bean的实例还未创建``BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor
，在所有bean定义信息将要被加载，bean实例还未创建的，优先于BeanFactoryPostProcessor执行，利用BeanDefinitionRegistryPostProcessor`可以给容器中再额外添加一些组件；上面说到了
BeanDefinitionRegistryPostProcessor优先于BeanFactoryPostProcessor实行，从这里可以看出来，是先获取BeanDefinitionRegistryPostProcessor执行的1）、获取所有的BeanDefinitionRegistryPostProcessor； 2）、看先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor、 postProcessor.postProcessBeanDefinitionRegistry(registry) 3）、在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor； postProcessor.postProcessBeanDefinitionRegistry(registry) 4）、最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors； postProcessor.postProcessBeanDefinitionRegistry(registry) 再执行BeanFactoryPostProcessor的方法 1）、获取所有的BeanFactoryPostProcessor 2）、看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor、 postProcessor.postProcessBeanFactory() 3）、在执行实现了Ordered顺序接口的BeanFactoryPostProcessor； postProcessor.postProcessBeanFactory() 4）、最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor； postProcessor.postProcessBeanFactory()对于这个方法，其实要了解的是两个后置处理器的意义，等有时间再写篇文章介绍这些什么。好啦这个方法也就是得到一些东西，在beanFactory初始化做一些东西。
registerBeanPostProcessors(beanFactory),接下来我们就来注册BeanPostProcessor（Bean的后置处理器），拦截Bean的创建。不同接口类型的BeanPostProcessor,在Bean创建前后的执行时机是不一样的,BeanPostProcessor有许多种，BeanPostProcessor、DestructionAwareBeanPostProcessor、InstantiationAwareBeanPostProcessor、SmartInstantiationAwareBeanPostProcessor、MergedBeanDefinitionPostProcessor【internalPostProcessors】。1）、获取所有的 BeanPostProcessor;后置处理器都默认可以通过PriorityOrdered、Ordered接口来执行优先级 2）、先注册PriorityOrdered优先级接口的BeanPostProcessor； 把每一个BeanPostProcessor；添加到BeanFactory中beanFactory.addBeanPostProcessor(postProcessor); 3）、再注册Ordered接口的4）、最后注册没有实现任何优先级接口的 5）、最终注册MergedBeanDefinitionPostProcessor； 6）、注册一个ApplicationListenerDetector；来在Bean创建完成后检查是否是ApplicationListener，如果是 applicationContext.addApplicationListener((ApplicationListener<?>) bean);
写不出了，第一篇先这样吧，后面再继续介绍接下的流程。先归纳一点流程吧：
prepareRefresh();
obtainFreshBeanFactory();
prepareBeanFactory(beanFactory);
postProcessBeanFactory(beanFactory);
invokeBeanFactoryPostProcessors(beanFactory);
registerBeanPostProcessors(beanFactory);
- 首先是预处理刷新容器，对容器进行一些属性设置，比如环境，并且进行校验。
- 创建并且得到一个
BeanFactory,用来创建Bean - 接下来进行BeanFactory的预准备工作（BeanFactory进行一些设置）
- 子类通过重写``postProcessBeanFactory`来在BeanFactory创建并预准备完成以后做进一步的设置
- 执行``invokeBeanFactoryPostProcessors`，拦截BeanFactory的初始化，按照特定的顺序执行后置处理器
registerBeanPostProcessors注册BeanPostProcessor（Bean的后置处理器）
