在【spring 源码】IOC 之 ClassPathXmlApplicationContext 1-5 小段源码里多次调用了getBean（）的方法，我们经常通过这个方法从beanFactory里获取bean实例，而bean的初始化细节也在这个方法里实现了。本文重点解析getBean（）方法。
AbstractBeanFactory#getBean()
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
// L235
@SuppressWarnings("unchecked")
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;
// 从手动注册的单例缓存里取出相关实例在下面的1-0展开细说
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
//创建实例的第一种方式：正在创建的共享单例实例不为空且是无参数的情况（此时的单例对象并没有真正实例化完毕，仅仅是提前曝光，解决循环依赖的策略）
...//打印相关日志，略
// 下面这个方法：如果是普通 Bean 的话，直接返回 sharedInstance，
// 如果是 FactoryBean 的话，返回它创建的那个实例对象 详见1-1
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//创建实例的第二种方式
// 当前线程已经创建过了此 beanName 的 prototype 类型的 bean，那么抛异常.能调用到这里的肯定都是单例的
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 检查当前父bean工厂是否存在该bean实例，如果不存在就递归调用知道有实例返回
String nameToLookup = originalBeanName(name);
if (args != null) {
// 有参数，这里不展开详说
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// 无参数创建实例
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
//将beanName放入alreadyCreated，标识其实例已经创建
markBeanAsCreated(beanName);
}
try {
final 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);
getBean(dep);
}
}
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
//这里是第二种创建bean实例的方式，1-2展开详说
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()) {
...
}
else {
...
}
}
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.isInstance(bean)) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
catch (TypeMismatchException ex) {
...
}
}
return (T) bean;
}
复制代码1-0 getSingleton(beanName);
这里的getSingleton（）调用了AbstractBeanFactory父类DefaultSingletonBeanRegistry#getSingleton（）方法。
在此之前我们先了解一下spring单例的三级缓存
/** 已实例好单例对象缓存 为了方便理解称为一级缓存（下同）*/
private final Map singletonObjects = new ConcurrentHashMap(256);
/** 提前曝光的单例对象缓存（尚未实例完） 二级缓存*/
private final Map earlySingletonObjects = new HashMap(16);
/** 单例对象工厂缓存 三级缓存*/
private final Map> singletonFactories = new HashMap>(16);
复制代码DefaultSingletonBeanRegistry.java L172
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
/**
* Return the (raw) singleton object registered under the given name.
* Checks already instantiated singletons and also allows for an early
* reference to a currently created singleton (resolving a circular reference).
* 大体意思是：返回一个以给定名称注册的单例对象，检查已经实例好的单例池子，同时也允许对当前对象的引用
*/
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//单例对象的cache
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//一级缓存里没有该对象并且此beanName正在创建过程中才会进来，因为正在创建的bean也许会在二级缓存里
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);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
复制代码到这里已经把spring 单例的三级缓存说完了，这三个缓存是spring处理循环依赖的重要依据，有兴趣的话可以看我之前的文章《spring是如何解决循环依赖的？》。
1-1 getObjectForBeanInstance(sharedInstance, name, beanName, null)第一种创建bean实例的方式
AbstractBeanFactory#getObjectForBeanInstance（） L1607
/**
* Get the object for the given bean instance, either the bean
* instance itself or its created object in case of a FactoryBean.
* 下面这个方法：如果是普通 Bean 的话，直接返回 sharedInstance，
* 如果是 FactoryBean 的话，返回它创建的那个实例对象
*/
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.
//如果这个bean不是工厂bean，直接抛异常，不让其调用者撤销引用工厂
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
//name以&开头并且bean实例不属于工厂bean，直接抛异常
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.
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
//①如果bean实例不是工厂bean，名称是以&开头，直接放回bean实例
//②如果bean实例是工厂bean，名称不是以&开头，直接放回bean实例
return beanInstance;
}
Object object = null;
if (mbd == null) {
//从factoryBeanObjectCache缓存里取
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
if (mbd == null && containsBeanDefinition(beanName)) {
//将该类的子类、父类配置信息都集中到rootBeanDefinition里
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
//下面调用了FactoryBeanRegistrySupport类的getObjectFromFactoryBean（），是从factoryBean里获取bean实例的入口
object = getObjectFromFactoryBean(factory, beanName,!synthetic);
}
return object;
}
复制代码1-1-0 getObjectFromFactoryBean（factory, beanName,!synthetic）
FactoryBeanRegistrySupport#getObjectFromFactoryBean（） L98
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
if (factory.isSingleton() && containsSingleton(beanName)) {
//单例场景
synchronized (getSingletonMutex()) {
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
//这里是实例化bean的最核心入口
object = doGetObjectFromFactoryBean(factory, beanName);
// Only post-process and store if not put there already during getObject() call above
// (e.g. because of circular reference processing triggered by custom getBean calls)
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
if (object != null && shouldPostProcess) {
try {
//这里会调用所有BeanPostProcessor#postProcessAfterInitialization的实现方法，这里不做展开，后续会有文章介绍
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
}
this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
}
}
return (object != NULL_OBJECT ? object : null);
}
}
else {
//非单例场景，这里不做展开
...
return object;
}
}
复制代码1-1-0-0. ==doGetObjectFromFactoryBean（factory, beanName）==
FactoryBeanRegistrySupport#doGetObjectFromFactoryBean（） L148
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
throws BeanCreationException {
Object object;
try {
//调用java的安全模型来实例化相关类，保证安全
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 {
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
if (object == null && isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
return object;
}
复制代码这里只简单说一下，后面会有专门一篇文章详细介绍java的安全模型，感兴趣的同学可以先参考《Java 授权内幕》，Java 安全模型介绍》，《Java安全——安全管理器、访问控制器和类装载器》先了解一下java的安全模型。
小结一下，到这里整个1-1第一种创建bean实例的方法结束了，接下来继续回到AbstractBeanFactory#doGetBean()方法继续往下看。
1-2 createBean(beanName, mbd, args)第二种创建bean方式
//AbstractAutowireCapableBeanFactory#createBean() L447
/**
* Central method of this class: creates a bean instance,
* populates the bean instance, applies post-processors, etc.
* @see #doCreateBean
*/
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
...
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
...
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
...
}
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
...
}
return beanInstance;
}
复制代码
83
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
