Spring中BeanFactory解析bean详解
在该文中来讲讲spring框架中beanfactory解析bean的过程，该文之前在小编原文中有发表过，先来看一个在spring中一个基本的bean定义与使用。
package bean;
public class testbean {
private string beanname = "beanname";
public string getbeanname() {
return beanname;
}
public void setbeanname(string beanname) {
this.beanname = beanname;
}
}
spring配置文件root.xml定义如下：
<?xml version="1.0" encoding="utf-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd"> <bean id="testbean" class="bean.testbean"> </beans>
下面使用xmlbeanfactory来获取该bean：
public class beantest {
private static final java.util.logging.logger logger = loggerfactory.getlogger(beantest.class);
@test
public void getbeantest() {
beanfactory factory = new xmlbeanfactory(new classpathresource("root.xml"));
testbean bean = factory.getbean("testbean");
logger.info(bean.getbeanname);
}
}
这个单元测试运行结果就是输出beanname，上面就是spring最基本的bean的获取操作，这里我用beanfactory作为容器来获取bean的操作并不多见，在企业开发中一般是使用功能更完善的applicationcontext，这里先不讨论这个，下面重点讲解使用beanfactory获取bean的过程。
现在就来分析下上面的测试代码，看看spring到底为我们做了什么工作，上面代码完成功能的流程不外乎如此：
1. 读取spring配置文件root.xml；
2. 根据root.xml中的bean配置找到对应的类的配置，并实例化；
3. 调用实例化后的对象输出结果。
先来看看xmlbeanfactory源码：
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);
}
}
从上面可以看出xmlbeanfactory继承了defaultlistablebeanfactory，defaultlistablebeanfactory是spring注册加载bean的默认实现，它是整个bean加载的核心部分，xmlbeanfactory与它的不同点就是xmlbeanfactory使用了自定义的xml读取器xmlbeandefinitionreader，实现了自己的beandefinitionreader读取。
xmlbeanfactory加载bean的关键就在于xmlbeandefinitionreader，下面看看xmlbeandefinitionreader的源码（只列出部分）：
public class xmlbeandefinitionreader extends abstractbeandefinitionreader {
private class<?> documentreaderclass = defaultbeandefinitiondocumentreader.class;
private problemreporter problemreporter = new failfastproblemreporter();
private readereventlistener eventlistener = new emptyreadereventlistener();
private sourceextractor sourceextractor = new nullsourceextractor();
private namespacehandlerresolver namespacehandlerresolver;
private documentloader documentloader = new defaultdocumentloader();
private entityresolver entityresolver;
private errorhandler errorhandler = new simplesaxerrorhandler(logger);
}
xmlbeandefinitionreader继承自abstractbeandefinitionreader，下面是abstractbeandefinitionreader的源码（只列出部分）：
public abstract class abstractbeandefinitionreader implements environmentcapable, beandefinitionreader {
protected final log logger = logfactory.getlog(getclass());
private final beandefinitionregistry registry;
private resourceloader resourceloader;
private classloader beanclassloader;
private environment environment;
private beannamegenerator beannamegenerator = new defaultbeannamegenerator();
}
xmlbeandefinitionreader主要通过以下三步来加载spring配置文件中的bean：
1. 通过继承自abstractbeandefinitionreader中的方法，使用resourloader将资源文件（root.xml）路径转换为对应的resource文件；
2. 通过documentloader对resource文件进行转换，将resource文件转换为ducument文件；
3. 通过defaultbeandefinitiondocumentreader类对document进行解析，最后再对解析后的element进行解析。
了解以上基础后，接下来详细分析下一开始例子中的代码：
beanfactory factory = new xmlbeanfactory(new classpathresource("root.xml"));
先看看下面xmlbeanfactory初始化的时序图来进一步了解这段代码的执行，
在这里可以看出beantest测试类通过向classpathresource的构造方法传入spring的配置文件构造一个resource资源文件的实例对象，再通过这个resource资源文件来构造我们想要的xmlbeanfactory实例。在前面xmlbeanfactory源码中的构造方法可以看出，
public xmlbeanfactory(resource resource) throws beansexception {
this(resource, null);
}
public xmlbeanfactory(resource resource, beanfactory parentbeanfactory) throws beansexception {
super(parentbeanfactory);
this.reader.loadbeandefinitions(resource);
}
this.reader.loadbeandefinition(resource)就是资源加载真正的实现，时序图中xmlbeandefinitionreader加载数据就是在这里完成的。
接下来跟进this.reader.loadbeandefinition(resource)方法里面，
public class xmlbeandefinitionreader extends abstractbeandefinitionreader {
@override
public int loadbeandefinitions(resource resource) throws beandefinitionstoreexception {
return loadbeandefinitions(new encodedresource(resource));
}
}
在loadbeandefinition(resource)方法里对资源文件resource使用encodedresource进行编码处理后继续传入loadbeandefinitions方法，继续跟进loadbeandefinitions(new encodedresource(resource))方法源码：
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);
this.resourcescurrentlybeingloaded.set(currentresources);
}
if (!currentresources.add(encodedresource)) {
throw new beandefinitionstoreexception(
"detected cyclic loading of " + encodedresource + " - check your import definitions!");
}
try {
// 从resource中获取对应的inputstream，用于下面构造inputsource
inputstream inputstream = encodedresource.getresource().getinputstream();
try {
inputsource inputsource = new inputsource(inputstream);
if (encodedresource.getencoding() != null) {
inputsource.setencoding(encodedresource.getencoding());
}
// 调用doloadbeandefinitions方法
return doloadbeandefinitions(inputsource, encodedresource.getresource());
}
finally {
inputstream.close();
}
}
catch (ioexception ex) {
throw new beandefinitionstoreexception(
"ioexception parsing xml document from " + encodedresource.getresource(), ex);
}
finally {
currentresources.remove(encodedresource);
if (currentresources.isempty()) {
this.resourcescurrentlybeingloaded.remove();
}
}
}
继续跟进doloadbeandefinitions(inputsource, encodedresource.getresource())方法，这是整个bean加载过程的核心方法，在这个方法执行bean的加载。
protected int doloadbeandefinitions(inputsource inputsource, resource resource)
throws beandefinitionstoreexception {
try {
document doc = doloaddocument(inputsource, resource);
return registerbeandefinitions(doc, resource);
}
/* 省略一堆catch */
}
跟进doloaddocument(inputsource, resource)源码：
protected document doloaddocument(inputsource inputsource, resource resource) throws exception {
return this.documentloader.loaddocument(inputsource, getentityresolver(), this.errorhandler,
getvalidationmodeforresource(resource), isnamespaceaware());
}
在doloaddocument(inputsource, resource)方法里就使用到了前面讲的documentloader加载document，这里documentloader是个接口，真正调用的是其实现类defaultdocumentloader的loaddocument方法，跟进源码：
public class defaultdocumentloader implements documentloader {
@override
public document loaddocument(inputsource inputsource, entityresolver entityresolver,
errorhandler errorhandler, int validationmode, boolean namespaceaware) throws exception {
documentbuilderfactory factory = createdocumentbuilderfactory(validationmode, namespaceaware);
if (logger.isdebugenabled()) {
logger.debug("using jaxp provider [" + factory.getclass().getname() + "]");
}
documentbuilder builder = createdocumentbuilder(factory, entityresolver, errorhandler);
return builder.parse(inputsource);
}
}
从源码可以看出这里先创建documentbuilderfactory，再用它创建documentbuilder，进而解析inputsource来返回document对象。得到document对象后就可以准备注册我们的bean信息了。
在上面的doloadbeandefinitions(inputsource, encodedresource.getresource())方法中拿到document对象后下面就是执行registerbeandefinitions(doc, resource)方法了，看源码：
public int registerbeandefinitions(document doc, resource resource) throws beandefinitionstoreexception {
beandefinitiondocumentreader documentreader = createbeandefinitiondocumentreader();
documentreader.setenvironment(getenvironment());
// 还没注册bean前的beandefinition加载个数
int countbefore = getregistry().getbeandefinitioncount();
// 加载注册bean
documentreader.registerbeandefinitions(doc, createreadercontext(resource));
// 本次加载注册的beandefinition个数
return getregistry().getbeandefinitioncount() - countbefore;
}
这里的doc就是上面的loaddocument方法加载转换来的，从上面可以看出主要工作是交给beandefinitiondocumentreader的registerbeandefinitions()方法实现的，这里beandefinitiondocumentreader是个接口，注册bean功能在默认实现类defaultbeandefinitiondocumentreader的该方法实现，跟进它的源码：
@override
public void registerbeandefinitions(document doc, xmlreadercontext readercontext) {
this.readercontext = readercontext;
logger.debug("loading bean definitions");
element root = doc.getdocumentelement();
doregisterbeandefinitions(root);
}
到这里通过doc.getdocumentelement()获得element对象后，交给doregisterbeandefinitions()方法后就是真正执行xml文档的解析了，跟进doregisterbeandefinitions()方法源码：
protected void doregisterbeandefinitions(element root) {
beandefinitionparserdelegate parent = this.delegate;
this.delegate = createdelegate(getreadercontext(), root, parent);
if (this.delegate.isdefaultnamespace(root)) {
string profilespec = root.getattribute(profile_attribute);
if (stringutils.hastext(profilespec)) {
string[] specifiedprofiles = stringutils.tokenizetostringarray(
profilespec, beandefinitionparserdelegate.multi_value_attribute_delimiters);
if (!getreadercontext().getenvironment().acceptsprofiles(specifiedprofiles)) {
return;
}
}
}
preprocessxml(root);
parsebeandefinitions(root, this.delegate);
postprocessxml(root);
this.delegate = parent;
}
到这里处理流程就很清晰了，先是对profile进行处理，之后就通过parsebeandefinitions()方法进行文档的解析操作，跟进parsebeandefinitions()方法源码：
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;
// 下面对bean进行处理
if (delegate.isdefaultnamespace(ele)) {
parsedefaultelement(ele, delegate);
}
else {
delegate.parsecustomelement(ele);
}
}
}
}
else {
delegate.parsecustomelement(root);
}
}
上面if-else语句块中的parsedefaultelement(ele, delegate)和delegate.parsecustomelement(ele)就是对spring配置文件中的默认命名空间和自定义命名空间进行解析用的。在spring的xml配置中，默认bean声明就如前面定义的：
<bean id="testbean" class="bean.testbean">
自定义的bean声明如：
<tx:annotation-driven />
xmlbeanfactory加载bean的整个过程基本就讲解到这里了。希望对大家的学习有所帮助，也希望大家多多支持。