Spring IoC源码解析——Bean的创建和初始化

矫情吗；* 2023-10-18 16:12 122阅读 0赞

## [Spring IoC源码解析——Bean的创建和初始化][Spring IoC_Bean] ##

**正文**

### **Spring介绍** ###

Spring([http://spring.io/][http_spring.io])是一个轻量级的Java 开发框架，同时也是轻量级的IoC和AOP的容器框架，主要是针对JavaBean的生命周期进行管理的轻量级容器，可以单独使用，也可以和Struts框架，MyBatis框架等组合使用。

### oC介绍 ###

#### IoC是什么 ####

Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

●谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

●为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

#### IoC能做什么 ####

IoC 不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是 松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

那么，IoC容器到底是如何从初始化完成的BeanFactory中对Bean进行创建并初始化的呢？接下来我们就一探究竟。

[回到顶部][Link 1]

### **源码解析** ###

#### 准备工作 ####

首先写一个Spring的配置文件spring.xml，为了方便测试，这里面就只有一个名为test的bean。

<?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.xsd"> 
    
    <bean id="test" class="org.study.spring.ioc.Test"></bean> 
    
    </beans>

编写程序入口代码，可以直接打断点进行调试。![ExpandedBlockStart.gif][]

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
    Test bean = context.getBean("test", Test.class);

#### 开始解析 ####

开始源码解析，紧接着上一节，首先进入AbstractApplicationContext.java的refresh方法，这一节我们重点来看里面的invokeBeanFactoryPostProcessors方法。

@Override
        public void refresh() throws BeansException, IllegalStateException {
            synchronized (this.startupShutdownMonitor) {
                // 在这种情况下刷新
                prepareRefresh();
    
                // 告诉子类刷新内部bean工厂
                ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
                // 在这种情况下,bean工厂准备使用的.
                prepareBeanFactory(beanFactory);
    
                try {
                    // 允许在上下文bean的后处理工厂子类。
                    postProcessBeanFactory(beanFactory);
    
                    //在上下文中调用factory工厂的时候注册bean的 实例对象
                    invokeBeanFactoryPostProcessors(beanFactory);
    
                    // 注册bean的过程当中拦截所以bean的创建
                    registerBeanPostProcessors(beanFactory);
    
                    // 初始化上下文消息资源
                    initMessageSource();
    
                    //初始化事物传播属性
                    initApplicationEventMulticaster();
    
                    // 在特定上下文初始化其他特殊bean子类。
                    onRefresh();
    
                    // 检查侦听器bean并注册。
                    registerListeners();
    
                    // 实例化所有剩余(non-lazy-init)单例.
                    finishBeanFactoryInitialization(beanFactory);
    
                    // 最后一步:发布对应的事件。
                    finishRefresh();
                }
    
                catch (BeansException ex) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("Exception encountered during context initialization - " +
                                "cancelling refresh attempt: " + ex);
                    }
    
                    // 销毁已经创建的单例对象避免浪费资源
                    destroyBeans();
    
                    // 重置“活跃”的旗帜。
                    cancelRefresh(ex);
    
                    // 异常传播到调用者。
                    throw ex;
                }
    
                finally {
                    // 在spring 核心包里重置了内存，因为我们肯不需要元数据单例bean对象了
                    resetCommonCaches();
                }
            }
        }

进入invokeBeanFactoryPostProcessors方法

![复制代码][copycode.gif]

/**
         * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
         * respecting explicit order if given.
         * <p>Must be called before singleton instantiation.
         */
        protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
            PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
            // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
            // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
            if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
                beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
                beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
            }
        }

![复制代码][copycode.gif]

打开PostProcessorRegistrationDelegate类中的invokeBeanFactoryPostProcessors方法，可以看到，这个方法里有很多内容，这里我们只分析最关键的部分。从本质上来说，该方法就是去执行BeanFactoryPostProcessor这个接口中的方法去的，上面代码注释也清楚的写到如果想先执行BeanFactoryPostProcessor这个接口的方法，必须先去实例化实现这个接口的Bean,也就是getBean这个方法。

![ContractedBlock.gif][]

接下来进入AbstractBeanFactory.java类中的doGetBean方法，这个方法的具体实现可以分为三个部分：

第一部分，首先先去singleton缓存中去找实例。由于我们例子中没有把我们的bean手动放入singletonObjects这个Map里面去，所以这里肯定没找到。

第二部分，然后是去获取该BeanFactory父Factory，希望从这些Factory中获取，如果该Beanfactory有父类，则希望用父类去实例化该bean，类似于JVM类加载的双亲委派机制。由于我们例子中的的Beanfactory为null，所以暂不讨论这种情况。

第三部分，这一部分是我们关注的重点，这里我们将这一大部分再分为三个小的部分来进行分析：

1.  先将目前的bean标记为的正在创建
2.  再获取根据beanName得到对应bean在beanfactory中的beanDefinitionMap的BeanDefinition（上一节初始化beanFactory时存入的），然后去获取这个bean依赖的bean。如果依赖的bean还没有创建，则先创建依赖的bean，进行递归调用（这就是依赖注入Dependence Injection）。如果找不到依赖，则忽略。
3.  最后如果是单例（Spring默认是单例），则调用createBean()这个方法进行Bean的创建。

![ContractedBlock.gif][]

进入AbstractAutowireCapableBeanFactory.java类的createBean方法，这里面可以分为四个部分：

第一部分：确保该bean的class是真实存在的，也就是该bean是可以classload可以找到加载的

第二部分：准备方法的重写

第三部分：可以看到，这边出现了一个return，也就是说这边可以返回bean了。但看注释：Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. 这样就很清晰了，BeanPostProcessor这个接口是可以临时修改bean的，优先级高于正常实例化bean的，如果beanPostProcessor能返回，则直接返回了。

第四部分：调用doCreateBean方法开始对bean进行创建

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

/**
         * 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;
    
            //确保bean类实际上是解决在这一点上,和克隆bean定义的动态解析类不能存储在共享合并bean定义。
            Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
            if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
                mbdToUse = new RootBeanDefinition(mbd);
                mbdToUse.setBeanClass(resolvedClass);
            }
    
            // 准备方法覆盖
            try {
                mbdToUse.prepareMethodOverrides();
            }
            catch (BeanDefinitionValidationException ex) {
                throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                        beanName, "Validation of method overrides failed", ex);
            }
    
            try {
                // .让BeanPostProcessors返回一个代理,而不是目标bean实例
                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);
            }
    
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isDebugEnabled()) {
                logger.debug("Finished creating instance of bean '" + beanName + "'");
            }
            return beanInstance;
        }

![复制代码][copycode.gif]

打开doCreateBean方法，在这个方法里会做两件事：一是通过createBeanInstance这个方法创建bean，二是通过initializeBean方法初始化bean。先看看createBeanInstance这个方法里有什么玄`/**`

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

* Actually create the specified bean. Pre-creation processing has already happened
         * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
         * <p>Differentiates between default bean instantiation, use of a
         * factory method, and autowiring a constructor.
         * @param beanName the name of the bean
         * @param mbd the merged bean definition for the bean
         * @param args explicit arguments to use for constructor or factory method invocation
         * @return a new instance of the bean
         * @throws BeanCreationException if the bean could not be created
         * @see #instantiateBean
         * @see #instantiateUsingFactoryMethod
         * @see #autowireConstructor
         */
        protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
            // Instantiate the bean.
            BeanWrapper instanceWrapper = null;
            if (mbd.isSingleton()) {
                instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
            }
            if (instanceWrapper == null) {
                instanceWrapper = createBeanInstance(beanName, mbd, args);
            }
            final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
            Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    
            // Allow post-processors to modify the merged bean definition.
            synchronized (mbd.postProcessingLock) {
                if (!mbd.postProcessed) {
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                    mbd.postProcessed = true;
                }
            }
    
            /// 急切地缓存单件能够解决循环引用
                   // 即使像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);
                    }
                });
            }
    
            // 初始化 bean 的实例对象
            Object exposedObject = bean;
            try {
                populateBean(beanName, mbd, instanceWrapper);
                if (exposedObject != null) {
                    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<>(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.");
                        }
                    }
                }
            }
    
            // 注册一次性使用的 bean
            try {
                registerDisposableBeanIfNecessary(beanName, bean, mbd);
            }
            catch (BeanDefinitionValidationException ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
            }
    
            return exposedObject;
        }

![复制代码][copycode.gif]

#### **创建Bean** ####

进入createBeanInstance方法，这块代码主要是再次对bean做安全检查并确定该bean有默认的构造函数。直接看这个方法最后一行，调用instantiateBean方法并返回方法的结果。

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

/**
         * Create a new instance for the specified bean, using an appropriate instantiation strategy:
         * factory method, constructor autowiring, or simple instantiation.
         * @param beanName the name of the bean
         * @param mbd the bean definition for the bean
         * @param args explicit arguments to use for constructor or factory method invocation
         * @return BeanWrapper for the new instance
         * @see #instantiateUsingFactoryMethod
         * @see #autowireConstructor
         * @see #instantiateBean
         */
        protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
            // 这一步是确保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());
            }
    
            if (mbd.getFactoryMethodName() != null)  {
                return instantiateUsingFactoryMethod(beanName, mbd, args);
            }
    
            // 重新创建相同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);
                }
            }
    
            // 这个时候需要确定该一下 这个 bean 的构造函数.
            Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
            if (ctors != null ||
                    mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
                    mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
                return autowireConstructor(beanName, mbd, ctors, args);
            }
    
            // 不做任何特殊处理:简单地使用不带参数的构造函数。
            return instantiateBean(beanName, mbd);
        }

![复制代码][copycode.gif]

接着进入instantiateBean方法查看

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

/**
         * Instantiate the given bean using its default constructor.
         * @param beanName the name of the bean
         * @param mbd the bean definition for the bean
         * @return BeanWrapper for the new instance
         */
        protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
            try {
                Object beanInstance;
                final BeanFactory parent = this;
                if (System.getSecurityManager() != null) {
                    beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
                        @Override
                        public Object run() {
                            return getInstantiationStrategy().instantiate(mbd, beanName, parent);
                        }
                    }, getAccessControlContext());
                }
                else {
                    beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
                }
                BeanWrapper bw = new BeanWrapperImpl(beanInstance);
                initBeanWrapper(bw);
                return bw;
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
            }
        }

![复制代码][copycode.gif]

再进入SimpleInstantiationStrategy.java的instantiate方法，我们可以看到，在这个方法里，Spring通过反射的方法根据BeanDefinition创建出Bean的对象并返回。

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

@Override
        public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
            // Don't override the class with CGLIB if no overrides.
            if (bd.getMethodOverrides().isEmpty()) {
                Constructor<?> constructorToUse;
                synchronized (bd.constructorArgumentLock) {
                    constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
                    if (constructorToUse == null) {
                        final Class<?> clazz = bd.getBeanClass();
                        if (clazz.isInterface()) {
                            throw new BeanInstantiationException(clazz, "Specified class is an interface");
                        }
                        try {
                            if (System.getSecurityManager() != null) {
                                constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
                                    @Override
                                    public Constructor<?> run() throws Exception {
                                        return clazz.getDeclaredConstructor((Class[]) null);
                                    }
                                });
                            }
                            else {
                                constructorToUse =    clazz.getDeclaredConstructor((Class[]) null);
                            }
                            bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                        }
                        catch (Throwable ex) {
                            throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                        }
                    }
                }
                return BeanUtils.instantiateClass(constructorToUse);
            }
            else {
                // Must generate CGLIB subclass.
                return instantiateWithMethodInjection(bd, beanName, owner);
            }
        }

![复制代码][copycode.gif]

以上是Bean的创建，接下来我们看IoC容器是如何对Bean进行初始化的。

#### **初始化Bean** ####

让我们回到AbstractAutowireCapableBeanFactory.java类中的doCreateBean方法中，重点关注里面的initializeBean方法。现在bean已经被创建了，开始初始化该bean。

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

/**
         * Initialize the given bean instance, applying factory callbacks
         * as well as init methods and bean post processors.
         * <p>Called from {@link #createBean} for traditionally defined beans,
         * and from {@link #initializeBean} for existing bean instances.
         * @param beanName the bean name in the factory (for debugging purposes)
         * @param bean the new bean instance we may need to initialize
         * @param mbd the bean definition that the bean was created with
         * (can also be {@code null}, if given an existing bean instance)
         * @return the initialized bean instance (potentially wrapped)
         * @see BeanNameAware
         * @see BeanClassLoaderAware
         * @see BeanFactoryAware
         * @see #applyBeanPostProcessorsBeforeInitialization
         * @see #invokeInitMethods
         * @see #applyBeanPostProcessorsAfterInitialization
         */
        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 {
                invokeAwareMethods(beanName, bean);
            }
    
            Object wrappedBean = bean;
            if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
            }
    
            try {
                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;
        }

![复制代码][copycode.gif]

在这个方法中，先调用invokeAwareMethods方法用于加载相关资源（比如BeanName、BeanClassLoader、BeanFactory等资源）。

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

private void invokeAwareMethods(final String beanName, final Object bean) {
            if (bean instanceof Aware) {
                if (bean instanceof BeanNameAware) {
                    ((BeanNameAware) bean).setBeanName(beanName);
                }
                if (bean instanceof BeanClassLoaderAware) {
                    ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
                }
                if (bean instanceof BeanFactoryAware) {
                    ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
                }
            }
        }

![复制代码][copycode.gif]

再调用applyBeanPostProcessorsBeforeInitialization方法用于构造方法执行之前再次修改Bean（BeanPostProcessor接口）。

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

@Override
        public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
                throws BeansException {
    
            Object result = existingBean;
            for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
                result = beanProcessor.postProcessBeforeInitialization(result, beanName);
                if (result == null) {
                    return result;
                }
            }
            return result;
        }

![复制代码][copycode.gif]

然后通过invokeInitMethods调用自定义的初始化方法

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

/**
         * Give a bean a chance to react now all its properties are set,
         * and a chance to know about its owning bean factory (this object).
         * This means checking whether the bean implements InitializingBean or defines
         * a custom init method, and invoking the necessary callback(s) if it does.
         * @param beanName the bean name in the factory (for debugging purposes)
         * @param bean the new bean instance we may need to initialize
         * @param mbd the merged bean definition that the bean was created with
         * (can also be {@code null}, if given an existing bean instance)
         * @throws Throwable if thrown by init methods or by the invocation process
         * @see #invokeCustomInitMethod
         */
        protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
                throws Throwable {
    
            boolean isInitializingBean = (bean instanceof InitializingBean);
            if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
                }
                if (System.getSecurityManager() != null) {
                    try {
                        AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                            @Override
                            public Object run() throws Exception {
                                ((InitializingBean) bean).afterPropertiesSet();
                                return null;
                            }
                        }, getAccessControlContext());
                    }
                    catch (PrivilegedActionException pae) {
                        throw pae.getException();
                    }
                }
                else {
                    ((InitializingBean) bean).afterPropertiesSet();
                }
            }
    
            if (mbd != null) {
                String initMethodName = mbd.getInitMethodName();
                if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                        !mbd.isExternallyManagedInitMethod(initMethodName)) {
                    invokeCustomInitMethod(beanName, bean, mbd);
                }
            }
        }

![复制代码][copycode.gif]

再调用applyBeanPostProcessorsAfterInitialization方法用于构造方法执行之前再次修改Bean（BeanPostProcessor接口）。

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

@Override
        public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
                throws BeansException {
    
            Object result = existingBean;
            for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
                result = beanProcessor.postProcessAfterInitialization(result, beanName);
                if (result == null) {
                    return result;
                }
            }
            return result;
        }

![复制代码][copycode.gif]

以上就完成了创建并初始化Bean的整个过程。

[回到顶部][Link 1]

### **总结** ###

通过这次源码分析，我们应该知道bean是怎么被IoC容器所创建的了，也知道IoC容器是如何去初始化spring.xml中的的bean了。我们来总结一下，整个过程最主要的就是AbstractAutowireCapableBeanFactory.java类中两个方法，一是createBeanInstance方法，用于创建Bean，二是initializeBean方法，用于初始化Bean。这两个方法需要仔细地分析和思考，如果还有不明白的地方，可以对照着Spring的源码自己动手理解一下，希望能对大家有所帮助。

[Spring IoC_Bean]: https://www.cnblogs.com/yxh2008/p/6012230.html
[http_spring.io]: http://spring.io/
[Link 1]: https://www.cnblogs.com/yxh1008/p/6012230.html#_labelTop
[ExpandedBlockStart.gif]: https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif
[copycode.gif]: https://common.cnblogs.com/images/copycode.gif
[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif