相关文章
接上篇,直接上代码,上篇链接为spring-ioc(五)-bean的注册终篇
本文开始讲spring bean的实例化
说明
1. 本文只是讲下大概流程
2. 后续会有三篇分别讲解 bean的实例化(构造方法,@bean),依赖注入(大致了解下),aop(可能不是很详细)
直接上源码
//还是熟悉的代码 ,建议先看前面几篇文章
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
//这里实例化的入口
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
.........................................................
}
}
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
............................................................................
// Instantiate all remaining (non-lazy-init) singletons.
//这里
beanFactory.preInstantiateSingletons();
}
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("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.
//获取所有的 beanNames 前面讲过,没注册一个BeanDefinition 都会 在beanDefinitionNames中添加一个beanName
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
//循环创建
for (String beanName : beanNames) {
//获取一个beanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//这个bean必须不是抽象的 && 必须是单例的或者默认的 && 不是懒加载的
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//是不是 factortBean , 我们使用的正常都不是,但是你的 dao 层接口全部都是,因为mybtais用的factortBean
//等spring-ioc讲完之后,有时间会单独说先 factoryBean和beanFactory的区别
if (isFactoryBean(beanName)) {
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 {
//主要目标 getBean
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
//实现了SmartInitializingSingleton bean 的初始化回调
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();
}
}
}
}
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//获取beanName
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
//这个方法很重要,但是内容不多,解决了spring循环依赖的问题
//我们先去看看这个方法,看完了在接着看下面的代码所以下面代码先删除
Object sharedInstance = getSingleton(beanName);
........................................................................
}
@Override
@Nullable
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//去 singletonObjects中查找bean 找得到话直接返回
// singletonObjects很重要,是spring-ioc 中管理的bean' 的容器
Object singletonObject = this.singletonObjects.get(beanName);
//下面if 两个条件,第一个就是singletonObjects查找的bean为空,我们看下第二个条件
//所以说这个方法正常情况下话返回的是null
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
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;
}
//第二个条件
public boolean isSingletonCurrentlyInCreation(String beanName) {
//查看singletonsCurrentlyInCreation中是否包含这个beanName,假如包含返回true
//singletonsCurrentlyInCreation就是spring解决循环依赖的重点 很重要,记住这个容器
return this.singletonsCurrentlyInCreation.contains(beanName);
}
接着看主线
//这个方法是真的长 所以删除掉一些不是那么重要的代码
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
//尝试去获取bean
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
................................
} else {
...................................................
//这个方法就是标记下这个bean 是否创建过,假如创建过放在 alreadyCreated 容器中,同时把 合并的 beanDefinition 删除掉
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
//获取beanDefinition 这个使用final 修饰的 , 不可变的
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查这个bean是不是抽象的 假如是抽象的会报错 XXX Bean definition is abstract
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
//查看当前的bean是不是需要依赖别的类 @dependsOn 注解
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);
try {
//getbean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
//创建bean实例 ,对着上面的英文注释 直译的
//这个地方用了个 lambda 表达式,这个 getSingleton 不是上面的那个方法,但是他们功能上是有关联的,为了处理循环依赖
//我们先看下getSingleton 然后继续看 createBean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
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;
}
});
//这里就是处理 实现了 factoryBean 接口的bean , 最后调用的方式是 getObject
//也就是我们说的工厂方法
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
..........................省略的代码不看了,上边的createBean方法讲完spring-ioc就结束了.........................................................
return (T) bean;
}
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
//先去 singletonObjects 根据beanName 获取bean,能获取到直接返回
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
..................................................................................
//在singletonsCurrentlyInCreation容器中添加beanName 这个很重要,就是这里和前一个getSingleton 配合解决了循环依赖
/**
*假如实例化A 那么当程序走到 第一个 getSingleton 方法是查询不到结果的,
*然后到这个方法,把当前的bean标记为正在创建,然后等这个bean实例化完成的时候,会依赖注入
*这个时候发现依赖了B ,那么就会去实例化B,然后B的实例化过程,走到第一个getSingleton方法也是获取不到,
*然后走到这里,B标记为正在创建,然后重要的是,当B注入属性的时候,发现依赖了A 那么又回去实例化A
*然后实例化A的过程中走到了第一个getSingleton发现A正在创建,然后就从singletonsCurrentlyInCreation容器
*中拿到A,然后创建完成,,,,你想下,假如没有标记为正在创建中会出现什么现象,直接就死循环了.
*/
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
...................................................................
if (newSingleton) {
//把创建的bean添加到容器
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
//把创建的bean添加到容器
protected void addSingleton(String beanName, Object singletonObject) {
//记住下面的几个容器 尤其是singletonObjects
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
..................................................................................................
try {
//这里
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
//假如是单例的 , 先去删除一波
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//创建bean实例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
.............................先删除,先看下createBeanInstance.................................................................
return exposedObject;
}
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
//根据beanDefinition 获取class 对象
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());
}
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
//说实话我不知道这个是处理什么的
return obtainFromSupplier(instanceSupplier, beanName);
}
if (mbd.getFactoryMethodName() != null) {
//这个就是处理我们 @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);
}
}
// Candidate constructors for autowiring?
//这个是获取构造方法,基本上都是使用无参构造器,这里面的代码很复杂,我们只要知道是获取了可用的无参构造器就行了
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//有参数的构造器
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
//无参构造器 通过反射 使用构造器实例化对象
return instantiateBean(beanName, mbd);
}
//接着看主线代码
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//创建实例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
//做一些合并的后置处理
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
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.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//将你常见的实例放入 singletonFactories
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//现在的两行两行代码都很重要
//填充属性,依赖注入
populateBean(beanName, mbd, instanceWrapper);
//aop代理 , 初始化之后执行的方法
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
....................................下面的代码不看了,结束了.................................................................
return exposedObject;
}
