spring容器refresh方法源码分析(二)接着前面讲:
文章目录
finishBeanFactoryInitialization初始化所有单例的bean(懒加载除外)最重要
直接看抽象类AbstractApplicationContext中的源码:
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
// 初始化上下文的转换服务conversionService,
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
// 容器是否注册了嵌入值解析器,如果没有注册默认的嵌入值解析器(主要用于注解属性值的解析)
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
@Override
public String resolveStringValue(String strVal) {
return getEnvironment().resolvePlaceholders(strVal);
}
});
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
// 初始化LoadTimeWeaverAware对象
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
//getBean也会加载bean
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
// 停止使用临时类型匹配的类加载器。
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
// 冻结所有bean定义,不允许修改了
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
// 实例化所有(非懒加载) 单利bean
beanFactory.preInstantiateSingletons();
}
点到方法preInstantiateSingletons,是这个类的方法DefaultListableBeanFactory:
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isDebugEnabled()) {
logger.debug("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
// 创建beanDefinitionNames的副本beanNames用于后续的遍历,可能后续通过init方法注册新的bean定义
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
// 遍历,初始化非懒加载bean
for (String beanName : beanNames) {
// 获取beanName的RootBeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// bd,表示bean定义,不是抽象的&& 单利的 && 不是懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 判断是否是工厂bean
if (isFactoryBean(beanName)) {
// 通过beanName获取工厂bean实例,&+beanName;工厂bean如果不加&会执行factoryBean的getObject方法
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
// 判断这个工厂bean是否优先初始化
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
// 如果渴望先初始化,则通过getBean初始化
getBean(beanName);
}
}
else {
// 不是工厂bean,通过getBean初始化bean
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
// 触发所有SmartInitializingSingleton的后初始化回调
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
//触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
smartSingleton.afterSingletonsInstantiated();
return null;
}
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
getBean
这时候发现getBean方法是最重要,通过名字应该是获取bean,但是创建bean的方法也封装在了这个方法:
源码:
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//解析beanName,解析别名,去掉FactoryBean的前缀&
final String beanName = transformedBeanName(name);
//返回的bean
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 尝试从缓存中获取beanName的实例(重要)
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// 如果beanName的实例存在于缓存中
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 的话，直接返回 sharedInstance，
// 如果是 FactoryBean 的话，返回它创建的那个实例对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 创建过了此 beanName 的 scope为 prototype 类型的 bean，那么抛异常，
// 往往是因为陷入了循环依赖
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
// 获取beanFactory,检测beanDefinition在容器中是否存在
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
// 将别名解析成真正的beanName
String nameToLookup = originalBeanName(name);
// 尝试在父容器中获取bean实例
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) {
// typeCheckOnly 为 false，将当前 beanName 放入一个 alreadyCreated 的 Set 集合中。
//这里面删除了对应的beanName 的 MergedBeanDefinition
markBeanAsCreated(beanName);
}
try {
// 根据beanName重新获取MergedBeanDefinition(前面删除了对应的MergedBeanDefinition,这边获取个新的)
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查MergedBeanDefinition
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 拿到当前bean的所有依赖bean,实例化自己之前需要先实例化自己的依赖(depends on 属性)
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 检查是否存在循环依赖,depends on不能循环依赖
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 将dep和beanName注册到缓存
registerDependentBean(dep, beanName);
try {
// 获取dep对应的bean实例,如果没有则创建
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
// 创建bean实例
if (mbd.isSingleton()) {
// scope为singleton的bean创建(新建ObjectFactory,重写getObject方法)
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
// 创建bean,最重要
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;
}
}
});
// 返回beanName对应的实例对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// scope为prototype的bean创建
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
// 创建实例前的操作（将beanName保存到prototypesCurrentlyInCreation缓存中）
beforePrototypeCreation(beanName);
// 创建实例
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//创建实例后的操作（将创建完的beanName从prototypesCurrentlyInCreation缓存中移除）
afterPrototypeCreation(beanName);
}
// 返回beanName对应的实例对象
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
// 其他scope的bean创建,可能是request之类的,方法同上
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.
//检查所需类型是否与实际的bean对象的类型匹配
if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
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());
}
}
// 返回bean实例
return (T) bean;
}
getSingleton方法
getSingleton方法重要,就是解决循环依赖,创建早期对象的地方:
循环依赖就是,A对象依赖B对象,B对象依赖A,这段代码就是通过爆光对应Bean实例的ObjectFactory,通过ObjectFactory创建一个早期的bean对象,此时对象还未进行属性赋值,因为后续处理都是通过缓存中获取的,并且不在通过ObjectFactory在进行创建,此时缓存中的对象地址值是不会改变的,这时候就能够解决循环依赖,具体的代码还是比较复杂的;
这里面使用的几个属性:这三个属性构成了三级缓存,用来解决循环依赖
- singletonFactories 缓存 new HashMap<String, ObjectFactory<?>>(16);
- earlySingletonObjects缓存 new HashMap<String, Object>(16);
- singletonObjects 缓存new ConcurrentHashMap<String, Object>(256);
@Override
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//从单例对象缓存中获取对应的beanName对象
Object singletonObject = this.singletonObjects.get(beanName);
//单例缓存中没有,该beanName对象正在创建中
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//加锁
synchronized (this.singletonObjects) {
//早期的单例对象缓存中获取单单例对象,(通过ObjectFactory创建出来的对象.未进行属性填充)
singletonObject = this.earlySingletonObjects.get(beanName);
//早期单例对象中没有,允许创建早期单例对象引用
if (singletonObject == null && allowEarlyReference) {
//从单例工厂对象中返回对应beanName的单例ObjectFactory
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//通过单例对象工厂返回对象,并放到早期暴露的单例对象map中,将单例工厂对象里面对应名称的单例工厂移除,
// 因为已经通过单例工厂返回创建了对象,单例的,就不需要对应的对象工厂
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
isDependent 检查是否依赖指定类
protected boolean isDependent(String beanName, String dependentBeanName) {
synchronized (this.dependentBeanMap) {
return isDependent(beanName, dependentBeanName, null);
}
}
private boolean isDependent(String beanName, String dependentBeanName, Set<String> alreadySeen) {
// 检查过的直接跳过
if (alreadySeen != null && alreadySeen.contains(beanName)) {
return false;
}
//将别名解析为真正的名称
String canonicalName = canonicalName(beanName);
// 拿到依赖集合
Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
if (dependentBeans == null) {
return false;
}
if (dependentBeans.contains(dependentBeanName)) {
return true;
}
// 循环检查,检查以来的canonicalName是否存在被dependentBeanName依赖的(隔层依赖)
for (String transitiveDependency : dependentBeans) {
if (alreadySeen == null) {
alreadySeen = new HashSet<String>();
}
//已经检查过的添加到alreadySeen，避免重复检查
alreadySeen.add(beanName);
if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
return true;
}
}
return false;
}
下篇文章讲:createBean方法;
