【Spring源码】-【Bean标准初始化顺序】

目录

1.BeanFactory描述(标准初始化顺序)

2.解析

        2.1 调用beanFactory相关的aware接口

        2.2 调用ApplicationContext相关的aware接口

        2.3 调用BeanPostProcessor的初始化前置方法（AOP）

        2.4 调用初始化方法

        2.5 调用bean定义文件中的指定初始化方法

        2.6 调用BeanPostProcessor的初始化后置方法（AOP）

        2.7 其他

3.例证

3.1 入口 AbstractAutowireCapableBeanFactory#initializeBean

3.2 AbstractAutowireCapableBeanFactory#invokeAwareMethods

3.3 ApplicationContextAwareProcessor#invokeAwareInterfaces

3.4 AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

3.5 AbstractAutowireCapableBeanFactory#invokeInitMethods

3.6 AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization

4.结论

---

1.BeanFactory描述(标准初始化顺序)

* <p>Bean factory implementations should support the standard bean lifecycle interfaces
 * as far as possible. The full set of initialization methods and their standard order is:
 * <ol>
 * <li>BeanNameAware's {@code setBeanName}
 * <li>BeanClassLoaderAware's {@code setBeanClassLoader}
 * <li>BeanFactoryAware's {@code setBeanFactory}
 * <li>EnvironmentAware's {@code setEnvironment}
 * <li>EmbeddedValueResolverAware's {@code setEmbeddedValueResolver}
 * <li>ResourceLoaderAware's {@code setResourceLoader}
 * (only applicable when running in an application context)
 * <li>ApplicationEventPublisherAware's {@code setApplicationEventPublisher}
 * (only applicable when running in an application context)
 * <li>MessageSourceAware's {@code setMessageSource}
 * (only applicable when running in an application context)
 * <li>ApplicationContextAware's {@code setApplicationContext}
 * (only applicable when running in an application context)
 * <li>ServletContextAware's {@code setServletContext}
 * (only applicable when running in a web application context)
 * <li>{@code postProcessBeforeInitialization} methods of BeanPostProcessors
 * <li>InitializingBean's {@code afterPropertiesSet}
 * <li>a custom {@code init-method} definition
 * <li>{@code postProcessAfterInitialization} methods of BeanPostProcessors
 * </ol>
 *
 * <p>On shutdown of a bean factory, the following lifecycle methods apply:
 * <ol>
 * <li>{@code postProcessBeforeDestruction} methods of DestructionAwareBeanPostProcessors
 * <li>DisposableBean's {@code destroy}
 * <li>a custom {@code destroy-method} definition
 * </ol>
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @author Chris Beams
 * @since 13 April 2001
 * @see BeanNameAware#setBeanName
 * @see BeanClassLoaderAware#setBeanClassLoader
 * @see BeanFactoryAware#setBeanFactory
 * @see org.springframework.context.EnvironmentAware#setEnvironment
 * @see org.springframework.context.EmbeddedValueResolverAware#setEmbeddedValueResolver
 * @see org.springframework.context.ResourceLoaderAware#setResourceLoader
 * @see org.springframework.context.ApplicationEventPublisherAware#setApplicationEventPublisher
 * @see org.springframework.context.MessageSourceAware#setMessageSource
 * @see org.springframework.context.ApplicationContextAware#setApplicationContext
 * @see org.springframework.web.context.ServletContextAware#setServletContext
 * @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessBeforeInitialization
 * @see InitializingBean#afterPropertiesSet
 * @see org.springframework.beans.factory.support.RootBeanDefinition#getInitMethodName
 * @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessAfterInitialization
 * @see org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor#postProcessBeforeDestruction
 * @see DisposableBean#destroy
 * @see org.springframework.beans.factory.support.RootBeanDefinition#getDestroyMethodName

2.解析

        标准初始化顺序如下

        2.1 调用beanFactory相关的aware接口

                2.1.1 BeanNameAware#setBeanName

                2.1.2 BeanClassLoaderAware#setBeanClassLoader

                2.1.3 BeanFactoryAware#setBeanFactory

        2.2 调用ApplicationContext相关的aware接口

                2.2.1 EnvironmentAware#setEnvironment

                2.2.2 EmbeddedValueResolverAware#setEmbeddedValueResolver

                2.2.3 ResourceLoaderAware#setResourceLoader

                2.2.4 ApplicationEventPublisherAware#setApplicationEventPublisher

                2.2.5 MessageSourceAware#setMessageSource

                2.2.6 ApplicationContextAware#setApplicationContext

                2.2.7 ServletContextAware#setServletContext

        2.3 调用BeanPostProcessor的初始化前置方法（AOP）

                2.3.1 BeanPostProcessor#postProcessBeforeInitialization

        2.4 调用初始化方法

                InitializingBean#afterPropertiesSet

        2.5 调用bean定义文件中的指定初始化方法

                RootBeanDefinition#getInitMethodName

        2.6 调用BeanPostProcessor的初始化后置方法（AOP）

                BeanPostProcessor#postProcessAfterInitialization

        2.7 其他

                DestructionAwareBeanPostProcessor#postProcessBeforeDestruction

                DisposableBean#destroy

                RootBeanDefinition#getDestroyMethodName

3.例证

<?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="blc" class="com.sh.basic.source.spring.BeanLifeCircle" init-method="init" destroy-method="myDestroy">
        <property name="name" value="nameBlc"></property>
    </bean>
    <bean id="mbpp" class="com.sh.basic.source.spring.MyBeanPostProcess"></bean>
</beans>

package com.sh.basic.source.spring;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor;

public class MyBeanPostProcess implements DestructionAwareBeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor-postProcessBeforeInitialization");
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor-postProcessAfterInitialization");
        return null;
    }

    @Override
    public boolean requiresDestruction(Object bean) {
        System.out.println("DestructionAwareBeanPostProcessor-requiresDestruction");
        return false;
    }

    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
        System.out.println("DestructionAwareBeanPostProcessor-postProcessBeforeDestruction");

    }
}

package com.sh.basic.source.spring;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.*;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.util.StringValueResolver;
import org.springframework.web.context.ServletContextAware;

import javax.servlet.ServletContext;

public class BeanLifeCircle implements BeanNameAware,
        BeanClassLoaderAware, BeanFactoryAware, EnvironmentAware,
        EmbeddedValueResolverAware, MessageSourceAware,
        ApplicationEventPublisherAware, ResourceLoaderAware,
        ApplicationContextAware, ServletContextAware,InitializingBean,DisposableBean {

    private String name;

    public void setName(String name) {
        System.out.println("setProperty");
    }

    public BeanLifeCircle() {
        System.out.println("constructor");
    }
    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("BeanClassLoaderAware-setBeanClassLoader");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryAware-setBeanFactory");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("BeanNameAware-setBeanName");
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        System.out.println("EmbeddedValueResolverAware-setEmbeddedValueResolver");
    }

    @Override
    public void setEnvironment(Environment environment) {
        System.out.println("EnvironmentAware-setEnvironment");
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        System.out.println("ApplicationEventPublisherAware-setApplicationEventPublisher");
    }

    @Override
    public void setMessageSource(MessageSource messageSource) {
        System.out.println("MessageSourceAware-messageSource");
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        System.out.println("ResourceLoaderAware-setResourceLoader");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("ApplicationContextAware-setApplicationContext");
    }

    @Override
    public void setServletContext(ServletContext servletContext) {
        System.out.println("ServletContextAware-setServletContext");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean-afterPropertiesSet");
    }

    public void init() {
        System.out.println("myInit");
    }

    public void myDestroy() {
        System.out.println("myDestroy");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean-destroy");
    }

}

3.1 入口 AbstractAutowireCapableBeanFactory#initializeBean

3.2 AbstractAutowireCapableBeanFactory#invokeAwareMethods

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

3.3 ApplicationContextAwareProcessor#invokeAwareInterfaces

private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationStartupAware) {
			((ApplicationStartupAware) bean).setApplicationStartup(this.applicationContext.getApplicationStartup());
		}
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}

3.4 AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

3.5 AbstractAutowireCapableBeanFactory#invokeInitMethods

3.6 AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				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;
	}

4.结论