===========================================

    原文链接: spring源码浅析——IOC   转载请注明出处!

===========================================

在读之前应该明白其重点:读spring读的不是其具体的技术实现,读的是其系统层面的结构和设计! spring漂亮就漂亮在她的结构,包括接口和抽象类的灵活使用!

  IOC模块只是spring框架中的一个模块,这里只对该模块进行分析(使用版本:spring-framework-4.0.0.RELEASE-dist)。

  IOC(Inversion of Control,控制反转),“控制对象的创建或销毁不再由调用处进行控制,而是由spring容器进行管理和控制”,“控制”就是指对程序中的对象实体的生命周期的控制。“反转”本来是由调用处进行控制的,现在调用处不管了,反倒由spring进行管理,所以叫做bean的管理“反转”了,合在一起也就是所谓的“控制反转”。很不喜欢这四个字来描述!刚接触spring的朋友对这个概念比较难以理解,我当时接触的时候就感觉无法理解,直到后来一遍一遍的琢磨之后才理解其含义。

IOC涉及到的类比较多,结构较为复杂,在分析之前需要先抓住九个关键的类系(之所以用类系来形容是因为下面所列出来的不是某个具体的实现类,而是从接口到抽象类等一些系列相关类/接口):

  BeanFactory:bean的管理工厂,所有的bean都在该对象中进行创建、存储和销毁。

  DefaultListableBeanFactory:beanFactory具体实现类

  Resource:spring的配置信息,该信息可能来源于xml文件,可能来源于网络,也可能来源于数据流中。不管他从哪里来的,都封装为Resource对象。

  BeanDefinition:bean的所有信息在该对象中进行封装,包括bean的参数值、方法名、是否懒加载、是否为单例等各种信息

  BeanDefinitionReader:见名知意,构建BeanDefinition的reader,也就是通过该Reader从Resource中读取信息封装为BeanDefinition。

  ApplicationContext:俗称“上下文”和“控制反转”一样晦涩难懂,据我猜测之所以这样命名,是因为context继承了太多的接口,具有各种各样的功能,可以称为万能的上帝。并且所有的需要用到的bean都可以在其中取到,起到沟通上下的桥梁的作用,所以叫做“上下文”。这里可以看出其特性是:实现了各种功能接口,封装了各种bean对象。

  Environment:运行环境配置信息,也就是一些配置属性,来源于:properties文件,JVM properties,system环境变量,JNDI, servlet context parameters上下文参数,专门的Properties对象,Maps等等

  Document:从xml文件文件中抽取出来的本文对象。

  Element:从Document中取出的node节点

  上面的描述暂时理解不了没关系,只要心里面有这几个模块的概念就可以,在进行分析代码的时候能够意识到相关bean的功能即可,如需深入理解相关类系,需要深入对代码进行剖析。

下面我们就从一个小例子进入对IOC模块的分析。

  Spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <bean id="person" class="com.zpj.bean.Person">
<property name="name" value="xingoo" />
<property name="age" value="12" />
</bean> </beans>

  程序入口

public class SpringTest {
public static void main(String[] args) {
//获取context上下文对象,该上下文是ClassPathXmlApplicationContext类
ApplicationContext context = new ClassPathXmlApplicationContext("springConfig.xml");
//从容器中取出名为"person"的对象
Person person = context.getBean("person", Person.class);
//调用person.info()方法。
person.info();
}
}

在进入ClassPathXmlApplicationContext构造方法之后,一直调用this()找到被重载的构造方法

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
this(new String[] {configLocation}, true, null);
}
//this()进入重载的构造方法
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)throws BeansException {
super(parent);
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}

第一个super()一直向上找到AbstractApplicationContext,该类中实现了大部分的标准操作。

    public AbstractApplicationContext(ApplicationContext parent) {
this();
setParent(parent);
}
//先看this方法,this()进入该方法对resourcePatternResolver进行赋值
public AbstractApplicationContext() {
this.resourcePatternResolver = getResourcePatternResolver();
}
//这里需要注意的是getResourcePatternResolver()中返回的是PathMatchingResourcePatternResolver对象,并把this作为参数赋值给resolver中的resourceLoader。
protected ResourcePatternResolver getResourcePatternResolver() {
return new PathMatchingResourcePatternResolver(this);
}
//在PathMatchingResourcePatternResolver中,this被赋值给resourceLoader。上面传进来的是context,怎么用resourceLoader进行接收了呢?
//因为Context实现了ResourceLoader的接口(这里需要记住)
private final ResourceLoader resourceLoader;//resourceLoader的定义
public PathMatchingResourcePatternResolver(ResourceLoader resourceLoader) {
Assert.notNull(resourceLoader, "ResourceLoader must not be null");
this.resourceLoader = resourceLoader;
}
//************************分析完this(),下面看setParent(parent);(这里parent是个null值,这里我们进入看看都进行了哪些操作)**************************************************************
@Override
public void setParent(ApplicationContext parent) {
this.parent = parent;
if (parent != null) {
//注意这里,说明是从AbstractApplicationContext中取得的EnvEnvironment对象
Environment parentEnvironment = parent.getEnvironment();
if (parentEnvironment instanceof ConfigurableEnvironment) {
//merge()对取得的parentEnvironment和当前的Environment进行合并。
getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
}
}
} // 再AbstractApplicationContext中,如果存在则直接返回,如果不存在则进行创建操作
// 注意该方法,后面有多次进行获取environment
public ConfigurableEnvironment getEnvironment() {
if (this.environment == null) {
//这里创建同时保存在了当前类AbstractApplicationContext中
this.environment = createEnvironment();
}
return this.environment;
}
//创建的时候返回以StandardEnvironment实现类进行创建
protected ConfigurableEnvironment createEnvironment() {
return new StandardEnvironment();
}
// 至此,ClassPathXmlApplicationContext构造方法中super()的操作结束

  这里对ClassPathXmlApplicationContext构造方法的super操作进行汇总:

    1、AbstractApplicationContext中对resourcePatternResolver设值,并把自身当做resourceLoader设置给resourcePatternResolver。

    2、AbstractApplicationContext中对environment进行了设值

    3、把parent的environment和自己的environment进行了合并

这里需要注意的是,进行到这一步environment和resourcePatternResolver都已经有值了,在后面就可以进行get使用了。

下面进入到setConfigLocations(configLocations) 操作

    public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)throws BeansException {
super(parent);
//对该方法进行分析,这里configLocations的值为[springConfig.xml]
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}
//进入void org.springframework.context.support.AbstractRefreshableConfigApplicationContext.setConfigLocations(String... locations) public void setConfigLocations(String... locations) {
if (locations != null) {
//这句断言攒在的意义是什么?上面已经进行了不为空判断,如果为null根本就执行不到这一步
Assert.noNullElements(locations, "Config locations must not be null");
this.configLocations = new String[locations.length];
for (int i = 0; i < locations.length; i++) {
//该方法主要目的就是对configLocations进行解析设值
this.configLocations[i] = resolvePath(locations[i]).trim();
}
}
else {
this.configLocations = null;
}
}
// 进入resolvePath,这里调用了Environment的resolveRequiredPlaceholders方法(上面已经说过Environment已经进行了设值)
protected String resolvePath(String path) {
return getEnvironment().resolveRequiredPlaceholders(path);
}
// 该方法全名为:String org.springframework.core.env.AbstractEnvironment.resolveRequiredPlaceholders(String text) throws IllegalArgumentException
//是实现在StandardEnvironment的父类AbstractEnvironment中
@Override
public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {
// 这里又进行了调用
return this.propertyResolver.resolveRequiredPlaceholders(text);
}
// 这里的需要注意的是propertyResolver的实例化在哪里进行的。
// 在该类中有三个全局变量:
protected final Log logger = LogFactory.getLog(getClass());
private final MutablePropertySources propertySources = new MutablePropertySources(this.logger);
private final ConfigurablePropertyResolver propertyResolver =new PropertySourcesPropertyResolver(this.propertySources);
// 所以propertyResolver在生成new StandEnvironment()的时候就同时创建了
// 这里不再继续进行跟进去,this.propertyResolver.resolveRequiredPlaceholders(text);主要是对占位符进行了替换操作,把${name}替换为其实际值。
// 至此setConfigLocations()操作结束

这里对ClassPathXmlApplicationContext构造方法的setConfigLocations(configLocations) 操作进行汇总:

  1、xml对配置文件名称进行了解析,解析之后存储在String[] org.springframework.context.support.AbstractRefreshableConfigApplicationContext.configLocations数组中。

到这一步,xml配置文件路径已经进行了存储,下面就该对xml进行读取,加载、解析等操作。

下面进入到void org.springframework.context.support.AbstractApplicationContext.refresh() throws BeansException, IllegalStateException操作

@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
//对context的刷新进行准备操作
prepareRefresh(); // Tell the subclass to refresh the internal bean factory.
//告诉子类刷新内部bean工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // Prepare the bean factory for use in this context.
//对beanFactory进行准备操作,以便于context的后续使用
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
//在对beanFactory进行标准化处理之后,允许子类对beanFactory进行后处理操作,子类覆写该方法进行特殊操作
postProcessBeanFactory(beanFactory); // Invoke factory processors registered as beans in the context.
//在上下文中调用作为bean注册的工厂处理器。
invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation.
//注册拦截bean创建的bean处理器,这里只是进行注册操作
registerBeanPostProcessors(beanFactory); // Initialize message source for this context.
//为上下文初始化message,即对国际化资源文件进行初始化
initMessageSource(); // Initialize event multicaster for this context.
//初始化应用消息广播器
initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses.
//子类覆写该方法,进行自己的初始化操作
onRefresh(); // Check for listener beans and register them.
//查找所用已经注册过的listener bean并注册到广播器中
registerListeners(); // Instantiate all remaining (non-lazy-init) singletons.
//初始化剩下的单实例(非惰性)
finishBeanFactoryInitialization(beanFactory); // Last step: publish corresponding event.
//最后一步:完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent事件,通知其他监听者
finishRefresh();
} catch (BeansException ex) {
logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex); // Destroy already created singletons to avoid dangling resources.
//发生异常销毁已经创建的单利bean
destroyBeans(); // Reset 'active' flag.
//关闭刷新操作
cancelRefresh(ex); // Propagate exception to caller.
throw ex;
}
}
}

beanFactory的创建和初始化操作都在该方法中进行,下面逐个方法进行分析

//    进入void org.springframework.context.support.AbstractApplicationContext.prepareRefresh()
protected void prepareRefresh() {
this.startupDate = System.currentTimeMillis();
this.active.set(true);
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
// Initialize any placeholder property sources in the context environment
//留给子类覆写,实现其特有的占位符初始化操作,这里方法体为空
initPropertySources(); // Validate that all properties marked as required are resolvable
// see ConfigurablePropertyResolver#setRequiredProperties
//验证系统所必须的关键性配置参数是否已经加载到environment中,如果没有则抛出MissingRequiredPropertiesException异常
getEnvironment().validateRequiredProperties();
}
/**
* void org.springframework.context.support.AbstractApplicationContext.prepareRefresh()汇总:
* 1、让子类进行自身特有的占位符初始化操作
* 2、验证必须的配置参数是否已经加载
*/ // 进入ConfigurableListableBeanFactory org.springframework.context.support.AbstractApplicationContext.obtainFreshBeanFactory()
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//刷新beanFactory
refreshBeanFactory();
//获取beanFactory并进行返回
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
} //这里进行刷新操作,该方法实现于:void org.springframework.context.support.AbstractXmlApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException
@Override
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {// 判断方式:return (this.beanFactory != null);
//如果已经存在则进行销毁同时关闭,至于怎么销毁和关闭的就不详解
destroyBeans();
closeBeanFactory();
}
try {
//创建beanFactory,该方法直接return new DefaultListableBeanFactory(getInternalParentBeanFactory());这里需要注意的是beanFactory的实现类是DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
//设置序列化唯一id
beanFactory.setSerializationId(getId());
//设置beanFactory相关属性,是否允许覆盖同名称的不同定义的对象、是否允许循环依赖,可以被子类进行覆写
customizeBeanFactory(beanFactory);
//重点!!!加载beanDefinition 加载分两步:1、解析Document 2、注册BeanDefinition
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
// 这里进入关键方法loadBeanDefinitions,该方法实现于:void org.springframework.context.support.AbstractXmlApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// Create a new XmlBeanDefinitionReader for the given BeanFactory.
//这里是使用xml文件进行配置的,所以这里使用的是XmlBeanDefinitionReader作为beanDefinitionReader,
//这里beanFactory作为BeanDefinitionRegistry实例传入beanDefinitionReader.XmlBeanDefinitionReader.XmlBeanDefinitionReader(BeanDefinitionRegistry registry);
//注意beanDefinitionReader中的registry
//提醒:还记得文章开始部分定义的BeanDefinition是什么吗?bean的所有信息在该对象中进行封装,包括bean的参数值、方法名、是否懒加载、是否为单例等各种信息
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); // Configure the bean definition reader with this context's resource loading environment.
beanDefinitionReader.setEnvironment(this.getEnvironment());
//注意这个ResourceLoader参数,此处的this指的是AbstractXmlApplicationContext,而AbstractBeanDefinitionReader.setResourceLoader(ResourceLoader resourceLoader)中接收的是ResourceLoader
//所以说AbstractXmlApplicationContext实现了ResourceLoader接口(上面已经说过)
beanDefinitionReader.setResourceLoader(this);
//设置实体解析器,该ResourceEntityResolver还是用ResourceLoader接收的this
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); // Allow a subclass to provide custom initialization of the reader,
// then proceed with actually loading the bean definitions.
//对defintionReader进行初始化操作,运训子类进行覆盖,然后开始进行实际加载bean definition
initBeanDefinitionReader(beanDefinitionReader);
//重点!!!进行BeanDefinitions的加载操作
loadBeanDefinitions(beanDefinitionReader);
}
// 这里进入关键方法loadBeanDefinitions,该方法实现于:void org.springframework.context.support.AbstractXmlApplicationContext.loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
//取得ClassPathResource并进行加载
Resource[] configResources = getConfigResources();
if (configResources != null) {
//标识位置:loadBeanDefinitions_Resource
reader.loadBeanDefinitions(configResources);
}
//取得ConfigLocations并进行加载(这里的ConfigLocations就是上面解析出来的String[] configLocations,存储着配置文件的路径)
String[] configLocations = getConfigLocations();
if (configLocations != null) {
//标识位置:loadBeanDefinitions_String
reader.loadBeanDefinitions(configLocations);
}
}
// 这里的loadBeanDefinitions_String和loadBeanDefinitions_Resource进行加载的方法是一样的,都是调用int org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException
// 进行加载。只是loadBeanDefinitions_String在进行加载之前多了一步操作,把String转化为Resource,然后进行加载,这里就从loadBeanDefinitions_String跟进去 // 进入loadBeanDefinitions方法,该方法实现于:int org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException
@Override
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
Assert.notNull(locations, "Location array must not be null");
int counter = 0;
for (String location : locations) {
//循环对locations进行加载
counter += loadBeanDefinitions(location);
}
return counter;
}
//进入loadBeanDefinitions,该方法实现于:int org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(String location) throws BeanDefinitionStoreException
@Override
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
//继续调用加载
return loadBeanDefinitions(location, null);
}
//进入loadBeanDefinitions,该方法实现于: int org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException
public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
//还记得这个resourceLoader什么时候赋值的吗?赋值的又是谁呢?AbstractXmlApplicationContext
ResourceLoader resourceLoader = getResourceLoader();
if (resourceLoader == null) {
throw new BeanDefinitionStoreException(
"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
}
//这里根据resourceLoader进行划分,不同的resourceLoader从不同的源加载resource。
if (resourceLoader instanceof ResourcePatternResolver) {
// Resource pattern matching available.
try {
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
int loadCount = loadBeanDefinitions(resources);
if (actualResources != null) {
for (Resource resource : resources) {
//把resource进行缓存
actualResources.add(resource);
}
}
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
}
return loadCount;
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"Could not resolve bean definition resource pattern [" + location + "]", ex);
}
}
else {
// Can only load single resources by absolute URL.
//只能加载从绝对URL加载单例资源,xml走的是这里,进入之后区分类路径资源、URL资源和文件系统资源(xml属于该种),这里不再对封装resource进行分析
Resource resource = resourceLoader.getResource(location);
//进行记载definition,这里调用的方法和标识位置:loadBeanDefinitions_Resource调用的加载方法就相同了
int loadCount = loadBeanDefinitions(resource);
if (actualResources != null) {
//把resource进行缓存
actualResources.add(resource);
}
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
}
return loadCount;
}
}
//进入loadBeanDefinitions,该方法实现于:int org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException //当前进行加载的resources存储于这个ThreadLocal线程局部变量中
private final ThreadLocal<Set<EncodedResource>> resourcesCurrentlyBeingLoaded = new NamedThreadLocal<Set<EncodedResource>>("XML bean definition resources currently being loaded");
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
Assert.notNull(encodedResource, "EncodedResource must not be null");
if (logger.isInfoEnabled()) {
logger.info("Loading XML bean definitions from " + encodedResource.getResource());
}
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
if (currentResources == null) {
currentResources = new HashSet<EncodedResource>(4);
//操作之前先把currentResources放在resourcesCurrentlyBeingLoaded中,注意下面加载操作完成之后进行了remove
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
//这里把encodedResource放进currentResources中,后面依旧会remove
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
}
try {
//获取inputStream
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
//封装为InputSource
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
//为inputSource设置resource的编码方式
inputSource.setEncoding(encodedResource.getEncoding());
}
//这里才是真正进行BeanDefinitions的加载操作,前面的都是进行预处理封装inputSource
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
inputStream.close();
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"IOException parsing XML document from " + encodedResource.getResource(), ex);
}
finally {
//操作之后把currentResources从resourcesCurrentlyBeingLoaded中移除出去,注意上面加载操之前的add
currentResources.remove(encodedResource);
if (currentResources.isEmpty()) {
this.resourcesCurrentlyBeingLoaded.remove();
}
}
}
// 进入doLoadBeanDefinitions,该方法实现于:int org.springframework.beans.factory.xml.XmlBeanDefinitionReader.doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
//关键方法两步:取得Document;注册BeanDefinition
//这里就不再解析怎么加载Document的了,Spring是使用SAX进行xml解析的,可以自己详细了解
Document doc = doLoadDocument(inputSource, resource);
//把BeanDefinition注册到context中
return registerBeanDefinitions(doc, resource);
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (SAXParseException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
}
catch (SAXException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"XML document from " + resource + " is invalid", ex);
}
catch (ParserConfigurationException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Parser configuration exception parsing XML from " + resource, ex);
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"IOException parsing XML document from " + resource, ex);
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Unexpected exception parsing XML document from " + resource, ex);
}
}
// 进入registerBeanDefinitions,该方法实现于: int org.springframework.beans.factory.xml.XmlBeanDefinitionReader.registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
//创建documentReader这里返回的是 return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
documentReader.setEnvironment(this.getEnvironment());
//这个countBefore是为了统计从Document中加载的beanDefinition的个数
int countBefore = getRegistry().getBeanDefinitionCount();
//进行注册BeanDefinition操作
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}
// 进入registerBeanDefinitions,该方法实现于:void org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.registerBeanDefinitions(Document doc, XmlReaderContext readerContext)
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
Element root = doc.getDocumentElement();
//取出root节点,从root节点遍历所有节点进行注册
doRegisterBeanDefinitions(root);
}
// 进入doRegisterBeanDefinitions,该方法实现于:void org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions(Element root)
protected void doRegisterBeanDefinitions(Element root) {
// Any nested <beans> elements will cause recursion in this method. In
// order to propagate and preserve <beans> default-* attributes correctly,
// keep track of the current (parent) delegate, which may be null. Create
// the new (child) delegate with a reference to the parent for fallback purposes,
// then ultimately reset this.delegate back to its original (parent) reference.
// this behavior emulates a stack of delegates without actually necessitating one.
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(this.readerContext, root, parent); if (this.delegate.isDefaultNamespace(root)) {
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
if (StringUtils.hasText(profileSpec)) {
Assert.state(this.environment != null, "Environment must be set for evaluating profiles");
String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
if (!this.environment.acceptsProfiles(specifiedProfiles)) {
return;
}
}
}
//为子类预留,覆写进行解析之前的特殊操作
preProcessXml(root);
//通过代理进行解析
parseBeanDefinitions(root, this.delegate);
//为子类预留,覆写进行解析之后的特殊操作
postProcessXml(root); this.delegate = parent;
}
// 进入postProcessXml,该方法实现于:void org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate)
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
//循环所有的Element节点进行解析
parseDefaultElement(ele, delegate);
}
else {
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}
// 进入postProcessXml,该方法实现于: void org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
//对“import”标签进行解析注册
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
//对“alias”标签进行解析注册
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
//对“bean”标签进行解析注册,这里从这里面进去分析,这里的分支思路大同小异
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
//对“beans”标签进行解析注册
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
// 进入processBeanDefinition,该方法实现于: void org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate)
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//对ele进行解析,把id、name、aliases进行封装
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
//如果需要则使用bdHolder的代理进行操作
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
//对definition的最终注册,注意该方法的第二个参数:Registry
//设置readerContext位置:documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
//设置Registry位置(第五个参数this):return new XmlReaderContext(resource, this.problemReporter, this.eventListener,this.sourceExtractor, this, getNamespaceHandlerResolver());
//该this指代的是XmlBeanDefinitionReader实例
//而他的Registry设置位置是:XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
//所以该Registry就是beanFactory
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
//发送注册event给监听者
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
// 进入BeanDefinitionReaderUtils.registerBeanDefinition,该方法实现于: void org.springframework.beans.factory.support.BeanDefinitionReaderUtils.registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)throws BeanDefinitionStoreException {
// Register bean definition under primary name.
//取得beanName注册beanDefinition
String beanName = definitionHolder.getBeanName();
//注册beanDefinition
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
//取得对该beanName注册aliases,这里关联的是aliases--beanName,所以通过aliase进行取值的时候需要先由aliase找到beanName,然后根据beanName找到beanDefinition
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String aliase : aliases) {
registry.registerAlias(beanName, aliase);
}
}
}
// 进入registerBeanDefinition.registerBeanDefinition,该方法实现于:void org.springframework.beans.factory.support.DefaultListableBeanFactory.registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException
//注意该方法的实现位置:DefaultListableBeanFactory private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null"); if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
} BeanDefinition oldBeanDefinition; //加锁同步
//注意该上面的beanDefinitionMap
synchronized (this.beanDefinitionMap) {
oldBeanDefinition = this.beanDefinitionMap.get(beanName);
if (oldBeanDefinition != null) {
//如果已经存在该beanDefinition则判断是否允许覆盖
if (!this.allowBeanDefinitionOverriding) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + oldBeanDefinition + "] bound.");
}
else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (this.logger.isWarnEnabled()) {
this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
" with a framework-generated bean definition ': replacing [" +
oldBeanDefinition + "] with [" + beanDefinition + "]");
}
}
else {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding bean definition for bean '" + beanName +
"': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
}
}
}
else {
//如果不存在该bean则注册beanName
this.beanDefinitionNames.add(beanName);
this.frozenBeanDefinitionNames = null;
}
//把bean加入缓存beanDefinitionMap,这里完成注册
this.beanDefinitionMap.put(beanName, beanDefinition);
} if (oldBeanDefinition != null || containsSingleton(beanName)) {
//重置该beanDefinition的所有缓存 Reset all bean definition caches for the given bean
resetBeanDefinition(beanName);
}
}
//至此,beanFactory构建完成, ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();结束。

beanFactory创建完成之后,缓存中已经存储有配置bean的beanDefinition。

在void org.springframework.context.support.AbstractApplicationContext.refresh() throws BeansException, IllegalStateException中的其他方法是对beanFactory以及context的其他操作,主要是为子类覆写一些方法、注册一些监听、处理一下国际化资源文件等,这里就不再进行详细分析。

至此,该方法中的context 创建完成。

public class SpringTest {
public static void main(String[] args) {
//获取context上下文对象,该上下文是ClassPathXmlApplicationContext类
ApplicationContext context = new ClassPathXmlApplicationContext("springConfig.xml");
//从容器中取出名为"person"的对象
Person person = context.getBean("person", Person.class);
//调用person.info()方法。
person.info();
}
}

  spring用着方便,但是实现起来确实很复杂,里面涉及了大量的设计模式,装饰模式、代理模式、工厂模式、模板方法等,对于学习系统设计有很大的帮助。

  文章中只简单的介绍了一下beanFactory的创建,其中忽略了大量的细节,比如对单利bean的管理,beanDefinition到bean的创建,此外,对beanFactory的后期处理,Listeners的添加、MessageSource的初始化等。有兴趣的朋友可以深入研究一下,这里就不再继续分析,能力有限,很多东西我也不是太明白,还需要继续学习。建议刚接触该模块源码的朋友一定要多进行debug读源码,对源码进行分析,如果能在熟练使用sping的基础上读源码效果会更好,最好自己亲自绘制一下该模块的类图,这样可以对该模块的整体结构有一个比较清晰的认识,对上面的九个关键的类系就能够有更好的理解。

在学习的过程中遇到一本讲解比较详细的书,这里分享给大家,里面还有绘制的相关类图,用powerdesigner进行打开。

链接在此:学习资源分享  文件名分别为:spring源码深度解析   spring-IOC相关类图

------over

spring源码浅析——IOC的更多相关文章

  1. spring源码分析---IOC(1)

    我们都知道spring有2个最重要的概念,IOC(控制反转)和AOP(依赖注入).今天我就分享一下spring源码的IOC. IOC的定义:直观的来说,就是由spring来负责控制对象的生命周期和对象 ...

  2. Spring源码解析-ioc容器的设计

    Spring源码解析-ioc容器的设计 1 IoC容器系列的设计:BeanFactory和ApplicatioContext 在Spring容器中,主要分为两个主要的容器系列,一个是实现BeanFac ...

  3. 【原】Spring源码浅析系列-导入源码到Eclipse

    用了Spring几年,平时也断断续续在项目里看过一些源码,大多都是比较模糊的,因为一旦从一个地方进去就找不到方向了,只能知道它大概是做了什么事能达到这个功能或者效果,至于细节一般没有太深入去研究.后来 ...

  4. Spring源码 05 IOC 注解方式

    参考源 https://www.bilibili.com/video/BV1tR4y1F75R?spm_id_from=333.337.search-card.all.click https://ww ...

  5. Spring源码 18 IOC refresh方法13

    参考源 https://www.bilibili.com/video/BV1tR4y1F75R?spm_id_from=333.337.search-card.all.click https://ww ...

  6. Spring源码 16 IOC refresh方法11

    参考源 https://www.bilibili.com/video/BV1tR4y1F75R?spm_id_from=333.337.search-card.all.click https://ww ...

  7. Spring源码 17 IOC refresh方法12

    参考源 https://www.bilibili.com/video/BV1tR4y1F75R?spm_id_from=333.337.search-card.all.click https://ww ...

  8. Spring源码 15 IOC refresh方法10

    参考源 https://www.bilibili.com/video/BV1tR4y1F75R?spm_id_from=333.337.search-card.all.click https://ww ...

  9. Spring源码 14 IOC refresh方法9

    参考源 https://www.bilibili.com/video/BV1tR4y1F75R?spm_id_from=333.337.search-card.all.click https://ww ...

随机推荐

  1. 堡垒机--paramiko模块

    做堡垒机之前,来了解一下paramiko模块. 实际上底层封装的SSH. SSHclient(1) import paramiko #实例化一个ssh ssh = paramiko.SSHClient ...

  2. wukong搜索引擎源码解读

    转自:https://ayende.com/blog/171745/code-reading-wukong-full-text-search-engine I like reading code, a ...

  3. noip2016天天爱跑步

    题目描述 小c同学认为跑步非常有趣,于是决定制作一款叫做<天天爱跑步>的游戏.«天天爱跑步»是一个养成类游戏,需要玩家每天按时上线,完成打卡任务. 这个游戏的地图可以看作一一棵包含 个结点 ...

  4. RAC时间同步的两种方法

    集群时间同步服务在集群中的两个 Oracle RAC 节点上执行以下集群时间同步服务配置.Oracle Clusterware 11g 第 2 版及更高版本要求在部署了 Oracle RAC 的集群的 ...

  5. SQL SERVER 运维日记-数据库备份

    概述 昨天下午突然看到,<炉石传说>游戏数据库发生宕机并引发数据丢失事故的新闻.刚看到时,满满的不可思议.暴雪啊,网易啊. 都是很牛叉的公司.他们出的游戏我都是很喜欢的. 当我看到,第一时 ...

  6. selenium相关面试题

    selenium中如何判断元素是否存在? selenium中hidden或者是display = none的元素是否可以定位到? selenium中如何保证操作元素的成功率?也就是说如何保证我点击的元 ...

  7. SQL Server事务、隔离级别详解(二十九)

    前言 事务一直以来是我最薄弱的环节,也是我打算重新学习SQL Server的出发点,关于SQL Server中事务将分为几节来进行阐述,Always to review the basics. 事务简 ...

  8. Express之托管静态文件

    中间件express.static 我们使用express初始化一个目录的时候,会在app.js中看到一大推的app.use. 其中一个主要的中间件是express.static(4.0版本依旧保留的 ...

  9. Quartz_理解3

    什么是Quartz Quartz是一个开源的作业调度框架,由java编写,在.NET平台为Quartz.Net,通过Quart可以快速完成任务调度的工作. Quartz能干什么/应用场景 如网页游戏中 ...

  10. json基础教程|理解Json

    一. 在异步应用程序中发送和接收信息时,可以选择以纯文本和 XML 作为数据格式.这一期讨论一种有用的数据格式 JavaScript Object Notation(JSON),以及如何使用它更轻松地 ...