不管是何种类型的bean，最终都要通过createBean方法来创建，处理，createBean方法可以说是beanFactory最重要的方法之一，其实现在AbstractAutowireCapableBeanFactory类中。
创建bean实例，计算bean实例，post-processors处理等等。
分析
createBean创建bean的时候调用的是doCreateBean方法。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) { // Instantiate the bean.
// 实例化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.
// 使用post-processors修改bean difinition，获取类型MergedBeanDefinitionPostProcessor的PostProcessor调用postProcessMergedBeanDefinition方法。
synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
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.
// 将刚才获取的beanInstance指向exposedObject。
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<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.
// 如果bean实现了disposable接口，注册这些bean。
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
} catch (BeanDefinitionValidationException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
} return exposedObject;
}初始化bean的实例，在doCreateBean内部，创建bena之后，需要对bean做一些初始化的工作。
Object exposedObject = bean; try { //从bean difinition中计算bean实例的属性值
populateBean(beanName, mbd, instanceWrapper); if (exposedObject != null) { //初始化bean，应用Factory 回调，init方法，和bean post processors
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);
}
}
// 初始化bean的实例 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;
}2.1 首先设置bean的aware，如果bean实现了Aware方法，那么依次设置
BeanNameAware
BeanClassLoaderAware
BeanFactoryAware
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);
}
}
}2.2 调用bean的init方法。invokeInitMethods
如果bean实现了InitializingBean方法，或者配置的方法为afterPropertiesSet，那么调用afterPropertiesSet方法
如果bean的初始化方法是自定义的，那么调用自定义的初始化方法
有些bean会在调用invokeInitMethods前后使用beanPostProcessors进行postProcessBeforeInitialization，postProcessAfterInitialization处理
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);
}
}
}注册实现了DisposableBean或者配置了销毁方法的bean
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null); if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) { if (mbd.isSingleton()) { // Register a DisposableBean implementation that performs all destruction
// work for the given bean: DestructionAwareBeanPostProcessors,
// DisposableBean interface, custom destroy method.
registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
} else { // A bean with a custom scope...
Scope scope = this.scopes.get(mbd.getScope()); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
}
scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
}
}返回bean
回顾
在创建bean，并且初始化bean的过程基本经历：
实例化bean，通过反射创建一个对象出来
设置bean的属性populateBean
调用initAware方法，配置一些bean的aware
(根据条件)beanProcessor.postProcessBeforeInitialization方法
调用afterPropertiesSet或者自定义的其它初始化的方法
(根据条件)beanProcessor.postProcessAfterInitialization方法
注册实现了销毁方法的bean，可能是实现DisposableBean接口，或者定义了销毁方法
总结
可以看到在createBean的时候，基本上完成了bean生命周期的配置，创建，初始化，注册需要销毁的bean。
随时随地看视频
