一、环境准备
对于学习源码来讲，拿到一大堆的代码，脑袋里肯定是嗡嗡的，所以从代码实例进行跟踪调试未尝不是一种好的办法，此处，我们准备了一个小例子：
package com.zjl;
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void sayHello(){
System.out.println("hello "+this.name);
}
}
bean的定义：
<bean id="person" class="com.zjl.Person">
<property name="name" value="zhangsan"></property>
</bean>
从很久以前，spring的第一个例子惯性的我们都是用XmlBeanFactory来进行，测试代码如下：
XmlBeanFactory xmlBeanFactory=new XmlBeanFactory(new ClassPathResource("bean.xml"));
Person person=(Person)xmlBeanFactory.getBean("person");
person.sayHello();
不过，很可惜，这个类在后来的版本中被删除了，不过没关系，他的源码很简单：
public class XmlBeanFactory extends DefaultListableBeanFactory {
private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
/**
* Create a new XmlBeanFactory with the given resource,
* which must be parsable using DOM.
* @param resource XML resource to load bean definitions from
* @throws BeansException in case of loading or parsing errors
*/
public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, null);
}
/**
* Create a new XmlBeanFactory with the given input stream,
* which must be parsable using DOM.
* @param resource XML resource to load bean definitions from
* @param parentBeanFactory parent bean factory
* @throws BeansException in case of loading or parsing errors
*/
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
super(parentBeanFactory);
this.reader.loadBeanDefinitions(resource);
}
}
我们可以看到，只是他继承了DefaultListableBeanFactory ，并持有一个XmlBeanDefinitionReader的引用，然后调用了this.reader.loadBeanDefinitions(resource)方法。所以我们很容易根据这个源码将程序改造一下
DefaultListableBeanFactory beanFacory=new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader=new XmlBeanDefinitionReader(beanFacory);
reader.loadBeanDefinitions(new ClassPathResource("bean.xml"));
Person person=(Person)beanFacory.getBean("person");
person.sayHello();
二、源码解析
结合上一节的内容，在本章节，我们只是详细看下针对xml配置的bean的一个加载过程，并不会调用getBean方法具体生成bean的对象，入口程序我们锁定为reader.loadBeanDefinitions(new ClassPathResource("bean.xml"))
1、对resource进行了再次包装，添加编码和字符集
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
return loadBeanDefinitions(new EncodedResource(resource));
}
2、读取配置文件，将inputStream转化为sax的inputSource，并设置字符集
try {
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
//入口程序
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
inputStream.close();
}
}
3、进入doLoadBeanDefinitions方法，将inputSource转化为Dom解析的Document
Document doc = doLoadDocument(inputSource, resource);
return registerBeanDefinitions(doc, resource);
4、创建dom的读取方法DefaultBeanDefinitionDocumentReader的实例，，并获取bean的数量，使用registerBeanDefinitions加载bean，解析完成后，返回此次加载bean的数量，注：此处对resource再次做了封装，疑似注入一些监听函数，但是暂时不管他们
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
int countBefore = getRegistry().getBeanDefinitionCount();
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}
5、进入DefaultBeanDefinitionDocumentReader的registerBeanDefinitions方法，获取到配置文件的根节点beans，针对根节点开始遍历
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
Element root = doc.getDocumentElement();
doRegisterBeanDefinitions(root);
}
6、创建了一个delegate，并判断节点是否为NameSpaceURI-http://www.springframework.org/schema/beans
public boolean isDefaultNamespace(Node node) {
return isDefaultNamespace(getNamespaceURI(node));
}
7、如果是默认的，获取profile属性，此处资料上可以配置开发、生产或者测试环境，暂不深究
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)) {
if (logger.isInfoEnabled()) {
logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
"] not matching: " + getReaderContext().getResource());
}
return;
}
}
}
8、继续解析，在真正解析前后，可以使用pre和post方法对xml进行处理，此处均为空，只看parseBeanDefinitions方法即可
preProcessXml(root);
//入口
parseBeanDefinitions(root, this.delegate);
postProcessXml(root);
9、此处再次判断，root是否为默认的namespace，如果是，获取所有子节点，进行遍历子节点，并解析。如果根节点或者子节点不是默认的namespace，将使用delegate.parseCustomElement进行解析，由此可以看出，spring为我们预留了一个自定义配置文件解析的入口(此部分作为下一个章节重点分析)
此次我们只有默认的namespace的应用，所以进行解析他的Element的子节点，我们知道唯一一个子节点为“bean”
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)) {
//入口
parseDefaultElement(ele, delegate);
}
else {
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}
10、对子节点的解析分为4中情况，分别为import，alias，bean，beans，其中
beans：之前处理过，再次解析子节点即可
import：表示引入另外的配置文件资源进行解析，此处预留其他文件解析入口
alias：支持此格式<alias name="doSpring" alias="do"/>，是对一个bean起别名
bean:是我们目前解析的重点，进入下一步解析
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
//入口
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
11、根据节点，创建一个BeanDefinitionHolder，
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//入口
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
12、我们具体看下他的源码，可以知道它是根据Element的id，name等两个属性进行生成，如果有id，id作为beanName，如果id不存在，name的第一个作为beanName，其他作为别名，此处不再贴出，然后根据name和元素，创建一个AbstractBeanDefinition
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
13、 分别获得className、parent、descriptioString className = null; if (ele.hasAttribute(CLASS_ATTRIBUTE)) { className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
try {
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
//14、初始化GenericBeanDefinition
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
//15、设置bean的其他属性，包括单例，抽象，延迟加载、autowire、dependency-check、depends-on、autowire-candidate、primary、init-method、destroy-method、factory-method、factory-bean等属性，
此部分的特点是有一个默认值，但也通过系统默认设置
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
//解析子标签中的meta标签
parseMetaElements(ele, bd);
//解析look-up标签
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
//解析replaced-method标签
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
//constructor-arg标签，为了便于构造函数注入
parseConstructorArgElements(ele, bd);
//解析Property标签，根据value或者ref标签分别注入TypedStringValue或RuntimeBeanReference到PropertyValue中
parsePropertyElements(ele, bd);
//解析qualifier
parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
return bd;
}
14、与13一起，根据parentName和className创建GenericBeanDefinition的实例，此处classLoader不为null时候，似乎客户设置复杂的数据格式，暂时跳过
public static AbstractBeanDefinition createBeanDefinition(
String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException { GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setParentName(parentName);
if (className != null) {
if (classLoader != null) {
bd.setBeanClass(ClassUtils.forName(className, classLoader));
}
else {
bd.setBeanClassName(className);
}
}
return bd;
}
15、如果有其他标签，仍按照此方法继续处理。到此部分，我们已经解析完了配置文件中的所有标签
16、根据别名，beanDefinition beanName创建BeanDefinitionHolder
String[] aliasesArray = StringUtils.toStringArray(aliases);
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
17、对holder进行进一步装饰，主要装饰[autowire="default", autowire-candidate="default", class="com.zjl.Person", id="person", lazy-init="default"]等
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.将最终装饰后的BeanDefinition注入registry,
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
18、调用registerBeanDefinition，注入bean时，先做一个父类检测((AbstractBeanDefinition) beanDefinition).validate()
主要检测是否在配置文件中设置了factoryMethodName，
public void validate() throws BeanDefinitionValidationException {
if (!getMethodOverrides().isEmpty() && getFactoryMethodName() != null) {
throw new BeanDefinitionValidationException(
"Cannot combine static factory method with method overrides: " +
"the static factory method must create the instance");
}
if (hasBeanClass()) {
prepareMethodOverrides();
}
}
19、将beanDefinition放入map，beanName放入list，将alias也放到map
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
20、触发注入的事件，此处触发了第四部分注入的监听事件，由于创建时候使用的XmlBeanDefinitionReader的new XmlReaderContext(resource, this.problemReporter, this.eventListener,this.sourceExtractor, this, getNamespaceHandlerResolver());方法中的EmptyReaderEventListener方法均为空，所以不做任何事情，此处我们也知道了，可以在自定义reader的子类中注入新的监听类，可以得到其他通知
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
三、总结
1、到此为止，整个ioc的配置文件读取和解析过程以及完成，此处只有一个bean，如果有多个，会从根继续读取下一个子节点进行解析。，最终我们在DefaultListableBeanFactory里得到了bean的map，beanName的list，alias的map等，通过这些容器就可以得到配置文件中bean的内容，但如何在调用getBean的时候获得到需要的bean，需要我们在以后的学习中进一步阅读源码
2、在源码中我们可以看到除了自己配置的一些简单信息外，spring还有大量的默认配置和全局配置，这些配置的不同，是spring的各种功能的入口和配置，需要我们进行关注
3、学习过程中，还有很多暂时不明白的功能，只能先跳过