在spring容器初始化过程中,在进行了BeanDefinition注册,processor应用等一系列处理之后, 接下来需要对非懒加载的Bean进行初始化处理。容器中的Bean实际初始化的过程在
中,分析spring中的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();
}
}
}
}
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
方法
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实例。
另一半代码逻辑如下。
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。这个跟依赖注入并不是同一个含义。
对于上面的代码,太长,我们关注典型的单例模式的创建代码,截取单例模式的创建部分,一下子视野开阔了许多。。代码如下。
// 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回调函数即可。
继续跟踪创建过程代码,
这个方法涉及的逻辑也是非常多,处理常规的创建实例过程,还有其他一些常见的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方法的执行原理
如果对于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。
说明了上面的**[标注3]**,让我们回到创建bean的代码,按照原本的代码,AbstractAutowireCapableBeanFactory#doCreateBean中
if (instanceWrapper == null) {
//--------------------------------创建bean实例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
所以回到以下代码跟踪
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);
}
}
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实例过程完成,并且包装一个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] 请看下面
spring处理依赖注入,利用InstantiationAwareBeanPostProcessor#postProcessPropertyValues完成,遍历所有InstantiationAwareBeanPostProcessor实例,执行相应处理。
不同的InstantiationAwareBeanPostProcessor实例处理不同类型的注解的依赖注入,最常见的有以下两种:
以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以下代码。
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方法。跟踪代码如下。
这个方法就是为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);
}
}
}
接下来,假如是@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对象,从而完成初始化。
了解完一般Bean的初始化的整个流程,可以进一步补充一下基于FactoryBean注册的Bean的获取流程。FactoryBean的初始化就是一个一般过程,但是FactoryBean的产品bean初始化获取却有所不同。
上面提到,想要通过getBean获取FactoryBean的产品就要使用getBean(“factoryBean”)。工厂bean的产品的beanName在表面上看就是工厂bean的名称。
在容器初始化完成之后,尝试使用getBean(“gaFactoryBean”)获取产品,gaFactoryBean是我定义的一个工厂Bean。在第一次调用getBean(“gaFactoryBean”)时候才会初始化工厂Bean的产品,类似于延迟加载的bean。
跟踪getBean代码。
这里跟踪就回到了上面提到的过程【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,以下调用链,
执行创建过程,
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创建的实例。