`

spring源码分析-XmlBeanFactory导读

SpringBeanXML框架 
阅读更多

源代码分析，是一件既痛苦又快乐的事情，看别人写的代码是通过的，但当你能够看明白的时候，相信快乐也会随之而来，为了减少痛苦，更快的带来快乐，在这里希望通过这篇文章对觉得困难的朋友有一个帮助。

本文以spring框架的XmlBeanFactory为入手点进行分析，希望能够以尽量简洁明了的方式给予有需要的朋友一定的帮助。

首先来打开该类的代码，我们将看到如下代码：

Java代码 复制代码
  1. public class XmlBeanFactory extends DefaultListableBeanFactory {   
  2.   
  3.     private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);   
  4.   
  5.     public XmlBeanFactory(Resource resource) throws BeansException {   
  6.         this(resource, null);   
  7.     }   
  8.   
  9.     public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {   
  10.         super(parentBeanFactory);   
  11.         this.reader.loadBeanDefinitions(resource);   
  12.     }   
  13.   
  14. }  
public class XmlBeanFactory extends DefaultListableBeanFactory {

	private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

	public XmlBeanFactory(Resource resource) throws BeansException {
		this(resource, null);
	}

	public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
		super(parentBeanFactory);
		this.reader.loadBeanDefinitions(resource);
	}

}



这个类的代码很简单，一个成员对象加两个构造函数，从这里我们可以看出，最重要的地方在于最后一个构造函数：

Java代码 复制代码
  1. super(parentBeanFactory);   
  2. this.reader.loadBeanDefinitions(resource);   
	super(parentBeanFactory);
	this.reader.loadBeanDefinitions(resource);



第一句就是将父亲工厂交给父类的构造函数，实际上最后也就是把父工厂保存到类的parentBeanFactory成员对象中，这个对象是在AbstractBeanFactory抽象类中定义的，而这个父工厂也会一直传递到该抽象类进行保存。第二句就是整个类中最重要的地方了，顾名思义，它的目的是通过XmlBeanDefinitionReader这个XML的Reader从资源resource中（也就是你的配置文件）读取bean的定义。接下来我们打开XmlBeanDefinitionReader的loadBeanDefinitions方法，我们可看到在这个方法里代码就一行，调用了一个同名不同参的方法，而参数是EncodedResource的一个实例，这个类实际上是Resource的一个包装类，用来保存资源的Encode的，那接下来我们再看被调用的loadBeanDefinitions方法，这个方法里最主要的部分就是：

Java代码 复制代码
  1. InputSource inputSource = new InputSource(inputStream);   
  2.         if (encodedResource.getEncoding() != null) {   
  3.             inputSource.setEncoding(encodedResource.getEncoding());   
  4.         }   
  5. return doLoadBeanDefinitions(inputSource, encodedResource.getResource());   
		InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
		return doLoadBeanDefinitions(inputSource, encodedResource.getResource());



这里的目的是将资源包装成一个InputSource，连同Resource作为参数传递到doLoadBeanDefinitions方法

Java代码 复制代码
  1. DocumentBuilderFactory factory = createDocumentBuilderFactory();   
  2. if (logger.isDebugEnabled()) {   
  3.     logger.debug("Using JAXP implementation [" + factory + "]");   
  4. }   
  5. DocumentBuilder builder = createDocumentBuilder(factory);   
  6. Document doc = builder.parse(inputSource);   
  7. return registerBeanDefinitions(doc, resource);   
			DocumentBuilderFactory factory = createDocumentBuilderFactory();
			if (logger.isDebugEnabled()) {
				logger.debug("Using JAXP implementation [" + factory + "]");
			}
			DocumentBuilder builder = createDocumentBuilder(factory);
			Document doc = builder.parse(inputSource);
			return registerBeanDefinitions(doc, resource);



这个方法的目的一目了然，就是为了将资源解释成为Document对象，然后调用registerBeanDefinitions方法，这里不做详细解释，不了解的话请去看看关于JAXP的介绍。接下来我们打开registerBeanDefinitions方法：

Java代码 复制代码
  1. public int registerBeanDefinitions(Document doc, Resource resource) throws BeansException {   
  2.     XmlBeanDefinitionParser parser =   
  3.             (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);   
  4.     return parser.registerBeanDefinitions(this, doc, resource);   
  5. }  
	public int registerBeanDefinitions(Document doc, Resource resource) throws BeansException {
		XmlBeanDefinitionParser parser =
				(XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
		return parser.registerBeanDefinitions(this, doc, resource);
	}



这里创建了一个XmlBeanDefinitionParser接口的实现，这个接口的具体类是DefaultXmlBeanDefinitionParser，这个接口很简单，只有registerBeanDefinitions一个方法，这个方法的作用也很明了，就是用来注册Bean的定义的，所以说类和方法的名字一定要起得有意义，这样可以让人一看就大概了解其作用，减少了很多阅读代码的痛苦。废话不多说，我们打开DefaultXmlBeanDefinitionParser的registerBeanDefinitions方法，这个类就是解释XML配置文件的核心类了，打开registerBeanDefinitions方法后我们看到如下代码：

Java代码 复制代码
  1. public int registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)   
  2.         throws BeanDefinitionStoreException {   
  3.   
  4.     this.beanDefinitionReader = reader;   
  5.     this.resource = resource;   
  6.   
  7.     logger.debug("Loading bean definitions");   
  8.     Element root = doc.getDocumentElement();   
  9.     //初始化根元素   
  10.     initDefaults(root);   
  11.     if (logger.isDebugEnabled()) {   
  12.         logger.debug("Default lazy init '" + getDefaultLazyInit() + "'");   
  13.         logger.debug("Default autowire '" + getDefaultAutowire() + "'");   
  14.         logger.debug("Default dependency check '" + getDefaultDependencyCheck() + "'");   
  15.     }   
  16.   
  17.     preProcessXml(root);//一个空方法用于扩展   
  18.     int beanDefinitionCount = parseBeanDefinitions(root);//解释配置的主要方法   
  19.     if (logger.isDebugEnabled()) {   
  20.         logger.debug("Found " + beanDefinitionCount + " <bean> elements in " + resource);   
  21.     }   
  22.     postProcessXml(root); //一个空方法用于扩展   
  23.   
  24.     return beanDefinitionCount;   
  25. }  
	public int registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)
			throws BeanDefinitionStoreException {

		this.beanDefinitionReader = reader;
		this.resource = resource;

		logger.debug("Loading bean definitions");
		Element root = doc.getDocumentElement();
		//初始化根元素
		initDefaults(root);
		if (logger.isDebugEnabled()) {
			logger.debug("Default lazy init '" + getDefaultLazyInit() + "'");
			logger.debug("Default autowire '" + getDefaultAutowire() + "'");
			logger.debug("Default dependency check '" + getDefaultDependencyCheck() + "'");
		}

		preProcessXml(root);//一个空方法用于扩展
		int beanDefinitionCount = parseBeanDefinitions(root);//解释配置的主要方法
		if (logger.isDebugEnabled()) {
			logger.debug("Found " + beanDefinitionCount + " <bean> elements in " + resource);
		}
		postProcessXml(root); //一个空方法用于扩展

		return beanDefinitionCount;
	}



在这个方法当中，主要用于解释定义的有两个方法，一个是initDefaults，一个是parseBeanDefinitions，第一个方法是用来解释根元素的属性的，例如lazy-init, autowire等，而parseBeanDefinitions就是用来解释具体的bean定义了，方法代码如下：

Java代码 复制代码
  1. protected int parseBeanDefinitions(Element root) throws BeanDefinitionStoreException {   
  2.     NodeList nl = root.getChildNodes();   
  3.     int beanDefinitionCount = 0;   
  4.     for (int i = 0; i < nl.getLength(); i++) {   
  5.         Node node = nl.item(i);   
  6.         if (node instanceof Element) {   
  7.             Element ele = (Element) node;   
  8.             if (IMPORT_ELEMENT.equals(node.getNodeName())) {   
  9.                 importBeanDefinitionResource(ele);   
  10.             }   
  11.             else if (ALIAS_ELEMENT.equals(node.getNodeName())) {   
  12.                 String name = ele.getAttribute(NAME_ATTRIBUTE);   
  13.                 String alias = ele.getAttribute(ALIAS_ATTRIBUTE);   
  14.                 this.beanDefinitionReader.getBeanFactory().registerAlias(name, alias);   
  15.             }   
  16.             else if (BEAN_ELEMENT.equals(node.getNodeName())) {   
  17.                 beanDefinitionCount++;   
  18.                 BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);   
  19.                 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());   
  20.             }   
  21.         }   
  22.     }   
  23.     return beanDefinitionCount;   
  24. }  
	protected int parseBeanDefinitions(Element root) throws BeanDefinitionStoreException {
		NodeList nl = root.getChildNodes();
		int beanDefinitionCount = 0;
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (node instanceof Element) {
				Element ele = (Element) node;
				if (IMPORT_ELEMENT.equals(node.getNodeName())) {
					importBeanDefinitionResource(ele);
				}
				else if (ALIAS_ELEMENT.equals(node.getNodeName())) {
					String name = ele.getAttribute(NAME_ATTRIBUTE);
					String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
					this.beanDefinitionReader.getBeanFactory().registerAlias(name, alias);
				}
				else if (BEAN_ELEMENT.equals(node.getNodeName())) {
					beanDefinitionCount++;
					BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
					BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
				}
			}
		}
		return beanDefinitionCount;
	}



其他标签具体如何被解释这里就不多说，相信大家也能看得懂，这里主要讲一下解释bean的的处理，我们注意以下代码：

Java代码 复制代码
  1. else if (BEAN_ELEMENT.equals(node.getNodeName())) {   
  2.     beanDefinitionCount++;   
  3.     BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);   
  4.     BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());   
  5. }   
				else if (BEAN_ELEMENT.equals(node.getNodeName())) {
					beanDefinitionCount++;
					BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
					BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
				}


这里是当碰到一个bean标签的时候所进行的处理，也既是对bean的定义进行解释，可以看到parseBeanDefinitionElement方法的第一个参数就是bean则个元素，第二个参数表示该bean是否为内置的bean，从这里进行解释的bean都不可能是内置的，所以这里直接以false为参数，打开parseBeanDefinitionElement方法，就可以看到这个方法里就是对bean的内部的解释，也很简单，也不多讲了，呵呵（下班时间已经到了，所以就写这么多了，基本的流程也就这样，没什么特别难的地方。），对了，最后还有一点就是解释完后，bean的定义将会被保存到beanFactory中，这个beanFactory的实现就是XmlBeanFactory了，该beanFactory是在new的时候被传递到reader中的，就是该类中以下这行代码：

Java代码 复制代码
  1. private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);  
	private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);



好了，就这么多了，本文只作为参考，只讲解了如何加载bean定义这块，只作为一个参考，希望对其他朋友能有所帮助吧，因为时间匆忙，有错漏的地方请指正。

分享到：
| Struts2标签库
评论
1 楼 xlongbuilder 2010-03-22  
最近打算看下spring 的源码 问下你这里分析的是什么版本？
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring源码解析思维导图

    XmlBeanFactory继承自DefaultListableBeanFactory，而DefaultListableBeanFactory是整个bean加载的核心部分，是Spring注册及加载bean的默认实现，XmlBeanFactory与DefaultListableBeanFactory不同的地方其实是在...

    shirayner#java-knowledge-hierarchy#Spring源码分析_100_容器的基本实现 - 副本1

    前言一、两个核心类XmlBeanFactory 继承向 DefaultListableBeanFactory ，而 DefaultListableBeanFac

    java8源码-spring_master:spring源码探究

    spring源码剖析，大部分都是基于Springframework5.0 交代： spring最核心的两个类： DefaultListableBeanFactory && XmlBeanDefinitionReader 容器的基础XMLBeanFactory XmlBeanFactory继承自...

    Spring XmlBeanFactory 容器的基本实现.doc

    Spring XmlBeanFactory 容器的基本实现.doc

    spring2.5.6源码

    rar包内含有spring2.5.6源码，解压即可使用 源代码分析，是一件既痛苦又快乐的事情，看别人写的代码是通过的，但当你能够看明白的时候，相信快乐也会随之而来，为了减少痛苦，更快的带来快乐，在这里希望通过这篇...

    Spring面试题含答案.pdf

    6. XMLBeanFactory 7. 解释 AOP 模块 8. 解释 JDBC 抽象和 DAO 模块 9. 解释对象/关系映射集成模块 10. 解释 WEB 模块 12. Spring 配置文件 13. 什么是 Spring IOC 容器？ 14. IOC 的优点是什么？ 15. ...

    Spring_依赖注入_面向接口编程_不同加载方式

    本项目为Java项目，使用Spring实现依赖注入，实现采用ApplicationContext，不再直接使用XmlBeanFactory方式。适合初学者了解Spring依赖注入的实现。

    spring AOP

    import org.springframework.beans.factory.xml.XmlBeanFactory; import org.springframework.core.io.ClassPathResource; import org.springframework.core.io.Resource; import com.icss.dao.StudentDao; import ...

    Spring面试题

    spring 的优点？ 1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦 2.可以使用容易提供的众多服务，如事务管理，消息服务等 3.容器提供单例模式支持 4.容器提供了AOP技术，利用它很容易实现如权限拦截，...

    SPRING API 2.0.CHM

    All Classes AbstractAdvisorAutoProxyCreator AbstractApplicationContext AbstractApplicationEventMulticaster AbstractAspectJAdvice AbstractAspectJAdvisorFactory AbstractAspectJAdvisorFactory....

    Spring3ProjectScopePrototype

    使用applicationContext.xml定义bean Spring需要Spring JAR / Libraries和JDK Libraries来运行基于Spring的应用程序我们需要一个驱动程序类[XmlBeanFactory]来运行Spring容器[IOC]，该容器实现了BeanFactory接口 &...

    maven相关资料

    // BeanFactory factory = new XmlBeanFactory(resource); // 用classpath路径 // ApplicationContext factory = new ClassPathXmlApplicationContext("classpath:appcontext.xml"); // ApplicationContext ...

Magicbox
Global site tag (gtag.js) - Google Analytics