spring源码-bean之初始化-1-白红宇

　　一、spring的IOC控制反转：控制反转——Spring通过一种称作控制反转（IOC）的技术促进了松耦合。当应用了IOC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。说白了就是原本需要手动去创建和管理的对象，现在交给容器了。在容器的基础上，实现对象的控制。这个方式也很好的减少了开发者在框架上面的时间，更多关注点在业务逻辑上面。

　　二、这表博客的主要目的是研究，bean容器的初始化，会在最基本的bean初始化作源码的解析和分析。如何存在不妥当的地方，还请指出！

　　三、BeanFactory是spring的核心，通过工厂的模式来创建和使用bean。

　　四、我们都知道spring的bean初始化，依赖xml文件来实现的，所以这里重点讲解XmlBeanFactory的初始化过程。可能有人会问为什么不是ApplicationContext，相对于ApplicationContext，XmlBeanFactory是基础的bean初始化过程，后续我会单独将ApplicationContext又做了哪些动作。

　　五、源码解读

　　1）创建xml配置文件spring-bean.xml（这里省略User,，重点不在这里）

　　2）开始创建对象

package com.pinnet.bean;import org.springframework.beans.factory.xml.XmlBeanFactory;import org.springframework.core.io.ClassPathResource;import org.springframework.core.io.Resource;public class Test {    public static void main(String[] args) {        //读取资源        Resource resource = new ClassPathResource("spring-bean.xml");        //初始化容器        new XmlBeanFactory(resource);    }}

　　3）初始化XmlBeanFactory

private final XmlBeanDefinitionReader reader;    public XmlBeanFactory(Resource resource) throws BeansException {        this(resource, (BeanFactory)null);    }    public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {        super(parentBeanFactory);        //用XmlBeanDefinitionReader，来进行加载        this.reader = new XmlBeanDefinitionReader(this);        //解析资源        this.reader.loadBeanDefinitions(resource);    }

　　4）loadBeanDefinitions

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    //包装成EncodedResource        return this.loadBeanDefinitions(new EncodedResource(resource));    }    public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {        Assert.notNull(encodedResource, "EncodedResource must not be null");        if (this.logger.isInfoEnabled()) {            this.logger.info("Loading XML bean definitions from " + encodedResource.getResource());        }        Set
     
       currentResources = (Set)this.resourcesCurrentlyBeingLoaded.get();        if (currentResources == null) {            currentResources = new HashSet(4);            this.resourcesCurrentlyBeingLoaded.set(currentResources);        }        if (!((Set)currentResources).add(encodedResource)) {            throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");        } else {            int var6;            try {
    //转换成InputStream流                InputStream inputStream = encodedResource.getResource().getInputStream();                try {                    InputSource inputSource = new InputSource(inputStream);                    if (encodedResource.getEncoding() != null) {                        inputSource.setEncoding(encodedResource.getEncoding());                    }                    //进一步解析                    var6 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());                } finally {                    inputStream.close();                }            } catch (IOException var15) {                throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), var15);            } finally {                ((Set)currentResources).remove(encodedResource);                if (((Set)currentResources).isEmpty()) {                    this.resourcesCurrentlyBeingLoaded.remove();                }            }            return var6;        }    }

　　5）doLoadBeanDefinitions

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {        try {            int validationMode = this.getValidationModeForResource(resource); //读取xml为doc            Document doc = this.documentLoader.loadDocument(inputSource, this.getEntityResolver(), this.errorHandler, validationMode, this.isNamespaceAware()); //注册BeanDefinition            return this.registerBeanDefinitions(doc, resource);        } catch (BeanDefinitionStoreException var5) {            throw var5;        } catch (SAXParseException var6) {            throw new XmlBeanDefinitionStoreException(resource.getDescription(), "Line " + var6.getLineNumber() + " in XML document from " + resource + " is invalid", var6);        } catch (SAXException var7) {            throw new XmlBeanDefinitionStoreException(resource.getDescription(), "XML document from " + resource + " is invalid", var7);        } catch (ParserConfigurationException var8) {            throw new BeanDefinitionStoreException(resource.getDescription(), "Parser configuration exception parsing XML from " + resource, var8);        } catch (IOException var9) {            throw new BeanDefinitionStoreException(resource.getDescription(), "IOException parsing XML document from " + resource, var9);        } catch (Throwable var10) {            throw new BeanDefinitionStoreException(resource.getDescription(), "Unexpected exception parsing XML document from " + resource, var10);        }    }

　　6）registerBeanDefinitions

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {        this.readerContext = readerContext;        this.logger.debug("Loading bean definitions");        Element root = doc.getDocumentElement();        BeanDefinitionParserDelegate delegate = this.createHelper(readerContext, root); 　　　　 //此方法用于提供子类处理之用        this.preProcessXml(root);        this.parseBeanDefinitions(root, delegate); 　　　　　//此方法用于提供子类处理之用        this.postProcessXml(root);    }

　　7）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;                    if (delegate.isDefaultNamespace(ele)) {
    　　　　　　　　　　　　　　//默认标签解析                        this.parseDefaultElement(ele, delegate);                    } else {
    　　　　　　　　　　　　　　//自定义标签解析（这里后面讲，这个也是非常重要的拓展功能）　　　　　　　　                        delegate.parseCustomElement(ele);                    }                }            }        } else {            delegate.parseCustomElement(root);        }    }

　　8）parseDefaultElement（默认标签解析，这里关注bean）

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {        if (delegate.nodeNameEquals(ele, "import")) {            this.importBeanDefinitionResource(ele);        } else if (delegate.nodeNameEquals(ele, "alias")) {            this.processAliasRegistration(ele);        } else if (delegate.nodeNameEquals(ele, "bean")) {            this.processBeanDefinition(ele, delegate);        }    }

　　9）processBeanDefinition

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {        //这里主要是解析过程        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);        if (bdHolder != null) {            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);            try {                //这里注册bean到beanDefinitionMap，后面会看到                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());            } catch (BeanDefinitionStoreException var5) {                this.getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, var5);            }            this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));        }    }

　　a、parseBeanDefinitionElement

　　public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {        return this.parseBeanDefinitionElement(ele, (BeanDefinition)null);    }    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {        String id = ele.getAttribute("id");        String nameAttr = ele.getAttribute("name");        List
     
       aliases = new ArrayList();        if (StringUtils.hasLength(nameAttr)) {            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, ",; ");            aliases.addAll((Collection)Arrays.asList(nameArr));        }        String beanName = id;        if (!StringUtils.hasText(id) && !aliases.isEmpty()) {            beanName = (String)aliases.remove(0);            if (this.logger.isDebugEnabled()) {                this.logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases");            }        }        if (containingBean == null) {            //检查id和别名是否重复            this.checkNameUniqueness(beanName, aliases, ele);        }        //解析过程        AbstractBeanDefinition beanDefinition = this.parseBeanDefinitionElement(ele, beanName, containingBean);        if (beanDefinition != null) {            if (!StringUtils.hasText(beanName)) {                try {                    if (containingBean != null) {                        beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);                    } else {                        //生成beanName                        beanName = this.readerContext.generateBeanName(beanDefinition);                        String beanClassName = beanDefinition.getBeanClassName();                        if (beanClassName != null && beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() && 　　　　　　　　　　　　　　　　!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {                            aliases.add(beanClassName);                        }                    }                    if (this.logger.isDebugEnabled()) {                        this.logger.debug("Neither XML 'id' nor 'name' specified - using generated bean name [" + beanName + "]");                    }                } catch (Exception var9) {                    this.error(var9.getMessage(), ele);                    return null;                }            }            String[] aliasesArray = StringUtils.toStringArray(aliases);            //将别名和beanName放入BeanDefinitionHolder            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);        } else {            return null;        }    }

　　parseBeanDefinitionElement（进一步解析过程，可以自己查看源码，这里不讲解）

public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {        this.parseState.push(new BeanEntry(beanName));        String className = null;        if (ele.hasAttribute("class")) {            className = ele.getAttribute("class").trim();        }        try {            String parent = null;            if (ele.hasAttribute("parent")) {                parent = ele.getAttribute("parent");            }            //创建GenericBeanDefinition            AbstractBeanDefinition bd = this.createBeanDefinition(className, parent);            //解析bean上面的默认元素            this.parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, "description"));            //meta            this.parseMetaElements(ele, bd);            //lookup-method            this.parseLookupOverrideSubElements(ele, bd.getMethodOverrides());            //replaced-method            this.parseReplacedMethodSubElements(ele, bd.getMethodOverrides());            //constructor-arg            this.parseConstructorArgElements(ele, bd);            //property            this.parsePropertyElements(ele, bd);            //qualifier            this.parseQualifierElements(ele, bd);            bd.setResource(this.readerContext.getResource());            bd.setSource(this.extractSource(ele));            //所有解析过后的元素全部放在AbstractBeanDefinition里面            AbstractBeanDefinition var8 = bd;            return var8;        } catch (ClassNotFoundException var13) {            this.error("Bean class [" + className + "] not found", ele, var13);        } catch (NoClassDefFoundError var14) {            this.error("Class that bean class [" + className + "] depends on not found", ele, var14);        } catch (Throwable var15) {            this.error("Unexpected failure during bean definition parsing", ele, var15);        } finally {            this.parseState.pop();        }        return null;    }

　　b、registerBeanDefinition（将AbstractBeanDefinition的相关数据放入beanDefinitionMap）

public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {        String beanName = definitionHolder.getBeanName();        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());        String[] aliases = definitionHolder.getAliases();        if (aliases != null) {            String[] var7 = aliases;            int var6 = aliases.length;            for(int var5 = 0; var5 < var6; ++var5) {                String aliase = var7[var5];                registry.registerAlias(beanName, aliase);            }        }    }

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 var6) {                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", var6);            }        }        Map var3 = this.beanDefinitionMap;        synchronized(this.beanDefinitionMap) {            Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);            if (oldBeanDefinition != null) {                if (!this.allowBeanDefinitionOverriding) {                    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName + "': There is already [" + oldBeanDefinition + "] bound.");                }                if (this.logger.isInfoEnabled()) {                    this.logger.info("Overriding bean definition for bean '" + beanName + "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");                }            } else {                this.beanDefinitionNames.add(beanName);                this.frozenBeanDefinitionNames = null;            }            //将beanName和beanDefinition形成键值对的形式，保存在Map中            this.beanDefinitionMap.put(beanName, beanDefinition);            this.resetBeanDefinition(beanName);        }    }

　　六、好了，这就是源码的实现过程，中间省略了很多的判定和实现过程。主要的流程，基本上就是这样。这里重点注意几个点，也是对流程的梳理

　　1）初始化XmlBeanFactory，需要注意XmlBeanDefinitionReader：这是整个解读过程的关键

　　2）然后就是字符集包装，然后形成流EncodedResource、inputSource

　　3）解析xml，基本上是通过spring的DefaultDocumentLoader实现的，通过对Document文档的解析来实现标签和元素的解析

　　4）判断是否是默认标签是通过xml的Namespace来实现的，默认Namespace的读取目录是通过DefaultNamespaceHandlerResolver来实现的，也就是读取spring.handlers和spring.schemas，后续会讲到这两个文件的作用

　　public boolean isDefaultNamespace(String namespaceUri) {        return !StringUtils.hasLength(namespaceUri) || "http://www.springframework.org/schema/beans".equals(namespaceUri);    }

　　protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {        return new DefaultNamespaceHandlerResolver(this.getResourceLoader().getClassLoader());    }

　　spring.handlers

http\://www.springframework.org/schema/p=org.springframework.beans.factory.xml.SimplePropertyNamespaceHandlerhttp\://www.springframework.org/schema/util=org.springframework.beans.factory.xml.UtilNamespaceHandler

　　spring.schemas

http\://www.springframework.org/schema/beans/spring-beans-2.0.xsd=org/springframework/beans/factory/xml/spring-beans-2.0.xsdhttp\://www.springframework.org/schema/beans/spring-beans-2.5.xsd=org/springframework/beans/factory/xml/spring-beans-2.5.xsdhttp\://www.springframework.org/schema/beans/spring-beans-3.0.xsd=org/springframework/beans/factory/xml/spring-beans-3.0.xsdhttp\://www.springframework.org/schema/beans/spring-beans.xsd=org/springframework/beans/factory/xml/spring-beans-3.0.xsdhttp\://www.springframework.org/schema/tool/spring-tool-2.0.xsd=org/springframework/beans/factory/xml/spring-tool-2.0.xsdhttp\://www.springframework.org/schema/tool/spring-tool-2.5.xsd=org/springframework/beans/factory/xml/spring-tool-2.5.xsdhttp\://www.springframework.org/schema/tool/spring-tool-3.0.xsd=org/springframework/beans/factory/xml/spring-tool-3.0.xsdhttp\://www.springframework.org/schema/tool/spring-tool.xsd=org/springframework/beans/factory/xml/spring-tool-3.0.xsdhttp\://www.springframework.org/schema/util/spring-util-2.0.xsd=org/springframework/beans/factory/xml/spring-util-2.0.xsdhttp\://www.springframework.org/schema/util/spring-util-2.5.xsd=org/springframework/beans/factory/xml/spring-util-2.5.xsdhttp\://www.springframework.org/schema/util/spring-util-3.0.xsd=org/springframework/beans/factory/xml/spring-util-3.0.xsdhttp\://www.springframework.org/schema/util/spring-util.xsd=org/springframework/beans/factory/xml/spring-util-3.0.xsd

　　5）解析bean标签，是生产一个GenericBeanDefinition这个类是继承AbstractBeanDefinition生产BeanDefinition的过程其实就是讲标签里面的元素进行解析放入的过程

　　6）注册的过程是放在DefaultListableBeanFactory里面的beanDefinitionMap，是不是有点奇怪过程并没有DefaultListableBeanFactory。在源码的9）中使用了BeanDefinitionRegistry ，而这个BeanDefinitionRegistry 也是我们最开始使用的XmlBeanFactory，但是XmlBeanFactory，并没有太多的实现。看来一个结构：

　　其实最开始调用XmlBeanFactory的时候就已经使用了DefaultListableBeanFactory，值不够是继承关系而已。所以这里基本上所有的数据都在DefaultListableBeanFactory里面了

　　7）最后解析过程就到这里，主要数据全部在DefaultListableBeanFactory的beanDefinitionMap里面。

　　8）注意一点，别名的加载过程也很重要，这里不多介绍，多想法自己查看源码

　　七、容器的初始化基本上就是这样了，主要是梳理流程和spring在IOC的控制中做了什么。