在spring容器初始化过程中,在进行了BeanDefinition注册,processor应用等一系列处理之后, 接下来需要对非懒加载的Bean进行初始化处理。容器中的Bean实际初始化的过程在
- AbstractApplicationContext#refresh
- AbstractApplicationContext#finishBeanFactoryInitialization
- DefaultListableBeanFactory#preInstantiateSingletons
- AbstractApplicationContext#finishBeanFactoryInitialization
中,分析spring中的Bean初始化过程，这里就是可跟踪的代码入口。
根据BeanDefinition信息循环初始化Bean
DefaultListableBeanFactory#preInstantiateSingletons的代码如下所示。根据在BeanFactory中注册的BeanDefinition信息，或者说BeanNames信息，循环根据BeanName获取对应的BeanDefinition进行初始化操作，包括创建实例和注入实例所依赖的bean，如果实例依赖的bean没有被初始化，还会触发实例化依赖的bean。这个初始化获取bean的过程分为利用FactoryBean初始化和普通Bean的初始化，这里先展开普通Bean的初始化过程。
@Override
public void preInstantiateSingletons() throws BeansException {
//获取所有注册到BeanFactory的BeanName
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//非延迟加载的单例bean进行初始化
if (isFactoryBean(beanName)) {
//如果beanName是一个factoryBean的beanName，就进行利用FactoryBean进行初始化的过程，这里先不展开，后续展开
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final 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 {
//普通Bean初始化过程
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
bean初始化–从缓存获取bean
- AbstractBeanFactory#getBean(java.lang.String)
- AbstractBeanFactory#doGetBean
doGetBean方法非常长，截取前半部分看。
Object sharedInstance = getSingleton(beanName);尝试从已经初始化过的缓存bean中获取bean。当然这里面还包含一个特殊逻辑就是，基于FactoryBean进行初始化的Bean，需要利用缓存的FactoryBean实例来创建或者从factoryBeanObjectCache中获取，这些稍后都会提及。
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.
//尝试从已经初始化过的缓存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 {
//略略略。。。。
}
//。。。。。。
return (T) bean;
}
这里展开普通的Bean是如何尝试从缓存获取bean的，进入getSingleton方法
- DefaultSingletonBeanRegistry#getSingleton(String, boolean)
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//如果缓存存在于singletonObjects，就返回缓存的bean实例
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//如果获取不到，则再次判断，bean是否已经在创建的过程中，如果是的话，进行以下处理
//这里涉及并发处理的逻辑，以后还需详细分析《spring对于并发创建如何处理》
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
//返回对象，PS：这里获取到的对象可能是一个普通的Bean或者FactoryBean，所以还有后续的操作，不能直接返回这个实例给用户
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
如上所示，如果从缓存中获取到sharedInstance对象，但是不能直接返回这个对象，后续还要做的操作就是分析用户想获取的是一个Bean还是一个FactoryBean对象。这到底有什么区别呢？我们继续往下看。
跟踪代码bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);,可以知道结果，代码如下。
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
//[标注1]这里是一个关于FactoryBean规范的判断
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
// Now we have the bean instance, which may be a normal bean or a FactoryBean.
// If it's a FactoryBean, we use it to create a bean instance, unless the
// caller actually wants a reference to the factory.
//1.如果从缓存得到的不是一个FactoryBean就可以返回给用户
//2.或者说如果用于闲的蛋疼使用 "&FactoryBeanName"的方式想获取一个FactoryBean实例，也可以直接返回这个FactoryBean实例给用户。
//last：如果不是以上两种情况，就表示用户想要获取基于FactoryBean创建的Bean，则继续执行以下过程
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
if (mbd == null) {
//执行基于FactoryBean创建Bean的过程，后续另外展开。
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
**[标注1]spring对于FactoryBean存在一个规范判断，如果想要通过getBean方法获取一个FactoryBean实例，你只能通过&factoryBeanName的方式，例如GaFactoryBean类，按道理他的beanName是gaFactoryBean，但是实际上通过getBean(“gaFactoryBean”)获取到的是FactoryBean的产品而不是FactoryBean本身，想要获取FactoryBean本身，需要使用getBean("&gaFactoryBean")。[标注1]**里面的判断是如果一个beanName是"&"开头，却又不是FactoryBean，就会抛出BeanIsNotAFactoryException
综上所述，对于单例对象，假如能够从缓存中得到bean实例，就无需新建单例，就可以直接返回实例给容器用户。
bean初始化–新建bean
假如压根不能从缓存中获取到对象，那么就需要执行另一部分逻辑，新建bean实例。
- AbstractBeanFactory#doGetBean
另一半代码逻辑如下。
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.
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == 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中有没有这个Bean实例，有的话从父亲容器获取，类似类加载的双亲委派机制
//父亲BeanFactory也可以继续往上层的BeanFactory查找
BeanFactory parentBeanFactory = getParentBeanFactory();
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 {
//获取BeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
//[标注2]查看depends-on配置的Bean是否存在，如果有depends-on配置，那么首先初始化depends-on的bean，后续才继续初始化当前bean。
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
if (isDependent(beanName, dependsOnBean)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
}
registerDependentBean(dependsOnBean, beanName);
getBean(dependsOnBean);
}
}
// Create bean instance.
//终于到了创建当前bean了(T.T)
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);
}
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;
}
}
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
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;
}
**[标注2]**depends-on 是bean标签中的一个属性，可以配置当前bean所依赖的bean。这一个配置的意义就是让当前bean所依赖的bean优先于当前的 bean进行初始化，以及晚于当前bean destroy。这个跟依赖注入并不是同一个含义。
新建bean过程的缓存处理
对于上面的代码，太长，我们关注典型的单例模式的创建代码，截取单例模式的创建部分，一下子视野开阔了许多。。代码如下。
// Create bean instance.
//终于到了创建当前bean了(T.T)
if (mbd.isSingleton()) {
//单例创建
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
//ObjectFactory的getObject作为回调函数传入
@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);
}
上面的代码，咋看之下跟从缓存中获取有点像，确实也是，这里getSingleton代码是尝试从缓存中获取，如果获取不到就会调用ObjectFactory的getObject作为回调函数新建一个实例。这里先看看getSingleton，再看看回调函数的逻辑。DefaultSingletonBeanRegistry#getSingleton代码如下。抛去一些逻辑，只显示主要关注点
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
//如果缓存没有bean，执行if逻辑进行创建
//略略略
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
//ObjectFactory的getObject回调函数
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
//略略略
}
catch (BeanCreationException ex) {
//略略略
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
//新建的bean放入缓存中，key是beanName，缓存处理手段
addSingleton(beanName, singletonObject);
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
了解了部分在创建bean过程中的缓存处理手段，我们可以正式关注创建的过程，跟踪ObjectFactory的getObject回调函数即可。
新建bean主干处理逻辑
继续跟踪创建过程代码，
- AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])
- AbstractAutowireCapableBeanFactory#doCreateBean
这个方法涉及的逻辑也是非常多，处理常规的创建实例过程，还有其他一些常见的prossor调用，需要仔细分析。
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) {
//--------------------------------创建bean实例
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.
//调用所有实现的MergedBeanDefinitionPostProcessor#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.
Object exposedObject = bean;
try {
//------------------给新建的bean实例进行依赖注入
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
//[标注3]执行常用的需要处于初始化生命周期执行的方法，例如常见的AwareMethod、BeanPostProcessor的处理方法，详看[标注3]
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()) {
//略略略
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
**[标注3]**详情看下面的AwareMethod和BeanPostProcessor方法的执行原理
AwareMethod和BeanPostProcessor方法的执行原理
如果对于spring使用比较熟悉的可能知道，我们对于在bean初始化周期想要执行一些逻辑处理，可以使用@PostConstruct、实现InitializingBean#afterPropertiesSet、实现BeanPostProcessor#postProcessBeforeInitialization、实现BeanPostProcessor#postProcessAfterInitialization等等的方式，这里需要讨论的就是实现InitializingBean#afterPropertiesSet、实现BeanPostProcessor#postProcessBeforeInitialization、实现BeanPostProcessor#postProcessAfterInitialization的调用时机与原理。
还有就是常用的BeanFactoryAware、BeanClassLoaderAware接口的原理等。
了解这些周期方法的原理有助于我们更加了解spring的实现。
假如在上面的初始化bean过程中执行了，新建bean–>bean依赖注入，那么接下来执行的就是上述的一些方法。
try {
//------------------给新建的bean实例进行依赖注入
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
//[标注3]执行常用的需要处于初始化生命周期执行的方法，例如常见的AwareMethod、BeanPostProcessor的处理方法，详看[标注3]
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
进入AbstractAutowireCapableBeanFactory#initializeBean(String, Object, RootBeanDefinition)方法，代码如下。
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 {
//1.为实现BeanFactoryAware、BeanClassLoaderAware接口的类注入BeanFactory、ClassLoader
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//2.调用BeanPostProcessor#postProcessBeforeInitializationd
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//3.调用InitializingBean#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()) {
//4.调用BeanPostProcessor#postProcessAfterInitialization
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
首先看一下AbstractAutowireCapableBeanFactory#invokeAwareMethods，这个注入方法。
private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
//如果实现BeanNameAware接口
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanNameAware) {
//如果实现BeanNameAware接口
((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
}
if (bean instanceof BeanFactoryAware) {
//如果实现BeanFactoryAware接口
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
再看AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization，这个方法是针对所有的bean的一种处理方法，不是某个bean的特定方法
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
//可以对传入的bean进行操作
result = beanProcessor.postProcessBeforeInitialization(result, beanName);
if (result == null) {
return result;
}
}
return result;
}
再看AbstractAutowireCapableBeanFactory#invokeInitMethods，这里面会调用bean的afterPropertiesSet方法，如果bean使用init-method 定义了特定的初始化方法，这个就是bean自己本身的方法。
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 {
//执行bean的afterPropertiesSet方法
((InitializingBean) bean).afterPropertiesSet();
}
}
if (mbd != null) {
//执行init-method 定义的初始化方法
String initMethodName = mbd.getInitMethodName();
if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
BeanPostProcessor#postProcessAfterInitialization调用同理类似BeanPostProcessor#postProcessBeforeInitializationd。
创建Bean过程
说明了上面的**[标注3]**，让我们回到创建bean的代码，按照原本的代码,AbstractAutowireCapableBeanFactory#doCreateBean中
if (instanceWrapper == null) {
//--------------------------------创建bean实例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
所以回到以下代码跟踪
推断创建bean所需的方法
-
AbstractAutowireCapableBeanFactory#createBeanInstance
这个方法目的是选择一个合适构造器来创建bean，可能是@Bean标注方法一类，或者是BeanClass对应的构造器。。。。
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) { // Make sure bean class is actually resolved at this point. 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) { //如果BeanDefinition中存在bean创建方法的定义，那么调用这个方法来构建bean，例如@Bean注解标注的方法就是在这里调用 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); } // No special handling: simply use no-arg constructor. //一般组件默认使用无参构造器创建bean return instantiateBean(beanName, mbd); } -
AbstractAutowireCapableBeanFactory#instantiateBean（默认无特殊操作使用无参数构造器时调用，以此为例跟踪），代码如下。这个方法对新建的bean进行包装返回。
-
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 { //选择合适的初始化策略，调用无参构造器创建bean，继续跟踪 beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent); } //将创建的bean包装为BeanWrapper对象 BeanWrapper bw = new BeanWrapperImpl(beanInstance); initBeanWrapper(bw); return bw; } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex); } }
获取无参Constructor创建bean
- SimpleInstantiationStrategy#instantiate(RootBeanDefinition, String, BeanFactory)，在这个方法中，定位出Bean的无参构造方法Constructor对象，为创建准备。
- BeanUtils#instantiateClass(Constructor,Object…)
BeanUtils#instantiateClass代码如下。利用Constructor创建新对象，自此完成创建bean。
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
Assert.notNull(ctor, "Constructor must not be null");
try {
ReflectionUtils.makeAccessible(ctor);
//创建bean新对象
return ctor.newInstance(args);
}
//略略略
}
}
Bean的依赖注入
等上面创建Bean实例过程完成，并且包装一个BeanWrapper返回之后，就需要执行属性的依赖注入了。回到**·新建bean主干处理逻辑·**
//------------------给新建的bean实例进行依赖注入
populateBean(beanName, mbd, instanceWrapper);
方法代码如下。
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.
//在属性设置之前可以修改bean的状态
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;
}
//根据定义的AutowireMode决定使用什么注入方式，但是默认下AutowireMode是AUTOWIRE_NO，不使用以下注入方式
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;
//[标注4]默认情况下，使用InstantiationAwareBeanPostProcessor处理依赖注入
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
applyPropertyValues(beanName, mbd, bw, pvs);
}
[标注4] 请看下面
InstantiationAwareBeanPostProcessor处理依赖注入
spring处理依赖注入，利用InstantiationAwareBeanPostProcessor#postProcessPropertyValues完成，遍历所有InstantiationAwareBeanPostProcessor实例，执行相应处理。
不同的InstantiationAwareBeanPostProcessor实例处理不同类型的注解的依赖注入，最常见的有以下两种：
- CommonAnnotationBeanPostProcessor----处理@Resource注解标注的依赖注入
- AutowiredAnnotationBeanPostProcessor----处理@Value、@Autowired注解标注的依赖注入。
以AutowiredAnnotationBeanPostProcessor为例，当遍历到AutowiredAnnotationBeanPostProcessor时，进入AutowiredAnnotationBeanPostProcessor的postProcessPropertyValues实现方法，代码如下。
@Override
public PropertyValues postProcessPropertyValues(
PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
//1.找到需要依赖注入的属性
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
//2.根据属性进行获取依赖并且注入
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
定位需要进行注入的属性
要进行属性注入，首先需要定位到哪些属性是需要属性注入的。换言之需要找到被@Value，@Autowired
标注的属性，并且获取BeanClass中这些注解的标注信息，例如@Value("${xxx}")中的xxx信息。
上面的代码中的第一个步骤就是这个过程。
follow以下代码。
- AutowiredAnnotationBeanPostProcessor#findAutowiringMetadata
- AutowiredAnnotationBeanPostProcessor#buildAutowiringMetadata
private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>();
Class<?> targetClass = clazz;
do {
final LinkedList<InjectionMetadata.InjectedElement> currElements =
new LinkedList<InjectionMetadata.InjectedElement>();
//寻找@Value，@Autowired标注的Field，并且包装为InjectedElement
ReflectionUtils.doWithLocalFields(targetClass, new ReflectionUtils.FieldCallback() {
@Override
public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
AnnotationAttributes ann = findAutowiredAnnotation(field);
if (ann != null) {
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation is not supported on static fields: " + field);
}
return;
}
boolean required = determineRequiredStatus(ann);
currElements.add(new AutowiredFieldElement(field, required));
}
}
});
//寻找@Autowired标注在方法之上的属性，同样封装为InjectedElement
ReflectionUtils.doWithLocalMethods(targetClass, new ReflectionUtils.MethodCallback() {
@Override
public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
if (Modifier.isStatic(method.getModifiers())) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation is not supported on static methods: " + method);
}
return;
}
if (method.getParameterTypes().length == 0) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation should be used on methods with parameters: " + method);
}
}
boolean required = determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
//AutowiredMethodElement
currElements.add(new AutowiredMethodElement(method, required, pd));
}
}
});
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
return new InjectionMetadata(clazz, elements);
}
以标注在属性上的依赖注入为了，doWithLocalFields循环遍历field，调用回调函数doWith，抽出doWith代码，如下。
public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
//查找这个field上属于依赖注入的注解
AnnotationAttributes ann = findAutowiredAnnotation(field);
if (ann != null) {
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation is not supported on static fields: " + field);
}
return;
}
boolean required = determineRequiredStatus(ann);
currElements.add(new AutowiredFieldElement(field, required));
进一步看一下是如何判断是否是依赖注入注解。autowiredAnnotationTypes中只要包含了这个注解，就可以定义为需要注入的属性。
private AnnotationAttributes findAutowiredAnnotation(AccessibleObject ao) {
if (ao.getAnnotations().length > 0) {
for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ao, type);
if (attributes != null) {
return attributes;
}
}
}
return null;
}
而autowiredAnnotationTypes在AutowiredAnnotationBeanPostProcessor初始化时就有定义。所以@Autowired，@Value能够在AutowiredAnnotationBeanPostProcessor中处理。
public AutowiredAnnotationBeanPostProcessor() {
//包含@Autowired
this.autowiredAnnotationTypes.add(Autowired.class);
//包含@Value
this.autowiredAnnotationTypes.add(Value.class);
try {
this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
进行依赖注入
在定位了需要依赖注入的属性之后，得到一个InjectionMetadata对象，里面封装了需要依赖注入的InjectedElement的列表，但是需要注意这里的InjectedElement实际上是AutowiredFieldElement，如果是使用setter的话上面的代码可以知道返回的是AutowiredMethodElement。调用InjectionMetadata的inject方法。跟踪代码如下。
- InjectionMetadata#inject （遍历AutowiredFieldElement的inject方法）
- AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
这个方法就是为bean注入属性的地方，利用反射的方式。 beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter)获取到依赖的bean实例。所以接下来看如果获取依赖的Bean。
@Override
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
Field field = (Field) this.member;
Object value;
if (this.cached) {
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
else {
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
TypeConverter typeConverter = beanFactory.getTypeConverter();
try {
//根据field等信息，从beanFActory获取目标bean
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
synchronized (this) {
if (!this.cached) {
if (value != null || this.required) {
//缓存对目标bean依赖的信息
this.cachedFieldValue = desc;
registerDependentBeans(beanName, autowiredBeanNames);
if (autowiredBeanNames.size() == 1) {
String autowiredBeanName = autowiredBeanNames.iterator().next();
if (beanFactory.containsBean(autowiredBeanName)) {
if (beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
this.cachedFieldValue = new ShortcutDependencyDescriptor(
desc, autowiredBeanName, field.getType());
}
}
}
}
else {
this.cachedFieldValue = null;
}
this.cached = true;
}
}
}
if (value != null) {
//利用field，反射设置属性值
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
}
- DefaultListableBeanFactory#resolveDependency
- DefaultListableBeanFactory#doResolveDependency 处理依赖，这里代码非常多，就不贴出。这个方法，对于@Value标注可以获得对应的值，对于@Autowired标注可以获得对应bean。
接下来，假如是@Autowired，会执行以下调用链。
-
DefaultListableBeanFactory#findAutowireCandidates
protected Map<String, Object> findAutowireCandidates( String beanName, Class<?> requiredType, DependencyDescriptor descriptor) { //根据classType，获取候选的beanName String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors( this, requiredType, true, descriptor.isEager()); Map<String, Object> result = new LinkedHashMap<String, Object>(candidateNames.length); for (Class<?> autowiringType : this.resolvableDependencies.keySet()) { if (autowiringType.isAssignableFrom(requiredType)) { Object autowiringValue = this.resolvableDependencies.get(autowiringType); autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType); if (requiredType.isInstance(autowiringValue)) { result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue); break; } } } for (String candidateName : candidateNames) { if (!isSelfReference(beanName, candidateName) && isAutowireCandidate(candidateName, descriptor)) { //descriptor.resolveCandidate根据候选的BeanName获取Bean，而descriptor.resolveCandidate只有一个逻辑，就是beanFactory.getBean(beanName, requiredType); result.put(candidateName, descriptor.resolveCandidate(candidateName, requiredType, this)); } } if (result.isEmpty() && !indicatesMultipleBeans(requiredType)) { // Consider fallback matches if the first pass failed to find anything... DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch(); for (String candidateName : candidateNames) { if (!isSelfReference(beanName, candidateName) && isAutowireCandidate(candidateName, fallbackDescriptor)) { result.put(candidateName, descriptor.resolveCandidate(candidateName, requiredType, this)); } } if (result.isEmpty()) { // Consider self references before as a final pass for (String candidateName : candidateNames) { if (isSelfReference(beanName, candidateName) && isAutowireCandidate(candidateName, fallbackDescriptor)) { result.put(candidateName, descriptor.resolveCandidate(candidateName, requiredType, this)); } } } } return result; }
上面的findAutowireCandidates 执行完整，就能得到一个依赖的Bean，最终回到AutowiredFieldElement中，通过反射注入属性值。
总结来说，进行完上面的依赖注入过程，就会进行之前提到的initializeBean初始方法的调用，然后返回bean对象，从而完成初始化。
补上：如何初始化基于FactoryBean注册的Bean
了解完一般Bean的初始化的整个流程，可以进一步补充一下基于FactoryBean注册的Bean的获取流程。FactoryBean的初始化就是一个一般过程，但是FactoryBean的产品bean初始化获取却有所不同。
上面提到，想要通过getBean获取FactoryBean的产品就要使用getBean(“factoryBean”)。工厂bean的产品的beanName在表面上看就是工厂bean的名称。
在容器初始化完成之后，尝试使用getBean(“gaFactoryBean”)获取产品，gaFactoryBean是我定义的一个工厂Bean。在第一次调用getBean(“gaFactoryBean”)时候才会初始化工厂Bean的产品，类似于延迟加载的bean。
跟踪getBean代码。
- AbstractApplicationContext#getBean(java.lang.String)
- AbstractBeanFactory#getBean(java.lang.String)
- AbstractBeanFactory#doGetBean
- AbstractBeanFactory#getBean(java.lang.String)
这里跟踪就回到了上面提到的过程【bean初始化–从缓存获取bean】，当根据“gaFactoryBean”作为key从缓存获取Bean时，getSingleton方法从BeanFactory的singletonObjects缓存中获取到了FactoryBean已经初始化过的实例。也就是说第一次获取时是一个工厂bean。
//关键代码
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
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);
}
当获取到一个工厂bean的sharedInstance实例时，继续往下执行getObjectForBeanInstance，代码如下。
如果当前得到的Bean是一个工厂Bean，那么就会执行下去，到object = getCachedObjectForFactoryBean(beanName)。可以预知这个方式是调用工厂Bean的getObject方法获取一个Bean对象。
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
//[标注1]这里是一个关于FactoryBean规范的判断
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
// Now we have the bean instance, which may be a normal bean or a FactoryBean.
// If it's a FactoryBean, we use it to create a bean instance, unless the
// caller actually wants a reference to the factory.
//1.如果从缓存得到的不是一个FactoryBean就可以返回给用户
//2.或者说如果用于闲的蛋疼使用 "&FactoryBeanName"的方式想获取一个FactoryBean实例，也可以直接返回这个FactoryBean实例给用户。
//last：如果不是以上两种情况，就表示用户想要获取基于FactoryBean创建的Bean，则继续执行以下过程
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
if (mbd == null) {
//尝试从工厂Bean产品缓存列表中获取对象
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
//利用工厂Bean创建对象
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
follow，以下调用链，
- FactoryBeanRegistrySupport#getObjectFromFactoryBean （把获得的bean放入factoryBeanObjectCache缓存起来）
- FactoryBeanRegistrySupport#doGetObjectFromFactoryBean
执行创建过程，
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
throws BeanCreationException {
Object object;
try {
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
return factory.getObject();
}
}, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
//调用getObject
object = factory.getObject();
}
}//。。。。略略了
return object;
}
最终返回通过factoryBean创建的实例。
394
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
