前面的博文已经探索到spring如果解析xml资源文件的,现在我们来看看spring是如何加载bean的。
核心代码
@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;
// 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);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (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 {
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 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.
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 '" + 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;
}
final String beanName = transformedBeanName(name);
使用do…while循环找到别名指向的最终的beanName;去除FactoryBean 的&号
getSingleton(String beanName)
从缓存中获取单例bean
singletonObjects -> earlySingletonObjects -> singletonFactories
-> factoryBean.getObject()
- 如果在缓存中得到值:
getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd)
从bean的实例中获取对象,高频率使用方法
作用:判断beanInstance是否是FactoryBean.是,则通过FactoryBean的getObject()方法获取最终的object.
该方法流程:
1. 先从factoryBeanObjectCache缓存中获取对应的object
2. 直接从factoryBean中获取.
3. 如果是单例:1.存入缓存。2.postProcessObjectFromFactoryBean
bean的后处理器BeanPostProcessor
4. ps:3.2版本之前,如果不是单例的,postProcessObjectFromFactoryBean步骤也需要执行。
如果在缓存中得不到值:
- 判断是否存在prototype的循环引用ThreadLocal
- this.beanDefinitionMap 中不含有beanName,则到parentBeanFactory中去寻找
- 转换为RootBeanDefinition,如果是子bean则合并父类属性
- 处理依赖,先实例化依赖的bean
singleton模式的创建
使用getSingleton重载方法,getSingleton(String beanName, ObjectFactory<?> singletonFactory)
获取bean,然后存入到singletonObjects
缓存当中,清除其他的辅助状态。
调用以下代码,记录加载状态,把正在创建的bean记录到缓存中,作用:对循环依赖进行检测。
创建完bean后,调用afterSingletonCreation
从缓存中移除。
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
- getSingleton方法参数 singletonFactory ,实体中的getObject方法的实现
protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
// Make sure bean class is actually resolved at this point.
resolveBeanClass(mbd, beanName);
// Prepare method overrides.
try {
mbd.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
Object bean = resolveBeforeInstantiation(beanName, mbd);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
Object beanInstance = doCreateBean(beanName, mbd, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
resolveBeanClass(mbd, beanName);
确认此时的beanDefinition中的BeanClass是指定的Class
mbd.prepareMethodOverrides();
对lookup-method和replace-method 的配置methodOverrides进行处理。
Object bean = resolveBeforeInstantiation(beanName, mbd);
实例化的前置处理。AOP的功能就是在这里判断的。 执行InstantiationAwareBeanPostProcessor 接口A的两个方法。postProcessBeforeInstantiation,postProcessAfterInitialization
该接口继承了BeanPostProcessor,这个接口B里面也有两个接口, postProcessBeforeInitialization
看上去很相似,其实不同,前者是实例化前的后处理,后者是初始化前的后处理。所以有区别。
如果执行了前者接口A的两个方法,并且返回的bean不为空,那么后者接口B就不会执行了,因为已经已经得到了一个代理bean,并且postProcessBeforeInitialization方法是在doCreateBean中的initializeBean执行的
Object beanInstance = doCreateBean(beanName, mbd, args);
创建bean
- 使用bean指定的策略创建新的实例,如工厂方法
- 提前曝光,bean初始化完成前将创建实例的ObjectFactory加入工厂
- 对bean进行填充,包含其他属性和依赖的bean
- 循环依赖检测
- 注册DisposableBean
- 完成创建并返回。