public class IocTest {

    @Test

    public void testBeanFactory(){

        ClassPathResource resource = new ClassPathResource("beans.xml");  //找到资源文件

        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

        reader.loadBeanDefinitions(resource); //根据资源文件，将资源文件中定义的bean转为beandefination，然后加载beanDefinition到容器中（存放到CurrentHashMap中）

        Student student = (Student) beanFactory.getBean("student");//获取bean实例：先实例化对象，填充属性（完成依赖注入）,最后是初始化对象（调用init方法或者afterPropertiesSet方法） 
        System.out.println("name="+student.getName()+",age="+student.getAge()); } }

/**

     * Load bean definitions from the specified XML file.

     * @param encodedResource the resource descriptor for the XML file,

     * allowing to specify an encoding to use for parsing the file

     * @return the number of bean definitions found

     * @throws BeanDefinitionStoreException in case of loading or parsing errors

     */

    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); //将定义好或获取到的HashSet放入ThreadLocal中

        }
        //将资源文件encodedResource放入HashSet中

        if (!currentResources.add(encodedResource)) {

            throw new BeanDefinitionStoreException(

                    "Detected cyclic loading of " + encodedResource + " - check your import definitions!");

        }

        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();

            }

        }

        catch (IOException ex) {

            throw new BeanDefinitionStoreException(

                    "IOException parsing XML document from " + encodedResource.getResource(), ex);

        }

        finally {

            currentResources.remove(encodedResource);

            if (currentResources.isEmpty()) {

                this.resourcesCurrentlyBeingLoaded.remove();

            }

        }

    }

    /**

     * Actually load bean definitions from the specified XML file.

     * @param inputSource the SAX InputSource to read from

     * @param resource the resource descriptor for the XML file

     * @return the number of bean definitions found

     * @throws BeanDefinitionStoreException in case of loading or parsing errors

     * @see #doLoadDocument

     * @see #registerBeanDefinitions

     */

    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)

            throws BeanDefinitionStoreException {

        try {

            Document doc = doLoadDocument(inputSource, resource);
            //进入该方法

            return registerBeanDefinitions(doc, resource);

        }
        //以下catch中捕获的各种异常就是我们经常在容器启动中遇到的

        catch (BeanDefinitionStoreException ex) {

            throw ex;

        }

        catch (SAXParseException ex) {

            throw new XmlBeanDefinitionStoreException(resource.getDescription(),

                    "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);

        }

        catch (SAXException ex) {

            throw new XmlBeanDefinitionStoreException(resource.getDescription(),

                    "XML document from " + resource + " is invalid", ex);

        }

        catch (ParserConfigurationException ex) {

            throw new BeanDefinitionStoreException(resource.getDescription(),

                    "Parser configuration exception parsing XML from " + resource, ex);

        }

        catch (IOException ex) {

            throw new BeanDefinitionStoreException(resource.getDescription(),

                    "IOException parsing XML document from " + resource, ex);

        }

        catch (Throwable ex) {

            throw new BeanDefinitionStoreException(resource.getDescription(),

                    "Unexpected exception parsing XML document from " + resource, ex);

        }

    }

/**

     * Register the bean definitions contained in the given DOM document. //注册dom文档中的beandefinations

     * Called by {@code loadBeanDefinitions}.

     * <p>Creates a new instance of the parser class and invokes

     * {@code registerBeanDefinitions} on it.

     * @param doc the DOM document

     * @param resource the resource descriptor (for context information)

     * @return the number of bean definitions found

     * @throws BeanDefinitionStoreException in case of parsing errors

     * @see #loadBeanDefinitions

     * @see #setDocumentReaderClass

     * @see BeanDefinitionDocumentReader#registerBeanDefinitions

     */

    public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {

        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();

        int countBefore = getRegistry().getBeanDefinitionCount(); //容器中现有的BeanDefinatin数量
        //进入该方法

        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

        return getRegistry().getBeanDefinitionCount() - countBefore;//返回新注册的beandefination数量

    }

    /**

     * This implementation parses bean definitions according to the "spring-beans" XSD

     * (or DTD, historically).

     * <p>Opens a DOM Document; then initializes the default settings

     * specified at the {@code <beans/>} level; then parses the contained bean definitions.

     */

    @Override

    public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {

        this.readerContext = readerContext;

        logger.debug("Loading bean definitions");

        Element root = doc.getDocumentElement(); //获取document的根元素

        //进入该方法
        doRegisterBeanDefinitions(root);

    }

/**

     * Register each bean definition within the given root {@code <beans/>} element.

     */

    protected void doRegisterBeanDefinitions(Element root) {

        // Any nested <beans> elements will cause recursion in this method. In

        // order to propagate and preserve <beans> default-* attributes correctly,

        // keep track of the current (parent) delegate, which may be null. Create

        // the new (child) delegate with a reference to the parent for fallback purposes,

        // then ultimately reset this.delegate back to its original (parent) reference.

        // this behavior emulates a stack of delegates without actually necessitating one.

        //该类的作用是解析document中的元素，将元素解析为beandefination，进入该类可以看到有各种解析方法

        BeanDefinitionParserDelegate parent = this.delegate;

        this.delegate = createDelegate(getReaderContext(), root, parent);

        //默认的命名空间是 http://www.springframework.org/schema/beans

        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;

                }

            }

        }

        preProcessXml(root);
        //进入该方法

        parseBeanDefinitions(root, this.delegate);

        postProcessXml(root);

        this.delegate = parent;

    }

    /**

     * Parse the elements at the root level in the document:

     * "import", "alias", "bean".

     * @param root the DOM root element of the document

     */

    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);

        }

    }

    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
      　　//xml文件中定义的ele元素的前缀为 import 时

        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {

            importBeanDefinitionResource(ele);

        }
        //xml文件中定义的ele元素的前缀为 alias 时

        else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {

            processAliasRegistration(ele);

        }
        //xml文件中定义的ele元素的前缀为 bean 时

        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
            //进入该方法

            processBeanDefinition(ele, delegate);

        }

        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {

            // recurse

            doRegisterBeanDefinitions(ele);

        }

    }

    /**

     * Process the given bean element, parsing the bean definition

     * and registering it with the registry.

     */

    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        //解析ele元素获取BeanDefinationHolder，具体的解析过程可以进入该方法看看

        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

        if (bdHolder != null) {

            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

            try {

                // Register the final decorated instance. 将获取到的BeanDefination放到容器中的CurrentHashMap中，key为beanName，value为BeanDefination

                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));

        }

    }

    /**

     * Return an instance, which may be shared or independent, of the specified bean.

     * @param name the name of the bean to retrieve

     * @param requiredType the required type of the bean to retrieve

     * @param args arguments to use when creating a bean instance using explicit arguments

     * (only applied when creating a new instance as opposed to retrieving an existing one)

     * @param typeCheckOnly whether the instance is obtained for a type check,

     * not for actual use

     * @return an instance of the bean

     * @throws BeansException if the bean could not be created

     */

    @SuppressWarnings("unchecked")

    protected <T> T doGetBean(

            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)

            throws BeansException {

        final String beanName = transformedBeanName(name);

        Object bean;

        // Eagerly check singleton cache for manually registered singletons.

        //spring容器中的bean默认是单例模式，当生成一个bean对象后，会存放到缓存中，等再次使用的时候直接取出这个bean对象，而不用重新创建一个新的对象
        Object sharedInstance = getSingleton(beanName);

        if (sharedInstance != null && args == null) {

            if (logger.isDebugEnabled()) {

                if (isSingletonCurrentlyInCreation(beanName)) {

                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +

                            "' that is not fully initialized yet - a consequence of a circular reference");

                }

                else {

                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");

                }

            }

            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

        }

        else {

            // Fail if we're already creating this bean instance:

            // We're assumably within a circular reference.

            if (isPrototypeCurrentlyInCreation(beanName)) {

                throw new BeanCurrentlyInCreationException(beanName);

            }

            // Check if bean definition exists in this factory.

            BeanFactory parentBeanFactory = getParentBeanFactory();
            //如果双亲容器不为空，并且在本容器中没有找到对应的BeanDefination，那就去双亲容器中获取bean对象；如果当前双亲容器获取不到，那就顺着该双亲容器一直向上查找获取

            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {

                // Not found -> check parent.

                String nameToLookup = originalBeanName(name);

                if (args != null) {

                    // Delegation to parent with explicit args.

                    return (T) parentBeanFactory.getBean(nameToLookup, args);

                }

                else {

                    // No args -> delegate to standard getBean method.

                    return parentBeanFactory.getBean(nameToLookup, requiredType);

                }

            }

            if (!typeCheckOnly) {

                markBeanAsCreated(beanName);

            }

            try {
　　　　　　　　　　//根据beanName获取BeanDefination

                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

                checkMergedBeanDefinition(mbd, beanName, args);

                //获取当前bean所有的依赖bean，需要注意的是，此处的依赖是指通过depends-on指定的依赖关系，而不是依赖注入；依赖注入的触发是在设置属性的时候进行的

                // Guarantee initialization of beans that the current bean depends on.

                String[] dependsOn = mbd.getDependsOn();

                if (dependsOn != null) {

                    for (String dep : dependsOn) {

                        if (isDependent(beanName, dep)) {

                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,

                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");

                        }

                        registerDependentBean(dep, beanName);

                        try {

                            getBean(dep);

                        }

                        catch (NoSuchBeanDefinitionException ex) {

                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,

                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);

                        }

                    }

                }

                //创建一个单例bean

                // Create bean instance.

                if (mbd.isSingleton()) {

                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {

                        @Override

                        public Object getObject() throws BeansException {

                            try { 
                                 //进入该方法

                                return createBean(beanName, mbd, args);

                            }

                            catch (BeansException ex) {

                                // Explicitly remove instance from singleton cache: It might have been put there

                                // eagerly by the creation process, to allow for circular reference resolution.

                                // Also remove any beans that received a temporary reference to the bean.

                                destroySingleton(beanName);

                                throw ex;

                            }

                        }

                    });

                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

                }

                //创建一个多例bean

                else if (mbd.isPrototype()) {

                    // It's a prototype -> create a new instance.

                    Object prototypeInstance = null;

                    try {

                        beforePrototypeCreation(beanName);

                        prototypeInstance = createBean(beanName, mbd, args);

                    }

                    finally {

                        afterPrototypeCreation(beanName);

                    }

                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);

                }

                else {

                    String scopeName = mbd.getScope();

                    final Scope scope = this.scopes.get(scopeName);

                    if (scope == null) {

                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");

                    }

                    try {

                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {

                            @Override

                            public Object getObject() throws BeansException {

                                beforePrototypeCreation(beanName);

                                try {

                                    return createBean(beanName, mbd, args);

                                }

                                finally {

                                    afterPrototypeCreation(beanName);

                                }

                            }

                        });

                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);

                    }

                    catch (IllegalStateException ex) {

                        throw new BeanCreationException(beanName,

                                "Scope '" + scopeName + "' is not active for the current thread; consider " +

                                "defining a scoped proxy for this bean if you intend to refer to it from a singleton",

                                ex);

                    }

                }

            }

            catch (BeansException ex) {

                cleanupAfterBeanCreationFailure(beanName);

                throw ex;

            }

        }

        //对将要返回的bean实例进行检查

        // Check if required type matches the type of the actual bean instance.

        if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {

            try {

                return getTypeConverter().convertIfNecessary(bean, requiredType);

            }

            catch (TypeMismatchException ex) {

                if (logger.isDebugEnabled()) {

                    logger.debug("Failed to convert bean '" + name + "' to required type '" +

                            ClassUtils.getQualifiedName(requiredType) + "'", ex);

                }

                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());

            }

        }

        return (T) bean;

    }

/**

     * Central method of this class: creates a bean instance,

     * populates the bean instance, applies post-processors, etc.

     * @see #doCreateBean

     */

    @Override

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

        if (logger.isDebugEnabled()) {

            logger.debug("Creating instance of bean '" + beanName + "'");

        }

        RootBeanDefinition mbdToUse = mbd;

        // Make sure bean class is actually resolved at this point, and

        // clone the bean definition in case of a dynamically resolved Class

        // which cannot be stored in the shared merged bean definition.

        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {

            mbdToUse = new RootBeanDefinition(mbd);

            mbdToUse.setBeanClass(resolvedClass);

        }

        // Prepare method overrides.

        try {

            mbdToUse.prepareMethodOverrides();

        }

        catch (BeanDefinitionValidationException ex) {

            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),

                    beanName, "Validation of method overrides failed", ex);

        }

        try {

            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.

            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

            if (bean != null) {

                return bean;

            }

        }

        catch (Throwable ex) {

            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,

                    "BeanPostProcessor before instantiation of bean failed", ex);

        }

        //这里是创建bean的地方，进入该方法

        Object beanInstance = doCreateBean(beanName, mbdToUse, args);

        if (logger.isDebugEnabled()) {

            logger.debug("Finished creating instance of bean '" + beanName + "'");

        }

        return beanInstance;

    }

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)

            throws BeanCreationException {


　　　　　//该BeanWrapper持有将要实例化的bean对象　

        // Instantiate the bean.

        BeanWrapper instanceWrapper = null;
        //如果是单例模式，则清除同名的bean对象

        if (mbd.isSingleton()) {

            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);

        }

        if (instanceWrapper == null) {
            //在这里完成bean对象的实例化 进入该方法

            instanceWrapper = createBeanInstance(beanName, mbd, args);

        }

        final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);

        Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

        mbd.resolvedTargetType = beanType;

        // Allow post-processors to modify the merged bean definition.

        synchronized (mbd.postProcessingLock) {

            if (!mbd.postProcessed) {

                try {

                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

                }

                catch (Throwable ex) {

                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,

                            "Post-processing of merged bean definition failed", ex);

                }

                mbd.postProcessed = true;

            }

        }

        // Eagerly cache singletons to be able to resolve circular references

        // even when triggered by lifecycle interfaces like BeanFactoryAware.

        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&

                isSingletonCurrentlyInCreation(beanName));

        if (earlySingletonExposure) {

            if (logger.isDebugEnabled()) {

                logger.debug("Eagerly caching bean '" + beanName +

                        "' to allow for resolving potential circular references");

            }

            addSingletonFactory(beanName, new ObjectFactory<Object>() {

                @Override

                public Object getObject() throws BeansException {

                    return getEarlyBeanReference(beanName, mbd, bean);

                }

            });

        }

        // Initialize the bean instance.

        Object exposedObject = bean;

        try {
            //属性的填充，此处触发依赖注入 进入该方法

            populateBean(beanName, mbd, instanceWrapper);

            if (exposedObject != null) {
                //进行对象的初始化，初始化方法的调用：init-method和afterPropertiesSet  进入该方法

                exposedObject = initializeBean(beanName, exposedObject, mbd);

            }

        }

        catch (Throwable ex) {

            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {

                throw (BeanCreationException) ex;

            }

            else {

                throw new BeanCreationException(

                        mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);

            }

        }

        if (earlySingletonExposure) {

            Object earlySingletonReference = getSingleton(beanName, false);

            if (earlySingletonReference != null) {

                if (exposedObject == bean) {

                    exposedObject = earlySingletonReference;

                }

                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {

                    String[] dependentBeans = getDependentBeans(beanName);

                    Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);

                    for (String dependentBean : dependentBeans) {

                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {

                            actualDependentBeans.add(dependentBean);

                        }

                    }

                    if (!actualDependentBeans.isEmpty()) {

                        throw new BeanCurrentlyInCreationException(beanName,

                                "Bean with name '" + beanName + "' has been injected into other beans [" +

                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +

                                "] in its raw version as part of a circular reference, but has eventually been " +

                                "wrapped. This means that said other beans do not use the final version of the " +

                                "bean. This is often the result of over-eager type matching - consider using " +

                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");

                    }

                }

            }

        }

        // Register bean as disposable.

        try {

            registerDisposableBeanIfNecessary(beanName, bean, mbd);

        }

        catch (BeanDefinitionValidationException ex) {

            throw new BeanCreationException(

                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);

        }

        return exposedObject;

    }

    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {

        // Make sure bean class is actually resolved at this point.

        //确认生成bean对象的类可以被实例化
        Class<?> beanClass = resolveBeanClass(mbd, beanName);

        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {

            throw new BeanCreationException(mbd.getResourceDescription(), beanName,

                    "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());

        }

        //使用工厂方法生成bean对象

        if (mbd.getFactoryMethodName() != null)  {

            return instantiateUsingFactoryMethod(beanName, mbd, args);

        }

        // Shortcut when re-creating the same bean...

        boolean resolved = false;

        boolean autowireNecessary = false;

        if (args == null) {

            synchronized (mbd.constructorArgumentLock) {

                if (mbd.resolvedConstructorOrFactoryMethod != null) {

                    resolved = true;

                    autowireNecessary = mbd.constructorArgumentsResolved;

                }

            }

        }

        if (resolved) {

            if (autowireNecessary) {

                return autowireConstructor(beanName, mbd, null, null);

            }

            else {

                return instantiateBean(beanName, mbd);

            }

        }

        // Need to determine the constructor...

        //使用构造方法生成对象
        Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);

        if (ctors != null ||

                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||

                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {

            return autowireConstructor(beanName, mbd, ctors, args);

        }

         //使用默认的构造方法实例化bean对象,进入该方法可以知道，生成对象对象的方式有两种 BeanUtils和cglib，默认使用cglib生成

        // No special handling: simply use no-arg constructor.使用无参构造器

        return instantiateBean(beanName, mbd);

    }

    protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {

        PropertyValues pvs = mbd.getPropertyValues();

        if (bw == null) {

            if (!pvs.isEmpty()) {

                throw new BeanCreationException(

                        mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");

            }

            else {

                // Skip property population phase for null instance.

                return;

            }

        }

        // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the

        // state of the bean before properties are set. This can be used, for example,

        // to support styles of field injection.

        boolean continueWithPropertyPopulation = true;

        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {

            for (BeanPostProcessor bp : getBeanPostProcessors()) {

                if (bp instanceof InstantiationAwareBeanPostProcessor) {

                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;

                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {

                        continueWithPropertyPopulation = false;

                        break;

                    }

                }

            }

        }

        if (!continueWithPropertyPopulation) {

            return;

        }

        //先完成autoware的依赖注入 有by name和 by type 两种方式

        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||

                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {

            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

            // Add property values based on autowire by name if applicable.

            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {

                autowireByName(beanName, mbd, bw, newPvs);

            }

            // Add property values based on autowire by type if applicable.

            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {

                autowireByType(beanName, mbd, bw, newPvs);

            }

            pvs = newPvs;

        }

        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();

        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

        if (hasInstAwareBpps || needsDepCheck) {

            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);

            if (hasInstAwareBpps) {

                for (BeanPostProcessor bp : getBeanPostProcessors()) {

                    if (bp instanceof InstantiationAwareBeanPostProcessor) {

                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;

                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);

                        if (pvs == null) {

                            return;

                        }

                    }

                }

            }

            if (needsDepCheck) {

                checkDependencies(beanName, mbd, filteredPds, pvs);

            }

        }

        //完成对属性的注入，对于autoware注入方式的属性会在刚进入方法就返回了。 进入该方法

        applyPropertyValues(beanName, mbd, bw, pvs);

    }

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {

        
　　　　 //对于autoware类型的注入，会进入该判断，然后return;　 　
　　　　 if (pvs == null || pvs.isEmpty()) {

            return;

        }

        if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {

            ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());

        }

        MutablePropertyValues mpvs = null;

        List<PropertyValue> original;

        if (pvs instanceof MutablePropertyValues) {

            mpvs = (MutablePropertyValues) pvs;

            if (mpvs.isConverted()) {

                // Shortcut: use the pre-converted values as-is.

                try {

                    bw.setPropertyValues(mpvs);

                    return;

                }

                catch (BeansException ex) {

                    throw new BeanCreationException(

                            mbd.getResourceDescription(), beanName, "Error setting property values", ex);

                }

            }

            original = mpvs.getPropertyValueList();

        }

        else {

            original = Arrays.asList(pvs.getPropertyValues());

        }

        TypeConverter converter = getCustomTypeConverter();

        if (converter == null) {

            converter = bw;

        }

        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

        // Create a deep copy, resolving any references for values.

        List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());

        boolean resolveNecessary = false;

        for (PropertyValue pv : original) {

            if (pv.isConverted()) {

                deepCopy.add(pv);

            }

            else {

                String propertyName = pv.getName();

                Object originalValue = pv.getValue();

                Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);

                Object convertedValue = resolvedValue;

                boolean convertible = bw.isWritableProperty(propertyName) &&

                        !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);

                if (convertible) {

                    convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);

                }

                // Possibly store converted value in merged bean definition,

                // in order to avoid re-conversion for every created bean instance.

                if (resolvedValue == originalValue) {

                    if (convertible) {

                        pv.setConvertedValue(convertedValue);

                    }

                    deepCopy.add(pv);

                }

                else if (convertible && originalValue instanceof TypedStringValue &&

                        !((TypedStringValue) originalValue).isDynamic() &&

                        !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {

                    pv.setConvertedValue(convertedValue);

                    deepCopy.add(pv);

                }

                else {

                    resolveNecessary = true;

                    deepCopy.add(new PropertyValue(pv, convertedValue));

                }

            }

        }

        if (mpvs != null && !resolveNecessary) {

            mpvs.setConverted();

        }

        // Set our (possibly massaged) deep copy.

        try { 
            //此处完成属性的依赖注入

            bw.setPropertyValues(new MutablePropertyValues(deepCopy));

        }

        catch (BeansException ex) {

            throw new BeanCreationException(

                    mbd.getResourceDescription(), beanName, "Error setting property values", ex);

        }

    }

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {

        if (System.getSecurityManager() != null) {

            AccessController.doPrivileged(new PrivilegedAction<Object>() {

                @Override

                public Object run() {

                    invokeAwareMethods(beanName, bean);

                    return null;

                }

            }, getAccessControlContext());

        }

        else {
            //对于BeanFactoryWare,ServletContextWare等ware类型，调用对应的ware方法

            invokeAwareMethods(beanName, bean);

        }

        Object wrappedBean = bean;

        if (mbd == null || !mbd.isSynthetic()) {

            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

        }

        try {
            //进入该方法可以看到,调用init方法和afterPropertiesSet方法

            invokeInitMethods(beanName, wrappedBean, mbd);

        }

        catch (Throwable ex) {

            throw new BeanCreationException(

                    (mbd != null ? mbd.getResourceDescription() : null),

                    beanName, "Invocation of init method failed", ex);

        }

        if (mbd == null || !mbd.isSynthetic()) {

            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

        }

        return wrappedBean;

    }