您的位置：首页 > 编程语言 > Java开发

Spring源码阅读（一）：IOC容器的初始化

2015-03-17 09:21 671 查看

        一直想研究下当下流行的开源框架的代码，最近年初终于得空了看了下Spring Framework的部分源代码。Spring最核心的功能是IOC容器，其他所有功能都是在此基础上做出的内部扩展，如aop、tx等。

        首先先从web工程下经常使用的ContextLoaderListener开始阅读，可以知道Spring bean的创建过程是context-> beanFactory->bean。

  1. 初始化context

    context的作用

      实现统一资源读取接口用于获取spring容器配置文件的内容。
    • 调用相关工具类读取spring配置文件解析成BeanDefinitionHolder并缓存起来。
    • 实现几个beanFactory接口使得我们获取到context后即可得到目标bean，这样简化了bean获取方法（不必再去获取beanFactory）。
    • 实现了应用事件发布器接口，用于在容器内发布相应的事件。

     

    contex相关t类结构图如下：



           web工程中加载spring容器时使用的容器上下文是XmlWebApplicationContext，还有其他非web工程经常使用的context实现类如ClassPathXmlApplicationContext、FileSystemXmlApplicationContext等都是通过xml文件来定义spring容器的。现在还可以完全通过注解的方式定义spring容器，其实现类为AnnotationConfigApplicationContext，定义spring容器的类需要使用@Configurable、@Bean注解来定义bean。在正式项目中通常还是使用xml+注解的方式，一般都会将aop、定时任务等的相关配置放在xml中，普通的spring bean则用@Service等注解进行定义，这样后续维护的人可以清楚的了解系统中有哪些隐秘执行的程序，不至于出现问题时毫无头绪。
           纯xml定义或者纯注解的方式都容易理解，但spring如何解析xml和注解同时存在的情况？这就是spring设计的强大之处，spring内部通过实现自己提供的扩展点来实现解析的。当在xml文件中加入了<context:annotation-config>或者<context:component-scan base-package="com.jj" />时，spring会向容器中默认加入ConfigurationClassPostProcessor、CommonAnnotationBeanPostProcessor、AutowiredAnnotationBeanPostProcessor等bean实例。在下面创建beanFactory和实例化bean的伪代码中可以找到其被调用的地方，大家可以通过查看其源码来理解spring具体的实现方法。

    context解析spring xml配置文件时需要使用BeanDefinationReader，其类图如下：



    为了更好的理解记忆context的创建过程，整理了如下伪代码用于描述ContextLoader初始化ApplicationContext的过程：

    ContextLoaderListener.contextInitialized(ServletContextEvent event) {
//listener继承自ContextLoader，因此下面这句其实是执行ContextLoaderListener父类的方法
ContextLoader.initWebApplicationContext(event.getServletContext()){
this.createWebApplicationContext(ServletContext sc, ApplicationContext parent){
/*
determineContextClass方法是先从servlet上下文中获取初始化参数servletContext.getInitParameter("contextClass")，
如果该方法获取不到则从ContextLoader.properties获取，所以基本上我们在web中使用的都是XmlWebApplicationContext作为Spring容器上下文的实例。
如果我们不使用web容器，那么最常使用的是ClassPathXmlApplicationContext
*/
Class<?> contextClass = determineContextClass(sc);
ConfigurableWebApplicationContext wac =(ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
//下面这句开启了beanFactory的初始化
wac.refresh();
}
}
}

     

  2. 创建beanFactory

    beanFactory是实现IOC的核心，其作用如下：

      创建singleton类型的bean并缓存。
    • 缓存prototype类型的beanFactory对象。
    • 调用factory创建时拦截器BeanFactoryPostProcessor、bean创建时拦截器BeanPostProcessor，实现spring bean最核心的扩展点。

    其类图如下：


    如下伪代码描述了ApplicationContext创建BeanFactory的过程：

    AbstractApplicationContext.refresh(){
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(){
//AbstractRefreshableApplicationContext继承自AbstractApplicationContext
AbstractRefreshableApplicationContext.refreshBeanFactory(){
//创建DefaultListableBeanFactory实例                                       ---1:创建beanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
//根据资源配置加载bean定义                                                 ---2：加载beanDefinition并缓存起来
XmlWebApplicationContext.loadBeanDefinitions(beanFactory){
BeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
//如果是web工程则会通过web.xml中initParam参数查找configLocations配置
for (String configLocation : configLocations) {
//将配置文件的解析工作委托给BeanDefinitionReader
reader.loadBeanDefinitions(configLocation){
//调用实际执行解析的方法
reader.registerBeanDefinitions(Document doc, Resource resource){
//创建reader上下文，之所以创建context是为了触发bean解析后的相关注册事件
ReaderContext readerContext = new XmlReaderContext(reader);
//创建实际执行Document解析工作的BeanDefinitionDocumentReader
BeanDefinitionDocumentReader documentReader = new DefaultBeanDefinitionDocumentReader();
//调用其解析方法并将解析后的结果存储在registry(即beanFactory中，因为beanFactory实现了BeanDefinitionRegistry接口)
documentReader.registerBeanDefinitions(doc, readerContext){
Element root = doc.getDocumentElement();
//创建真正执行解析的工具类BeanDefinitionParserDelegate
BeanDefinitionParserDelegate delegate =  = new BeanDefinitionParserDelegate(readerContext);
documentReader.parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate){
for(Element ele : root.elements()){
//判断节点类型
if (delegate.isDefaultNamespace(ele)) {
documentReader.parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate){
//根据ele节点类型来判断调用以下哪个方法
importBeanDefinitionResource(Element ele);
processAliasRegistration(Element ele);
//以bean节点的解析为例
processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate){
//解析出bdHolder对象，该对象包括beanName和beanDefinition
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
//将beanDefinition对象注册到registry bean定义缓存中
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
//获取reader上下文执行bean解析后的监听事件
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
} else {
delegate.parseCustomElement(ele){
/*
*解析各种特殊的节点如context:component-scan等
*NamespaceHandlerResolver是由XmlBeanDefinitionReader.createReaderContext进行初始化，其中包含了各种自定义命名空间的处理类。
*如context命名空间的解析类为ContextNamespaceHandler
*/
//此处获取handler时会调用其init方法，向handler中注册各种节点的解析器
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
handler.parse(ele, new ParserContext(this.readerContext, this, containingBd)){
//查找节点对应的解析器
//如component-scan对应的解析器为ComponentScanBeanDefinitionParser，此处会调用其parse方法时会调用ClassPathBeanDefinitionScanner.doScan方法扫描base-package指定的包中含有@Component注解的类并解析成beanDefinition注册到beanFactory
handler.findParserForElement(element, parserContext).parse(element, parserContext)
}
}
}
}
}
}
}
}
}
}
}
}
//可用来向beanFactory中添加自定义的拦截器， 如AbstractRefreshableWebApplicationContext中添加的ServletContextAwareProcessor
postProcessBeanFactory(beanFactory);
//从beanFactory中找到BeanFactoryPostProcessor的实现类并执行
invokeBeanFactoryPostProcessors(beanFactory){
//获取BeanDefinitionRegistryPostProcessor，该拦截器可由向beanDefineRegistry中添加bean定义
//spring内部有扩展该接口，如ConfigurationClassPostProcessor(当spring配置中加入了context:component-scan时，该bean会被注册到容器中)用于处理添加了@Configuration @Bean注解的bean，将其解析成beanDefine并添加到beanFactory中缓存起来
Map<String, BeanDefinitionRegistryPostProcessor> beanMap =
beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);
if(beanbFactory instanceOf BeanDefinitionRegistry){
BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry((BeanDefinitionRegistry) beanFactory);
} else {
BeanDefinitionRegistryPostProcessor.postProcessBeanFactory(beanFactory);
}
}
//从beanFactory中找到BeanPostProcessor的实现类实体bean定义，调用getBean方法实例化并注册到beanFactory中
registerBeanPostProcessors(beanFactory){
//BeanPostProcessor的注册顺序：首先是实现了PriorityOrdered接口的，然后是实现了Ordered 然后是没用排序接口的nonOrdered 最后是MergedBeanDefinitionPostProcessor的实现类
//当配置文件中加入了context:component-scan后spring会加入MergedBeanDefinitionPostProcessor的内部实现类PersistenceAnnotationBeanPostProcessor、
registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors);
}
//Initialize message source for this context.
initMessageSource();

//初始化上下文中的应用事件广播器
initApplicationEventMulticaster();
//与registerBeanPostProcessors类似，从beanFactory中获取ApplicationListener的实现类
registerListeners();

//bean实例化(此时处理的基本只有用户自定义的普通bean，像BeanPostProcessor等扩展bean都已经提前实例化好了，所以在实例化普通bean时可以直接调用了)
finishBeanFactoryInitialization();
}


     

  3. 实例化bean

    如下伪代码用于描述spring内部的调用顺序：

    BeanFactory实例化Bean的过程
AbstractApplicationContext.refresh(){
//完成bean的实例化
AbstractApplicationContext.finishBeanFactoryInitialization(){
DefaultListableBeanFactory.preInstantiateSingletons(){
List<String> beanNames = new ArrayList<String>(DefaultListableBeanFactory.beanDefinitionNames);
//遍历bean定义集合，预先实例化singleton类型bean
for (String beanName : beanNames) {
AbstractBeanFactory.getBean(beanName){
AbstractBeanFactory.doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly){
if (RootBeanDefinition.isSingleton()) {
//此处可以看出spring的bean都是从ObjectFactory生产出来的，如果是singleton等非自定义的工厂对象，那么最终工厂还是会去调用beanFactory里面的方法。
ObjectFactory singletonFactory = new ObjectFactory() {
public Object getObject() throws BeansException {
try {
return AbstractBeanFactory.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 all
1d58b
ow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
}
}
//调用bean缓存器来获取bean，如果缓存中没有则需要继续调用beanFactory的createBean方法来创建bean。
DefaultSingletonBeanRegistry.getSingleton(String beanName, singletonFactory){
Object singletonObject = singletonFactory.getObject(){
AbstractAutowireCapableBeanFactory.createBean(String beanName, RootBeanDefinition mbd, Object[] args){
AbstractAutowireCapableBeanFactory.doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
//创建Bean对象包装器，该包装器提供setProperty等方法供后续填充bean属性及解决依赖使用
BeanWrapper instanceWrapper = AbstractAutowireCapableBeanFactory.createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args){
AbstractAutowireCapableBeanFactory.instantiateBean(final String beanName, final RootBeanDefinition mbd){
//实际的bean创建方式可以是直接实例化创建也可以是用cglib等代理创建的对象，此处默认用的是CglibSubclassingInstantiationStrategy
//将真实的创建方式进行了策略抽象，这样就可以用不同的代理框架 可以自定义实现
SimpleInstantiationStrategy.instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner){
//CglibSubclassingInstantiationStrategy.instantiateWithMethodInjection(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner){
//}
BeanUtils.instantiateClass(constructorToUse);
}
}
}
//执行AbstractApplicationContext.ApplicationListenerDetector处理器，作为后续添加到context applicationListener的先决条件
//调用MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition方法
/*
*执行beanFactory创建时调用registerBeanPostProcessors方法所加入的MergedBeanDefinitionPostProcessor内部实现类，用于完善RootBeanDefinition定义
*PersistenceAnnotationBeanPostProcessor用来完善jpa相关注解的解析
*AutowiredAnnotationBeanPostProcessor
*RequiredAnnotationBeanPostProcessor
*CommonAnnotationBeanPostProcessor 解析字段和方法中的Resource webservice等注解，Resource注解字段信息会加入到externallyManagedConfigMembers中
*
*/
applyMergedBeanDefinitionPostProcessors();
DefaultSingletonBeanRegistry.addSingletonFactory(String beanName, ObjectFactory singletonFactory);
//进行属性设置 依赖bean注入
AbstractAutowireCapableBeanFactory.populateBean(beanName, mbd, instanceWrapper){
//执行beanPostProcessors中InstantiationAwareBeanPostProcessor实现类的postProcessAfterInstantiation方法
InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation(instanceWrapper.getWrappedInstance(), beanName);
/*
*调用InstantiationAwareBeanPostProcessor.postProcessPropertyValues方法
*CommonAnnotationBeanPostProcessor中会向Resource注解的字段注入相应的bean
*/
InstantiationAwareBeanPostProcessor.postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName);
}
}
}
}
//将创建的bean对象缓存起来
DefaultSingletonBeanRegistry.addSingleton(beanName, singletonObject);;
}
}
}
}
}
}
}
}



内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航