一文带你解读Spring5源码解析 IOC之开启Bean的加载,以及FactoryBean和BeanFactory的区别。
前言
通过往期的文章我们已经了解了Spring对XML配置文件的解析,将分析的信息组装成BeanDefinition,并将其保存到相应的BeanDefinitionRegistry中,至此Spring IOC的初始化工作已经完成,这篇文章主要对Bean的加载进行一个深入的了解及探索。
想要了解Bean就必要要知道接口BeanFactory
,接下来我们就从BeanFactory
切入
BeanFactory
我们在调用getBean()方法时,无论是显示调用还是隐式调用。都会触发Bean加载的阶段。demo如下:
@Test
public void Test(){
//使用BeanFactory方式加载XML.
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
MyTestBean myTestBean = (MyTestBean) beanFactory.getBean("myTestBean");
System.out.println(myTestBean.getName());
}
实际上这个getBean方法是在接口BeanFactory中定义的。我们先看一下BeanFactory的类图:
根据如上类图最一个简单的整理:
BeanFactory作为一个主接口不继承实现任何接口,我们可以定义为一级接口。
有3个子接口都继承了它,进行功能上的增强,这3个子接口我们可以定义为二级接口。
ConfiguratbleBeanFactory我们可以定义为三级接口,对二级接口HierarchicalBeanFactory,进行再次增强。它还继承了另外一个接口SingletomBeanRegistry
ConfigurableListableBeanFactory是一个更强大的接口,继承了上述的所有接口,无所不包,我们可以定义为四级接口,(这4级接口是BeanFactory的基本接口体系,继续,下面是继承关系的2个抽象类和2个实现类)
AbstractBeanFactory作为一个抽象类,实现了三级接口ConfigurableBe·anFactory
AbstractAutowireCapableBeanFactory同样是抽象类继承自AbstractBeanFactory,并额外实现了二级接口AutowireCapableBeanFactory
DefaultListableBeanFactory继承自AbstractAutowireCapableBeanFactory实现了强大的四级接口ConfigurableListableBeanFactory,并实现了一个外来接口BeanDefinitionRegistry,它并非抽象类。
最后就是强大的XmlBeanFactory继承自DefaultListableBeanFactory,重写了一些功能,是自己更强大。
BeanFactory,以Factory结尾,表示它是一个工厂类(接口),它负责生产和管理Bean的一个工厂。在Spring中,BeanFactory是IOC容器的核心接口,它的职责包括:实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。BeanFactory只是一个接口,并不是IOC的具体实现,但Spring容器给出了很多种实现,如:DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等,其中XmlBeanFactory就是常用的一个,该实现将以XML方式描述组件应用的对象及对象之间的依赖关系。XmlBeanFactory类将持有此Xml配置元数据,并用它来构建一个完全可配置的系统或应用。
BeanFactory是Spring IOC容器的鼻祖,是IOC容器的基础接口,所有的容器都是从它这里继承实现而来的。可以见其地位是多么重要。BeanFactory提供了最基本的IOC容器的功能,即所有的容器至少需要实现的标准。
XmlBeanFactory,只是提供了最基本的IOC容器的功能。而且XmlBeanFactory继承自DefaultListableBeanFactory。DefaultListableBeanFactory实际包含了基本IOC容器所具有的所有重要功能,是一个完整的IOC容器
ApplicationContext包含了BeanFactory的所有功能,通常建议比BeanFactory优先。
BeanFactory体系结构是典型的工厂方法模式,即什么样的工厂生产什么样的产品。BeanFactory是最基本的抽象工厂,而其它的IOC容器只不过是具体的工厂,对应着各自的Bean定义方法。但同时,其它容器也针对具体场景不同,进行了扩充,提供了具体的服务,如下:
// 1
Resource resource = new FileSystemResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
// 2
ClassPathResource resource = new ClassPathResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
// 3
ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml"});
BeanFactory factory = (BeanFactory) context;
大概就是这些了,接着使用getBean(String beanName)方法取得bean的实例;BeanFactory提供的方法极其简单,仅仅提供了六种方法供客户调用:
- boolean containsBean(String name);判断工厂中是否包含了给定名称的Bean定义,若有则返回true
- Object getBean(String name);返回给定名称注册的bean实例。根据Bean的配置情况,如果是singleton模式将返回一个共享的实例,否则将返回一个新建的实例,如果没有找到指定Bean,该方法会抛出异常(BeansException)。
- < T> T getBean(String name, Class requiredType) ;返回给定名称注册的Bean实例,并转换为给定class类型。
- boolean isSingleton(String name); 判断给定名称的Bean定义是否是单例模式。
- Class<?> getType(String name); 返回给定名称的Bean的Class,如果没有找到指定的Bean实例,则抛出NoSuchBeanDefinitionException异常。
- String[] getAliases(String name); 返回给定名称Bean的所有别名。
我们大致看一下BeanFactory源码里的所有方法。
public interface BeanFactory {
String FACTORY_BEAN_PREFIX = "&";
Object getBean(String name) throws BeansException;
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
Boolean containsBean(String name);
Boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
Boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
Boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
Boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
@Nullable
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
@Nullable
Class<?> getType(String name, Boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);
}
FactoryBean
概述:一一般情况下,Spring通过反射机制利用< bean>的class属性指定实现类实例化Bean,在某些情况下,实例化Bean的过程比较复杂,如果按照传统的方式,则需要在< bean>中提供大量的配置信息;配置方式的灵活性是受限的,这是采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.beans.factory.FactoryBean的工厂类接口,用户可以通过实现该接口定制实例化Bean的逻辑。FactoryBean接口对于Spring框架来说占有重要的地位,Spring自身就提供了70多个Factory Bean的实现,它们隐藏实例化一些复杂Bean的细节,给上层应用带来了便利,从Spring3.0开始,FactoryBean开始支持泛型,即接口声明改为FactoryBean< T>的形式。
以Bean结尾,表示它是一个Bean,不同于普通Bean的是:它实现了FactoryBean< T> 接口的Bean,根据该Bean的ID从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象,而不是FactoryBean本身,如果想要获取FactoryBean对象,请在id前面加一个&符号来获取。
- 看源码(
FactoryBean.java
)
public interface FactoryBean<T> {
String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
@Nullable
T getObject() throws Exception;
@Nullable
Class<?> getObjectType();
default Boolean isSingleton() {
return true;
}
}
从上述源码中我们可以看到,该接口一共定义了3个方法:
- T getObject() throws Exception; 返回由FactoryBean创建的Bean实例,如果isSingleton()返回true,则该实例会放到Spring容器中单例实例缓存池中;
- Class<?> getObjectType(); 返回FactoryBean创建的Bean实例;
- default boolean isSingleton() { return true;} 返回FactoryBean创建的Bean实例的作用域是singleton还是prototype;
补充:当配置文件中< bean>的class属性配置的实现类是FactoryBean时,通过getBean()方法返回的不是FactoryBean本身,而是FactoryBean中的getObject()方法所返回的对象,相当于FactoryBean的getObject()代理了getBean()方法。
例如:如果使用传统方式配置下面的Car的< bean>时,Car的每个属性分别对应一个< property>元素标签。
public class Car {
private int maxSpeed ;
private String brand ;
private double price ;
//get//set 方法
}
如果使用FactoryBean的方式实现的话就比较灵活,下例通过逗号的分割的方式一次性为Car的所有属性指定配置值。
import org.springframework.beans.factory.FactoryBean;
public class CarFactoryBean implements FactoryBean<Car> {
private String carInfo ;
public Car getObject() throws Exception {
Car car = new Car();
String[] infos = carInfo.split(",");
car.setBrand(infos[0]);
car.setMaxSpeed(Integer.valueOf(infos[1]));
car.setPrice(double.valueOf(infos[2]));
return car;
}
public Class<Car> getObjectType(){
return Car.class ;
}
public Boolean isSingleton(){
return false ;
}
public String getCarInfo(){
return this.carInfo;
}
//接受逗号分割符设置属性信息
public void setCarInfo (String carInfo){
this.carInfo = carInfo;
}
}
根据上述的CarFactoryBean,在配置文件中使用如下的方式进行配置
<bean d="car"class="com.vipbbo.spring.CarFactoryBean" P:carInfo="大奔,600,1000000"/>
当调用getBean("car")时,Spring通过反射机制发现CarFactoryBean实现了FactoryBean的接口,这时Spring容器就调用接口方法CarFactoryBean的getObject()方法返回。如果希望获取CarFactoryBean的实例,则需要在使用getBean(BeanName)方法时在BeanName前面加上"&"前缀:比如:getBean("&car");
获取Bean
接下来我们继续回到文章一开始讲的bean的加载阶段,当我们显式或隐式调用getBean()时,则会触发加载Bean的阶段,具体实现如下:
- 看源码(
AbstractBeanFactory.java
)
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
getBean()方法内部又调用了dogetBean()
方法:
- 看源码(
AbstractBeanFactory.java
)
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, Boolean typeCheckOnly)
throws BeansException {
// 获取 beanName,这里是一个转换动作,将 name 转换为 beanName
String beanName = transformedBeanName(name);
Object beanInstance;
/*
检查缓存中的实例工程是否存在对应的bean实例。
为何要优先使用这段代码呢?
因为在创建单例bean的时候会存在依赖注入的情况,而在创建依赖的时候为了避免循环依赖,Spring创建Bean的原则是在不等Bean创建完就会将
创建Bean的 objectFactory 提前曝光,即将其加入到缓存中,一旦下一个 Bean 创建时依赖上一个Bean则直接使用 objectFactory,直接
从缓存中或 singletonFactories 获取 objectFactory
就算没有循环依赖,只是单纯的依赖注入,如:B依赖A,如果A已经初始化完成,B进行初始化时,需要递归调用getBean()获取去A,这时A已经在
缓存里了,可以直接在这里获取到。
*/
// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
} else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 返回对应的实例,有些时候并不是直接返回实例,而是返回某些方法返回的实例
/*
这里涉及到我们上面讲的FactoryBean,如果此 Bean 是 FactoryBean 的实现类,如果name前缀为 "&",则直接返回此实现类的Bean,如果
没有前缀,则需要调用此实现类的getObject方法,返回getObject里真实的返回对象。
*/
beanInstance = 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.
// 尝试从 parentBeanFactory 中查找 bean
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
} else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
} else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
} else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
// 如果不是仅仅做类型检查,则这里需要创建bean,并做记录
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
.tag("beanName", name);
try {
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
// 将存储XML配置文件的GenericBeanDefinition转换成RootBeanDefinition,同时如果存在父Bean合并父Bean的相关属性
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 如果存在依赖,则需要递归实例化依赖的Bean
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(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
// 单例模式的Bean
if (mbd.isSingleton()) {
// 实例化依赖的Bean后对Bean本身进行实例化
sharedInstance = getSingleton(beanName, () -> {
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;
}
}
);
beanInstance = 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);
}
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 从指定的 scope 模式下创建 Bean else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
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, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
);
beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new ScopeNotActiveException(beanName, scopeName, ex);
}
}
}
catch (BeansException ex) {
beanCreation.tag("exception", ex.getClass().toString());
beanCreation.tag("message", String.valueOf(ex.getMessage()));
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
finally {
beanCreation.end();
}
}
return adaptBeanInstance(name, beanInstance, requiredType);
}
@SuppressWarnings("unchecked")
<T> T adaptBeanInstance(String name, Object bean, @Nullable Class<?> requiredType) {
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return (T) convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
dogetBean()方法的源码时相当的长,一共包含了两部分,也可以说是一部分,接下来:进行拆分讲解:
1. 获取BeanName
- 看源码(
AbstractBeanFactory.java
)
// 获取 beanName,这里是一个转换动作,将 name 转换为 beanName
String beanName = transformedBeanName(name);
protected String transformedBeanName(String name) {
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
- 源码分析
这里要注意传递的name,不一定就是beanName,也有可能是aliasName 别名,也有可能是FactoryBean(带有”&“前缀),因此这里需要调用transformeBeanName()
进行一下转换,主要内容如下:
- 看源码(
BeanFactoryUtils.java
)
public static String transformedBeanName(String name) {
// 这个方法主要是去掉FactoryBean的修饰符 &
Assert.notNull(name, "'name' must not be null");
if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
return name;
}
return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
do {
beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
}
while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
return beanName;
}
);
}
对aliasName别名的转换
public String canonicalName(String name) {
// 这个方法是转换aliasName
String canonicalName = name;
// Handle aliasing...
String resolvedName;
do {
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}
- 源码分析
上述的处理过程大致可以分为两步:
- 去除FactoryBean的修饰符,如果name以"&"为前缀,那么会去掉"&",例如:name="&testService",去除之后的结果是name=”testService“
- 取出指定的alias所表示的最终的beanName,主要是一个循环beanName的过程,例如别名A指向名称为B的bean则返回B,若别名A指向别名B,别名B指向名称为C的bean,则返回C。
缓存中获取单例Bean
单例在Spring的同一个容器中只会被创建一次,后续再获取Bean直接从单例缓存中获取即可,当然这里也只是尝试加载,首先尝试先从缓存中加载,然后再次从singletonFactory加载;因为在创建单例bean的时候会存在依赖注入的情况,而在创建依赖的时候为了避免循环依赖,Spring创建bean的原则是不等bean创建完成就会创建bean的ObjectFactory提早曝光加入到缓存中,一旦下一个bean创建时需要依赖上个bean,则直接使用ObejectFactory;就算没有循环依赖,只是单纯的依赖注入,如:B依赖A,如果A已经初始化完成,B进行初始化时,需要递归调用getBean()获取A,这时A已经在缓存里面了,直接可以从缓存里面获取到,接下来我们看获取单例bean的方法:
Object sharedInstance = getSingleton(beanName);
- 看源码(
DefaultSingletonBeanRegistry.java
)
@Override
@Nullable
public Object getSingleton(String beanName) {
// 参数true,代表允许早期依赖
return getSingleton(beanName, true);
}
@Nullable
protected Object getSingleton(String beanName, Boolean allowEarlyReference) {
// Quick check for existing instance without full singleton lock
// 检查缓存中是否存在实例,这里就是说上面的单纯的依赖注入,假设B依赖A,如果A已经初始化完成,B进行初始化时,需要递归调用getBean获取A,这时
// A已经在缓存里面了,直接可以从缓存中获取到。
Object singletonObject = this.singletonObjects.get(beanName);
// 如果缓存为空,且单例Bean正在创建中,则锁定全局变量,
// 为什么要判断单例Bean是否在创建中呢?
// 这里就是可以判断是否是循环依赖了。
// A依赖B,B也依赖A,A实例化的时候发现依赖B,则递归去实例化B;B又发现依赖A,则递归实例化A。这个时候就会回到原点A的实例化,第一次A的
// 实例化还没有完成,只不过是把实例化的对象加入到缓存中了,但是状态还是正在创建中。由此回到原点A发现A正在创建中,便可以根据此来判断这
// 是循环依赖了
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 尝试从 earlySingletonObjects 里面获取 如果此Bean正在加载,则不对其进行处理
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
synchronized (this.singletonObjects) {
// Consistent creation of early reference within full singleton lock
// 尝试从singletonObjects里面获取实例
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 当某些方法需要提前初始化的时候会直接调用 addSingletonFactory 把对应的 ObjectFactory 初始化策略 存储在
// singletonFactories中。
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 使用预先设定的getObject方法
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
- 源码分析
我们对上述方法进行一个简单的梳理,
首先该方法先从singletonObjects里获取实例;
如果获取不到会从earlySingletonObjects里面获取实例;
如果还是获取不到,再次尝试从singletonFactories里面获取beanName对应的ObjectFactory,并从singletonFactories里面remove掉这个ObjectFactory,而对于后续所有的内存操作都只为了循环依赖检测时候使用,即allowEarlyReference为true时才会使用。
以上代码涉及到了很多个存储bean的不同Map:
singletonObjects:用于保存BeanName和创建Bean实例之间的关系,beanName->bean Instance
singletonFactories:用于保存BeanName和创建Bean的工厂之间的联系,beanName->ObjectFactory
earlySingletonObjects:同样也是用于保存BeanName和创建Bean实例之间的关系,与singletonObjects的不同之处在于:当一个单例bean被放到这里面后,那么当bean还在创建过程中,就可以通过getBean方法获取到了,其目的是用来检测循环依赖的引用。
registeredSingletons:用来保存当前所有已经注册的bean。
从bean的实例中获取对象
获取到bean以后就要获取实例对象了,这里用到的时getObjectForBeanInstance方法。getObjectForBeanInstance是一个频繁使用的方法,无论是从缓存中获取bean还是根据不同的scope策略加载Bean;总之,我们得到bean的实例后,要做的第一步就是调用这个方法来检测一下正确性,其实就是检测获得的Bean是不是FactoryBean类型的bean,
如果是那么需要调用该bean对应的FactoryBean实例中的getObject()作为返回值。
- 看源码(
AbstractBeanFactory.java
)
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
// 如果指定的name 是工厂相关的
if (BeanFactoryUtils.isFactoryDereference(name)) {
// 如果是 NullBean 则直接返回此Bean
if (beanInstance instanceof NullBean) {
return beanInstance;
}
// 如果不是FactoryBean 类型,则直接抛出异常
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
// 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.
// 如果获取的beanInstance不是FactoryBean类型,说明是普通的Bean,可直接返回
// 如果获取的beanInstance是FactoryBean 类型,但是是以&开头,也可直接返回,此时返回的是FactoryBean实例
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
} else {
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());
// 到这里说明了获取的beanInstance是FactoryBean类型的,但是没有以&开头,此时就要返回factory内部的getObject里面的对象了。
// getObjectFromFactoryBean 核心方法
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
接下来我们继续看一下里面的核心方法getObjectFromFactoryBean()
- 看源码(
FactoryBeanRegistrySupport.java
)
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, Boolean shouldPostProcess) {
// 满足是单例并且缓存中存在的
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
// 从缓存中获取FactoryBean根据BeanName
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
// 为空,则从FactoryBean中获取对象
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 (shouldPostProcess) {
// 若该 bean 处于创建中,则返回非处理对象,而不是存储它
if (isSingletonCurrentlyInCreation(beanName)) {
// Temporarily return non-post-processed object, not storing it yet..
return object;
}
// 前置处理
beforeSingletonCreation(beanName);
try {
// 对从 FactoryBean 获取的对象进行后处理
// 生成的对象将暴露给bean引用
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
finally {
// 后置处理
afterSingletonCreation(beanName);
}
}
// 缓存
if (containsSingleton(beanName)) {
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
}
// 非单例 else {
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
- 源码分析
getObjectFromFactoryBean()该方法就是创建实例对象中的核心方法之一。我们关注它之中的单个方法即可:beforeSingletonCreation
,afterSingletonCreation
,postProcessObjectFromFactoryBean
,这三个方法十分重要,万分重要!!!!!!!!因为前两个方法记录着bean的加载状态,是检测当前bean是否处于创建中的关键之处,对解决bean循环依赖起着关键的作用。
before方法用于标记当前bean处于创建中,
after则是移除。
其实文章一开始的getSingleton源码分析就已经提到了isSingletonCurrentlyInCreation()
是用于检测当前bean是否处于创建之中,
- 看源码(
DefaultSingletonBeanRegistry.java
)
public Boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
beforeSingletonCreation()
上述代码是根据变量singletonsCurrentlyInCreation集合中是否包含了beanName判断,集合的元素则一定是在beforeSingletonCreation()
中添加的,如下:
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
afterSingletonCreation
afterSingletonCreation()
为移除,则一定就是对singletonsCurrentlyInCreation集合remove了,如下:
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
接下来我们再来看看真正的核心方法 doGetObjectFromFactoryBean
- 看源码(
FactoryBeanRegistrySupport.java
)
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
Object object;
try {
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) 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) {
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
- 源码分析
在文章开始我们有介绍FactoryBean的调用方法,如果bean声明为FactoryBean类型,则当提取bean的是否提取的不是FactoryBean,而是FactoryBean中对应的getObject方法返回的bean,而doGetObjectRFromFactoryBean正是实现这一功能的。
调用完doGetObjectFromFactoryBean方法后,并没有直接返回,getObjectFromFactoryBean方法中还调用了object = postProcessObjectFromFactoryBean(object, beanName);
方法,在子类AbstractAutowireCapableBeanFactory
有该方法的具体实现:
- 看源码(
AbstractAutowireCapableBeanFactory.java
)
@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
对于后处理器的使用,目前还没有讲到,后面再重新开篇去说,这里我们只需要了解在Spring获取Bean的规则中有这样一条,尽可能保证所有bean初始化后都会调用注册的BeanPostProcessor的postProcessAfterInitialization
方法进行处理,在实际开发中大可针对此特性设计自己的业务处理。
整理不易,如果对你有所帮助欢迎点赞关注
微信搜索【码上遇见你】获取更多精彩内容
一文带你解读Spring5源码解析 IOC之开启Bean的加载,以及FactoryBean和BeanFactory的区别。的更多相关文章
- spring源码深度解析— IOC 之 开启 bean 的加载
概述 前面我们已经分析了spring对于xml配置文件的解析,将分析的信息组装成 BeanDefinition,并将其保存注册到相应的 BeanDefinitionRegistry 中.至此,Spri ...
- springboot源码解析-管中窥豹系列之BeanDefine如何加载(十三)
一.前言 Springboot源码解析是一件大工程,逐行逐句的去研究代码,会很枯燥,也不容易坚持下去. 我们不追求大而全,而是试着每次去研究一个小知识点,最终聚沙成塔,这就是我们的springboot ...
- Spring 源码学习(4)—— bean的加载part 1
前面随笔中,结束了对配置文件的解析工作,以及将配置文件转换成对应的BeanDefinition存储在容器中.接下来就该进行bean的加载了. public Object getBean(String ...
- android源码解析(十七)-->Activity布局加载流程
版权声明:本文为博主原创文章,未经博主允许不得转载. 好吧,终于要开始讲讲Activity的布局加载流程了,大家都知道在Android体系中Activity扮演了一个界面展示的角色,这也是它与andr ...
- Spring源码分析(十一)bean的加载
摘要:本文结合<Spring源码深度解析>来分析Spring 5.0.6版本的源代码.若有描述错误之处,欢迎指正. 经过前面的分析,我们终于结束了对XML配置文件的解析,接下来将会面临更大 ...
- Spring源码学习(5)—— bean的加载 part 2
之前归纳了从spring容器的缓存中直接获取bean的情况,接下来就需要从头开始bean的加载过程了.这里着重看单例的bean的加载 if(ex1.isSingleton()) { sharedIns ...
- Spring源码之IOC容器创建、BeanDefinition加载和注册和IOC容器依赖注入
总结 在SpringApplication#createApplicationContext()执行时创建IOC容器,默认DefaultListableBeanFactory 在AbstractApp ...
- springboot源码解析-管中窥豹系列之bean如何生成?(十四)
一.前言 Springboot源码解析是一件大工程,逐行逐句的去研究代码,会很枯燥,也不容易坚持下去. 我们不追求大而全,而是试着每次去研究一个小知识点,最终聚沙成塔,这就是我们的springboot ...
- Spring5源码解析-Spring框架中的单例和原型bean
Spring5源码解析-Spring框架中的单例和原型bean 最近一直有问我单例和原型bean的一些原理性问题,这里就开一篇来说说的 通过Spring中的依赖注入极大方便了我们的开发.在xml通过& ...
随机推荐
- SYCOJ223图书管理员
题目-图书管理员 (shiyancang.cn) 图书馆中每本书都有一个图书编码,可以用于快速检索图书,这个图书编码是一个正整数. 每位借书的读者手中有一个需求码,这个需求码也是一个正整数. 如果一本 ...
- [未完] Linux 4.4 USB —— spiflash模拟usb大容量存储设备 调试记录 Gadget Mass Stroage
linux 4.4 USB Gadget Mass Stroage 硬件平台: licheepi nano衍生 调试记录 驱动信息 │ This driver is a replacement for ...
- 纯手画WinForm的Alert提示弹出框
纯手画WinForm的Alert弹框 一.窗体设置 设置以下属性: 属性名 属性值 说明 AutoScaleMode None 确定屏幕分辨率或字体更改时窗体如何缩放 BackColor 103, 1 ...
- ecos matlab版本安装
官网链接 github地址 1.注意不仅要下载matlab版本,同时还要下载c版本,因为matlab版本缺少第三方软件,将两个版本解压缩后将c版本下的文件夹external,ecos_bb,inclu ...
- 【刷题-LeetCode】209. Minimum Size Subarray Sum
Minimum Size Subarray Sum Given an array of n positive integers and a positive integer s, find the m ...
- Cesium应用篇--添加雨雪天气
作为一个三维地球,在场景中来点雨雪效果,貌似可以增加一点真实感.Cesium官网Demo中有天气系统的实例,用的是Cesium中的粒子系统做的.效果如下图所示,粒子系统的本质是向场景中添加了很多物体, ...
- 话说C#程序员人手一个ORM
话说C#程序员人手一个ORM,确实没有必要再写ORM了,不过我的ORM并不是新的,是从DBHelper演化过来的,算是DBHelper魔改版. 目前流行的ORM有EF.Dapper.SqlSugar. ...
- java继承成员变量特点
1 /* 2 * 在子父类中,成员的特点体现. 3 * 1,成员变量. 4 * 2,成员函数. 5 * 3,构造函数. 6 */ 7 8 //1, 成员变量. 9 /* 10 * 当本类的成员和局部变 ...
- 【程序15】成绩>=90分用A表示,60-89分用B表示, 60分以下用C表示。
利用条件运算符的嵌套来完成此题 score = int(input('input score:')) if score >= 90: grade = 'A' elif score >= 6 ...
- K8S的安装部署以及基础知识
Kubernetes(K8S)概述 Kubernetes又称作k8s,是Google在2014年发布的一个开源项目. 最初Google开发了一个叫Borg的系统(现在命名为Omega),来调度近20多 ...