為原始碼付出的每一分努力都不會白費。
1. Bean的例項化概述
前一篇分析了BeanDefinition的封裝過程，最終將beanName與BeanDefinition以一對一對映關係放到beanDefinitionMap容器中，這一篇重點分析如何利用bean的定義資訊BeanDefinition例項化bean。
2. 流程概覽
其實bean的例項化過程比較複雜，中間細節很多，為了抓住重點，先將核心流程梳理出來，主要包含以下幾個流程：
step1: 通過反射建立例項；
step2：給例項屬性賦初始值；
step3：如果Bean類實現BeanNameAware介面，則將通過傳遞Bean的名稱來呼叫setBeanName()方法；如果Bean類實現BeanClassLoaderAware介面，則將通過傳遞載入此Bean的ClassLoader物件的例項來呼叫setBeanClassLoader()方法；如果Bean類實現BeanFactoryAware介面，則將通過傳遞BeanFactory物件的例項來呼叫setBeanFactory()方法；
step4: 如果有類實現BeanPostProcessors介面，則將在初始化之前呼叫postProcessBeforeInitialization()方法；
step5：如果Bean類實現了InitializingBean介面，將呼叫afterPropertiesSet()方法，如果配置檔案中的Bean定義包含init-method屬性，則該屬性的值將解析為Bean類中的方法名稱，並將呼叫該方法；
step6: 如果有類實現BeanPostProcessors介面，則將在初始化之後呼叫postProcessAfterInitialization()方法；
step7：如果Bean類實現DisposableBean介面，則當Application不再需要Bean引用時，將呼叫destroy()方法；如果配置檔案中的Bean定義包含destroy-method屬性，那麼將呼叫Bean類中的相應方法定義。
3. 原始碼分析
進入AbstractApplicationContext中的fresh()方法，找到finishBeanFactoryInitialization(beanFactory)方法，該類是bean的例項化的入口，具體的例項化由preInstantiateSingletons()方法觸發，見如下程式碼：
public void preInstantiateSingletons() throws BeansException
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
//xml解析時，把所有beanName都快取到beanDefinitionNames了
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
//把父BeanDefinition裡面的屬性拿到子BeanDefinition中
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//如果不是抽象的，單例的，非懶載入的就例項化
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//判斷bean是否實現了FactoryBean介面
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
// 例項化過程
getBean(beanName);
}
}
}
上述程式碼主要看getBean方法，隨後進入doGetBean方法:
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
String beanName = transformedBeanName(name);
Object bean;
// 從快取中獲取bean.
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("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();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 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);
}
}
}
// Create bean instance
// 建立bean例項
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
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，如果沒有，則建立bean，最重要的方法就是getSingleton，該方法第二個引數是個函式式介面，進入getSingleton方法，當呼叫singletonObject = singletonFactory.getObject()時，會觸發函式式介面中的createBean方法，隨後一路進入doCreateBean，這個方法裡面完成了所有例項化所需的步驟:
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
// 真正開始建立bean的例項.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
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.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 屬性賦值
populateBean(beanName, mbd, instanceWrapper);
// 初始化bean
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 " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
// 有必要時，註冊bean的銷燬
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
從上述原始碼中看出bean的例項化主要分為以下三步：
step1:bean的建立；
step2:給bean的屬性賦值；
step3:bean的初始化；
接著得到exposedObject這個已經完全例項化後的bean返回，其中當有必要時，註冊bean的銷燬，後面再詳細看，先抓住主要流程。其中step3也是比較重要的方法，進入該方法:
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 {
// 啟用aware介面
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 初始化前處理的beanPostProcessor
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 啟用 init-method方法
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()) {
// 初始化後處理的beanPostProcessor
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
從上面原始碼可知，梳理出主要的四個步驟：
step1:啟用aware介面，完成aware介面的相關操作；
step2:初始化前處理的beanPostProcessor；
step3:完成init-method方法；
step4:初始化後處理的beanPostProcessor;
BeanPostProcessor作用是對初始化後的bean進行增強處理，在該階段 BeanPostProcessor 會處理當前容器內所有符合條件的例項化後的 bean 物件。它主要是對 Spring 容器提供的 bean 例項物件進行有效的擴充套件，允許Spring在初始化 bean 階段對其進行定製化修改，如處理標記介面或者為其提供代理實現。
4. 演示
定義一個MyBeanPostProcessor實現BeanPostProcessor介面
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("post Process Before Initialization 被呼叫...");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("post Process after Initialization 被呼叫...");
return bean;
}
}
定義一個LifeCycleBean類，實現如下介面：
public class LifeCycleBean implements BeanNameAware, BeanFactoryAware, BeanClassLoaderAware,
InitializingBean, DisposableBean {
private String property;
public String getProperty() {
return property;
}
public void setProperty(String property) {
System.out.println("屬性注入....");
this.property = property;
}
public LifeCycleBean(){
System.out.println("建構函式呼叫...");
}
@Override
public void setBeanClassLoader(ClassLoader classLoader) {
System.out.println("BeanClassLoaderAware 被呼叫...");
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("BeanFactoryAware 被呼叫...");
}
@Override
public void setBeanName(String name) {
System.out.println("BeanNameAware 被呼叫...");
}
@Override
public void destroy() throws Exception {
System.out.println("DisposableBean destroy 被呼叫...");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("InitializingBean afterPropertiesSet 被呼叫...");
}
public void initMethod(){
System.out.println("init-method 被呼叫...");
}
public void destroyMethod(){
System.out.println("destroy-method 被呼叫...");
}
public void display(){
System.out.println("方法呼叫...");
}
}
指定配置檔案spring.xml，配置init-method與destroy-method方法
<bean id="lifeCycle" class="com.wzj.bean.LifeCycleBean"
init-method="initMethod" destroy-method="destroyMethod">
<property name="property" value="property"/>
</bean>
<bean id="myBeanPostProcessor" class="com.wzj.bean.MyBeanPostProcessor" >
</bean>
測試類如下：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring.xml"})
public class TestSpring {
@Test
public void testLifeCycleBean() {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
}
執行結果：
建構函式呼叫...
屬性注入....
BeanNameAware 被呼叫...
BeanClassLoaderAware 被呼叫...
BeanFactoryAware 被呼叫...
post Process Before Initialization 被呼叫...
InitializingBean afterPropertiesSet 被呼叫...
init-method 被呼叫...
post Process after Initialization 被呼叫...
DisposableBean destroy 被呼叫...
destroy-method 被呼叫...
4. 總結
本篇從一個初學者的角度概覽了bean的整個生命週期，並描述了其中的主要流程，閱讀原始碼的初始階段，優先抓住主要流程，別陷入細節，並通過跑案例、寫註解、畫流程圖等方式加深理解，後續將繼續分析bean例項化中的核心流程、設計思想等。