Spring源代码解析(一）：IOC容器

	public void parsePropertyElement(Element ele, BeanDefinition bd) {
		String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
		if (!StringUtils.hasLength(propertyName)) {
			error("Tag 'property' must have a 'name' attribute", ele);
			return;
		}
		this.parseState.push(new PropertyEntry(propertyName));
		try {
			if (bd.getPropertyValues().contains(propertyName)) {
				error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
				return;
			}
			Object val = parsePropertyValue(ele, bd, propertyName);
			PropertyValue pv = new PropertyValue(propertyName, val);
			parseMetaElements(ele, pv);
			pv.setSource(extractSource(ele));
			bd.getPropertyValues().addPropertyValue(pv);
		}
		finally {
			this.parseState.pop();
		}
	}

    public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
        String elementName = (propertyName != null) ?
                        "<property> element for property '" + propertyName + "'" :
                        "<constructor-arg> element";

        //这里取得这个Element的子元素值
        NodeList nl = ele.getChildNodes();
        Element subElement = null;
        for (int i = 0; i < nl.getLength(); i++) {
            if (nl.item(i) instanceof Element) {
                Element candidateEle = (Element) nl.item(i);
                //下面是对取得的子元素作的具体处理，取得subElement
                if (DESCRIPTION_ELEMENT.equals(candidateEle.getTagName())) {
                    // Keep going: we don't use this value for now.
                }
                else {
                    // Child element is what we're looking for.
                    if (subElement != null && !META_ELEMENT.equals(subElement.getTagName())) {
                        error(elementName + " must not contain more than one sub-element", ele);
                    }
                    subElement = candidateEle;
                }
            }
        }

        boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
        boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
        if ((hasRefAttribute && hasValueAttribute) ||
                ((hasRefAttribute || hasValueAttribute)) && subElement != null) {
            error(elementName +
                    " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
        }
        //如果这里取得的subElement是Ref　bean，生成一个RuntimeBeanReference持有这个bean的名字，但是并不持有ref bean对象。
        if (hasRefAttribute) {
            String refName = ele.getAttribute(REF_ATTRIBUTE);
            if (!StringUtils.hasText(refName)) {
                error(elementName + " contains empty 'ref' attribute", ele);
            }
            RuntimeBeanReference ref = new RuntimeBeanReference(refName);
            ref.setSource(extractSource(ele));
            return ref;
        }
        else if (hasValueAttribute) {
            return ele.getAttribute(VALUE_ATTRIBUTE);
        }

        if (subElement == null) {
            // Neither child element nor "ref" or "value" attribute found.
            error(elementName + " must specify a ref or value", ele);
        }
        //这里处理其他类型的属性，比如我们看到的List,Map,Set等等
        return parsePropertySubElement(subElement, bd);
    }

    public Object getBean(String name, Class requiredType, final Object[] args) throws BeansException {
        final String beanName = transformedBeanName(name);
        Object bean = null;
            ........

            // 这里检查是不是在父工厂里这个bean
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // Not found -> check parent.
                String nameToLookup = originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    //这里调用父工厂的getBean
                    return ((AbstractBeanFactory) parentBeanFactory).getBean(nameToLookup, requiredType, args);
                }
                else if (args == null) {
                    // No args -> delegate to standard getBean method.
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
                else {
                    throw new NoSuchBeanDefinitionException(beanName,
                            "Cannot delegate to parent BeanFactory because it does not supported passed-in arguments");
                }
            }

            this.alreadyCreated.add(beanName);

            final RootBeanDefinition mergedBeanDefinition = getMergedBeanDefinition(beanName, false);
            checkMergedBeanDefinition(mergedBeanDefinition, beanName, args);

            //这里调用bean的创建过程，也是依赖注入的地方，依赖解析已经完成放在BeanDefinition里面了
            if (mergedBeanDefinition.isSingleton()) {
                sharedInstance = getSingleton(beanName, new ObjectFactory() {
                    public Object getObject() throws BeansException {
                        try {
                            return createBean(beanName, mergedBeanDefinition, args);
                        }

          .........
    }

public abstract class AbstractBeanDefinition extends AttributeAccessorSupport implements BeanDefinition {
    ....... 
    private Object beanClass;
     ......
    //这个属性持有的这个bean的依赖属性，比如各种property的定义信息
    private MutablePropertyValues propertyValues;
    ......
}

    public AbstractBeanDefinition parseBeanDefinitionElement(
            Element ele, String beanName, BeanDefinition containingBean) {
        //这里得到定义的类的名字 - 通过属性Class
        String className = null;
        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
            className = ele.getAttribute(CLASS_ATTRIBUTE);
        }
        .........
        try {
            this.parseState.push(new BeanEntry(beanName));
            //这里是生成BeanDefinition的地方，也是生成根据定义的class属性来生成bean JAVA对象的地方
            //以前我们已经分析过了，这里生成一个BeanDefinition ， 它里面已经持有了生成的bean Java对象。
            AbstractBeanDefinition bd = BeanDefinitionReaderUtils.createBeanDefinition(
                    parent, className, getReaderContext().getReader().getBeanClassLoader());
            //下面是一系列对beandefinition的属性设置，依据是用户定义的bean定义信息，类似于用户定义的bean定义信息的读入
            if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
                // Spring 2.0 "scope" attribute
                bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
                if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
                    error("Specify either 'scope' or 'singleton', not both", ele);
                }
            }
            else if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
                // Spring 1.x "singleton" attribute
                bd.setSingleton(TRUE_VALUE.equals(ele.getAttribute(SINGLETON_ATTRIBUTE)));
            }
            ..........
            parseMetaElements(ele, bd);
            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

            parseConstructorArgElements(ele, bd);
            //注意这里是对依赖关系，也就是bean对象属性的处理！
            parsePropertyElements(ele, bd);

            bd.setResourceDescription(getReaderContext().getResource().getDescription());
            bd.setSource(extractSource(ele));

            return bd;
            ................
}

    public static AbstractBeanDefinition createBeanDefinition(
            String parent, String className, ClassLoader classLoader) throws ClassNotFoundException {

        AbstractBeanDefinition bd = null;
        if (parent != null) {
            bd = new ChildBeanDefinition(parent);
        }
        else {
            bd = new RootBeanDefinition();
        }
        //这里创建了bean的JAVA对象，同时在beandefinition中持有
        if (className != null) {
            if (classLoader != null) {
                bd.setBeanClass(ClassUtils.forName(className, classLoader));
            }
            else {
                bd.setBeanClassName(className);
            }
        }
        return bd;
    }

    public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
        //这里取得所有定义的属性定义
        NodeList nl = beanEle.getChildNodes();
        //很显然，需要一个一个的处理
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (node instanceof Element && DomUtils.nodeNameEquals(node, PROPERTY_ELEMENT)) {
                parsePropertyElement((Element) node, bd);
            }
        }

    public void parsePropertyElement(Element ele, BeanDefinition bd) {
        //这里得到属性定义的名字
        String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
        if (!StringUtils.hasLength(propertyName)) {
            error("Tag 'property' must have a 'name' attribute", ele);
            return;
        }
        this.parseState.push(new PropertyEntry(propertyName));
        try {
            //判断是不是已经有重名的属性定义
            if (bd.getPropertyValues().contains(propertyName)) {
                error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
                return;
            }
            //这里根据属性的名字对属性的定义进行具体的解析，结果放在PropertyValue对象里面
            //这里包含了对各种属性类型的解析，比如List，Map，Set,当然还有reference bean等等,
            //这个propertyValue是连接和表示各个bean之间依赖关系的桥梁
            Object val = parsePropertyValue(ele, bd, propertyName);
            PropertyValue pv = new PropertyValue(propertyName, val);
            parseMetaElements(ele, pv);
            pv.setSource(extractSource(ele));
            //最后把这个解析的结果，也就是生成的Property对象放到beanDefinition里面去
            bd.getPropertyValues().addPropertyValue(pv);
        }
        finally {
            this.parseState.pop();
        }
    }

    public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
        String elementName = (propertyName != null) ?
                        "<property> element for property '" + propertyName + "'" :
                        "<constructor-arg> element";

        // Should only have one child element: ref, value, list, etc.
        //这里根据DOM取得需要分析的属性定义
        NodeList nl = ele.getChildNodes();
        Element subElement = null;
        for (int i = 0; i < nl.getLength(); i++) {
            if (nl.item(i) instanceof Element) {
                Element candidateEle = (Element) nl.item(i);
                if (DESCRIPTION_ELEMENT.equals(candidateEle.getTagName())) {
                    // Keep going: we don't use this value for now.
                }
                else {
                    // Child element is what we're looking for.
                    if (subElement != null && !META_ELEMENT.equals(subElement.getTagName())) {
                        error(elementName + " must not contain more than one sub-element", ele);
                    }
                    subElement = candidateEle;
                }
            }
        }

        boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
        boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
        if ((hasRefAttribute && hasValueAttribute) ||
                ((hasRefAttribute || hasValueAttribute)) && subElement != null) {
            error(elementName +
                    " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
        }
        if (hasRefAttribute) {
            //这里是对ref属性的解析，称称一个RuntimeBeanReference对象，
            //这个RuntimeBeanReference很简单，只是保持beanName，toParent，source三个属性信息，对记录依赖关系已经足够了
            String refName = ele.getAttribute(REF_ATTRIBUTE);
            if (!StringUtils.hasText(refName)) {
                error(elementName + " contains empty 'ref' attribute", ele);
            }
            RuntimeBeanReference ref = new RuntimeBeanReference(refName);
            ref.setSource(extractSource(ele));
            return ref;
        }
        else if (hasValueAttribute) {
            return ele.getAttribute(VALUE_ATTRIBUTE);
        }

        if (subElement == null) {
            // Neither child element nor "ref" or "value" attribute found.
            error(elementName + " must specify a ref or value", ele);
        }
        //这里对各种其他属性值进行处理，比如List，Map，Set等等
        return parsePropertySubElement(subElement, bd);
    }

    public List parseListElement(Element collectionEle, BeanDefinition bd) {
        String defaultTypeClassName = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);
        NodeList nl = collectionEle.getChildNodes();
        ManagedList list = new ManagedList(nl.getLength());
        list.setSource(extractSource(collectionEle));
        list.setMergeEnabled(parseMergeAttribute(collectionEle));
        //这里对List的各个子属性进行处理，结果放到这个List，然后返回到beandefinition中以后可以使用。
        for (int i = 0; i < nl.getLength(); i++) {
            if (nl.item(i) instanceof Element) {
                Element ele = (Element) nl.item(i);
                list.add(parsePropertySubElement(ele, bd, defaultTypeClassName));
            }
        }
        return list;
    }

    public Object getBean(String name, Class requiredType, final Object[] args) throws BeansException {
        final String beanName = transformedBeanName(name);
        Object bean = null;

        // Eagerly check singleton cache for manually registered singletons.
        // 这里先从缓存中去取,处理那些已经被创建过的单件模式的bean，对这种bean的请求不需要重复的去创建
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null) {
            if (isSingletonCurrentlyInCreation(beanName)) {
            .......
            }
            else {
            .......
            }
            if (containsBeanDefinition(beanName)) {
                RootBeanDefinition mergedBeanDefinition = getMergedBeanDefinition(beanName, false);
                bean = getObjectForBeanInstance(sharedInstance, name, mergedBeanDefinition);
            }
            else {
                bean = getObjectForBeanInstance(sharedInstance, name, null);
            }
        }

        else {
            // Fail if we're already creating this singleton instance:
            // We're assumably within a circular reference.
            if (isSingletonCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            // Check if bean definition exists in this factory.
            //这里检查是否能在当前的工厂中取到我们需要的bean，如果在当前的工厂中取不到，则到父工厂取，如果一直取不到
            //那就顺着工厂链一直向上查找
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // Not found -> check parent.
                String nameToLookup = originalBeanName(name);

                // 这里调用父工厂的getbean取需要的bean
                // 这里有一个迭代，在父工厂中也会重复这么一个getbean的过程。
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    // Delegation to parent with args only possible for AbstractBeanFactory.                 
                    return ((AbstractBeanFactory) parentBeanFactory).getBean(nameToLookup, requiredType, args);
                }
                else if (args == null) {
                    // No args -> delegate to standard getBean method.
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
                else {
                    throw new NoSuchBeanDefinitionException(beanName,
                            "Cannot delegate to parent BeanFactory because it does not supported passed-in arguments");
                }
            }
            //把这个已经被要求过的bean记录下来，因为第一次要求bean的时候往往就是依赖被容器对bean进行注入的时候。
            this.alreadyCreated.add(beanName);          
           
            final RootBeanDefinition mergedBeanDefinition = getMergedBeanDefinition(beanName, false);
            checkMergedBeanDefinition(mergedBeanDefinition, beanName, args);

            // Create bean instance.
            //这里是根据beandefinition来创建bean和完成依赖注入的地方。
            if (mergedBeanDefinition.isSingleton()) {
                sharedInstance = getSingleton(beanName, new ObjectFactory() {
                    public Object getObject() throws BeansException {
                        try {
                            //注意这个createBean，是创建bean同时完成依赖注入的地方。
                            return createBean(beanName, mergedBeanDefinition, args);
                        }
                        catch (BeansException ex) {
                            destroySingleton(beanName);
                            throw ex;
                        }
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, mergedBeanDefinition);
            }
            //这里是处理prototype类型的bean请求的地方
            else if (mergedBeanDefinition.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    //每次请求，直接通过createBean来创建
                    prototypeInstance = createBean(beanName, mergedBeanDefinition, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, mergedBeanDefinition);
            }
         ........
         return bean;
    }

    protected Object createBean(String beanName, RootBeanDefinition mergedBeanDefinition, Object[] args)
            throws BeanCreationException {

        // Guarantee initialization of beans that the current one depends on.
        // 这里对取得当前bean的所有依赖bean，确定能够取得这些已经被确定的bean，如果没有被创建，那么这个createBean会被这些IOC
        // getbean时创建这些bean
        if (mergedBeanDefinition.getDependsOn() != null) {
            for (int i = 0; i < mergedBeanDefinition.getDependsOn().length; i++) {
                getBean(mergedBeanDefinition.getDependsOn()[i]);
            }
        }
      
            ........

            // 这里是实例化bean对象的地方，注意这个BeanWrapper类，是对bean操作的主要封装类
            if (instanceWrapper == null) {
                instanceWrapper = createBeanInstance(beanName, mergedBeanDefinition, args);
            }
            Object bean = instanceWrapper.getWrappedInstance();
            ......
            //这个populate方法，是对已经创建的bean实例进行依赖注入的地方，会使用到在loadBeanDefinition的时候得到的那些propertyValue来对bean进行注入。
            if (continueWithPropertyPopulation) {
                populateBean(beanName, mergedBeanDefinition, instanceWrapper);
            }
           
            //这里完成客户自定义的对bean的一些初始化动作
            Object originalBean = bean;
            bean = initializeBean(beanName, bean, mergedBeanDefinition);
            // Register bean as disposable, and also as dependent on specified "dependsOn" beans.
            registerDisposableBeanIfNecessary(beanName, originalBean, mergedBeanDefinition);

            return bean;
        }

       .........
    }