Spring Bean加载过程 FactoryBean对象加载

最新推荐文章于 2024-03-03 14:13:11 发布
最新推荐文章于 2024-03-03 14:13:11 发布
阅读量529 收藏 2
点赞数 1
分类专栏： Spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_36693244/article/details/124266590
版权

FactoryBean是一种特殊的Bean，作用就是创建我们需要的Bean对象，如果对象的创建过程比较复杂，或者要为接口创建动态代理对象等，都可以用FactoryBean来实现

FactoryBean是一种典型的工厂方法模式的运用，在整合框架上面用的比较多，比如整合Mybatis中的MapperFactoryBean

demo

@Component
public class FactoryBeanDemo implements FactoryBean {
    @Override
    public Object getObject() throws Exception {
        return new User();
    }

    @Override
    public Class<?> getObjectType() {
        return User.class;
    }
}

下面进入源码
ApplicationContext调用refresh方法，倒数第二步，加载bean对象

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

			// 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);

				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
				beanPostProcess.end();

				// 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();

				// 加载bean对象
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				// ...
			}

			finally {
				// ...
			}
		}
	}

最后执行到DefaultListableBeanFactory.preInstantiateSingletons方法

org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons

	public void preInstantiateSingletons() throws BeansException {
		// ...
		// 把解析到的beanNames一个一个的拿出来遍历
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                // 判断是不是工厂bean
				if (isFactoryBean(beanName)) {
                    // 获取工厂bean，& + beanName
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
                        // 只有实现了SmartFactoryBean 并且重写了isEagerInit方法，才会加载真正                                                    的bean，调用getObject方法
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				// 不是FactoryBean走这里
				else {
					getBean(beanName);
				}
			}
		}

		// ...
	}

判断是不是FactoryBean

public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
	String beanName = transformedBeanName(name);
	// 先去单例池中找，能找到就直接返回是不是实现了FactoryBean接口
    Object beanInstance = getSingleton(beanName, false);
	if (beanInstance != null) {
		return (beanInstance instanceof FactoryBean);
	}
	// No singleton instance found -> check bean definition.
	if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
		// No bean definition found in this factory -> delegate to parent.
		return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
	}
	// 单例池找不到，直接通过BeanDefinition判断是不是FactoryBean
	return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
	}

从前面DefaultListableBeanFactory.preInstantiateSingletons方法中可以看出，工厂bean调用getBean方法传的是 & + beanName ，在我这个demo里是：&factoryBeanDemo

再来看看getBean方法，最终会调到doGetBean方法

protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
		// 把&factoryBeanDemo 又转换成factoryBeanDemo，以factoryBeanDemo把对象加载到单例池中
		String beanName = transformedBeanName(name);
		Object beanInstance;

		// 从单例池拿对象，第一次肯定拿不到
		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 + "'");
				}
			}
			beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// ...
			try {
				// ...

				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							// 创建实例，和正常创建实例一样，beanName = factoryBeanDemo
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							
							destroySingleton(beanName);
							throw ex;
						}
					});
					// 获取真正的对象
					beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				// ...
			}
			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);
	}

返回真正对象的方法

// 本例中name 传入&factoryBeanDemo， beanName传入factoryBeanDemo
protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		// 这个判断就是判断name是不是&开头，这里为true，直接返回传入的FactoryBeanDemo对象
		// 所以ApplicationContext调用refresh方法时触发的对象加载，并不会调用FactoryBean的getObject方法
		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
			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.
		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());
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

可以看出，ApplicationContext调用refresh方法时触发的对象加载，传入& + beanName，然后进到方法后，又会截取掉&，执行的流程和普通getBean流程一样，最后把beanName对应的FacotyBean对象放入单例池中，本例中就是singletonObjects.put(“factoryBeanDemo” ：FactoryBeanDemo对象)

到此ApplicationContext.refresh创建工厂对象的过程就走完了

可以看到，到目前为止还没有调用FactoryBean.getObject方法，那我们怎么拿到getObject返回的对象呢？
答案是：再次调用getBean方法并且不加"&"前缀，如本例中调用getBean(“factoryBeanDemo”)

回到doGetBean方法

// name = factoryBeanDemo
protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {

	String beanName = transformedBeanName(name);
	Object beanInstance;

	// 这次从单例池能拿到对象，不过是FactoryBean对象
	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.getObject获取需要的对象
		beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}
	
	// ...
}


protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		// 不是以&开头，不会走这个if
		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
			}
			if (mbd != null) {
				mbd.isFactoryBean = true;
			}
			return beanInstance;
		}

		// 
		if (!(beanInstance instanceof FactoryBean)) {
			return beanInstance;
		}

		Object object = null;
		if (mbd != null) {
			mbd.isFactoryBean = true;
		}
		else {
			// 从factoryBeanObjectCache取对象，现在还取不到
			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());
			// 走这里获取FactoryBean.getObject的对象
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

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) {
				// 这个object已经是调用FactoryBean.getObject获得的对象
				object = doGetObjectFromFactoryBean(factory, beanName);
				// 判断缓存里是否有，感觉这个判断是不是放在doGetObjectFromFactoryBean方法前更好？
				Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
				if (alreadyThere != null) {
					object = alreadyThere;
				}
				else {
					if (shouldPostProcess) {
						if (isSingletonCurrentlyInCreation(beanName)) {
							// Temporarily return non-post-processed object, not storing it yet..
							return object;
						}
						beforeSingletonCreation(beanName);
						try {
							// 执行beanPostProcessor的后置处理方法
							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;
	}
}


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 {
			// 这里调用factory.getObject()获得真正需要的对象
			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;
}

总结一下流程：

第一次ApplicationContext.refresh创建FactoryBean对象

  1. 判断bean是不是FactoryBean
  2. 如果是FactoryBean，调用getBean("&" + beanName)加载单例bean
  3. doGetBean方法先把beanName截去"&"，然后执行正常加载bean的过程，最后把FactoryBean放入单例池，key是截去"&"的beanName
  4. 不会调用FactoryBean的getObject方法，而是直接返回FactoryBean对象

第二次getBean(beanName)

  1. 去单例池拿FactoryBean对象
  2. 拿到对象，先去factoryBeanObjectCache缓存里看是否有FactoryBean.getObject方法创建的对象
  3. 没有就调用FactoryBean.getObject方法创建一个对象
  4. 调用beanPostProcessor的后置处理方法，应该主要是为了看看需不需要生成动态代理对象
  5. 返回真正的对象

注意：可以看出通过FactoryBean.getObject获得的对象没有经历完整的Bean创建流程，只是会调用beanPostProcessor的后置处理方法，前置处理等方法都不会调用，这一点需要留意

火之华
关注
专栏目录
一文带你解读Spring5源码解析 IOC之开启Bean的加载，以及FactoryBean和BeanFactory的区别。
「 虚幻私塾」
02-23 243
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 前言 通过往期的文章我们已经了解了Spring对XML配置文件的解析，将分析的信息组装成BeanDefinition，并将其保存到相应的BeanDefinitionRegistry中，至此Spring IOC的初始化工作已经完成，这篇文章主要对Bean的加载进行一个深入的了解及
Spring Bean的加载过程以及一些生命周期
萌新Java工程师
03-27 937
Spring作为应用很广泛的开源框架，在面试中肯定少不了 Bean作为我们Spring的一大核心(容器)是非常重要的，下面是自己看周瑜老师学的还有其他一些视频的学习笔记 说一下Bean的加载过程，生命周期 （肯定少不了重要的IOC） class———>推断构造方法———–>实例化——>对象——> 属性填充(IOC)——>初始化——->AOP------>Bean(这里没总结完) bean的加载过程 我是这样理解的，从配置文件加载或者组件注解加载我们的Bean
spring学习_01-spring-factoryBean加载bean的流程
early_or_later的博客
06-13 427
1、代码实现，利用factoryBean，控制bean创建 实现思路：实现FactoryBean接口，复写getObject方法，利用工厂bean来实现具体的bean对象 源码分析： 1、 2、 3、 4、 5、 6、 7、
Spring源码阅读 -- ＞ FactoryBean与延迟加载
xinyu
03-02 595
Spring源码阅读 -- ＞ FactoryBean与延迟加载
Spring IOC 三个高级特性（延迟加载、FactoryBean、后置处理器）
章全蛋的博客
06-10 879
文章目录Spring IOC 高级特性lazy-Init 延迟加载BeanFactory 和 FactoryBean后置处理器BeanPostProcessorBeanFactoryPostProcessor Spring IOC 高级特性 lazy-Init 延迟加载 ApplicationContext 容器的默认行为是在启动服务器时将所有的 singleton bean 提前进行实例化。 提前实例化意味着作为初始化过程的一部分，ApplicationContext 实例会创建并配置所有的single
FactoryBean的getObject调用时机
qq_36364521的博客
07-24 1373
FactoryBean执行流程
Spring Bean的加载方式
qq_33753147的博客
10-30 1363
Spring Bean的加载方式
Spring的Bean加载流程
m0_67401270的博客
06-12 345
Spring IOC容器就像是一个生产产品的流水线上的机器，Spring创建出来的Bean就好像是流水线的终点生产出来的一个个精美绝伦的产品。既然是机器，总要先启动，Spring也不例外。因此Bean的加载流程总体上来说可以分为两个阶段：容器的启动阶段做了很多的预热工作，为后面Bean的实例化做好了充分的准备，我们首先看一下容器的启动阶段都做了哪些预热工作。1、配置元信息：Spring IOC容器将对象实例的创建与对象实例的使用分离，当业务中需要依赖某个对象，不再依靠我们自己手动创建，只需向Spring要，
9、Spring 源码学习 ~ Bean 的加载
戴泽王的博客
10-27 384
Spring 源码学习
spring如何通过FactoryBean配置Bean
08-25
Spring 通过 FactoryBean 配置 Bean 在 Spring 框架中，FactoryBean 是一种特殊的 Bean，它可以实现复杂的 Bean 实例化逻辑。通过 FactoryBean，我们可以将复杂的实例化逻辑封装起来，使得 Bean 的配置更加灵活和...
FactoryBean是现在的执行时机
许我笔墨三千绘你绝世倾城
04-04 474
FactoryBean、解析
bean的加载（二） FactoryBean的使用
u012291108的博客
07-05 1785
一般情况下，Spring通过反射机制利用bean的class属性指定实现类来实例化bean.某些情况下，实例化bean过程比较复杂，如果按照传统的方式，则需要在中提供大量的的配置信息，配置方式的灵活性是受限的，这是采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.Springframework.bean.factory.FactoryBean的工厂类接口，用户通过实现该接口
02、使用FactoryBean接口添加Bean
雄的博客
12-07 208
FactoryBean接口有三个方法可以重写： getObject()返回对象方法; getObjectType返回对象类型 isSingleton()是否单例控制 1. 新建Pig类 public class Pig { } 2. MyFactoryBean实现FactoryBean //创建一个Spring定义的工厂bean public class MyFactoryBea...
spring使用FactoryBean获取Bean的过程（懒加载）
qq_42165873的博客
06-17 755
spring中FactoryBean的使用以及源码debug
Spring源码阅读（一）浅谈beanFactory加载bean
wuxiaojun的专栏
09-07 649
题外话：学java 就要看源码，为什么要看源码？可以从中学到各位大佬的思想啊，看看大佬们是怎么写代码的。哈哈，这都是骗人家家的，谁TM想看源码啊，还不是被逼的！！！ 说重点，这篇文章分析下我们熟悉的优秀springFramework框架是怎么加载bean和管理bean的~ ...
工作笔记-Spring容器中bean 的加载顺序
qq_40091033的博客
06-08 289
Spring解析，加载及实例化Bean的顺序
自己设计一个的轻量级的RPC框架--客户端Spring 自定义标签和自定义注入bean
a294634473的博客
03-04 585
自己设计一个的轻量级的RPC框架--客户端Spring 自定义标签和自定义注入bean前言Spring 自定义标签spring-rpcClient.xsdspring.schemasspring.handlersRPCClientNameHandler自定义注入bean解释一下 前言 尝试后端调用服务要和普通controller一样，所以普通的注入service接口以及不适用于当前场景。因为调用接...
Spring：FactoryBean预加载逻辑以及自定义实现Mybatis的接口扫描
最新发布
a232884c的博客
03-03 1146
Spring：FactoryBean预加载逻辑以及自定义实现Mybatis的接口扫描 1 前言 参考Mybatis框架的@Mapper注解扫描Mapper接口的业务逻辑，其中集成Spring的逻辑里使用到了Spring框架的FactoryBean拓展点，本文针对Spring FactoryBean的加载流程进行分析和理解。 本文参考源码依赖： <parent> <artifactId>spring-boot-starter-parent</artifactId>
手写RPC-整合Spring、SpringBoot
itman_cx的博客
10-14 911
整合spring、springboot
使用FactoryBean实现延迟加载
03-31
FactoryBean是Spring框架中的一个接口，它提供了一种在容器中创建bean的方式。使用FactoryBean可以实现延迟加载，即在需要的时候才创建bean实例。下面是一个简单的示例： 1. 创建一个工厂类，实现FactoryBean接口： ``` public class MyBeanFactory implements FactoryBean<MyBean> { private boolean lazyInit = true; @Override public MyBean getObject() throws Exception { System.out.println("getObject() called"); return new MyBean(); } @Override public Class<?> getObjectType() { return MyBean.class; } @Override public boolean isSingleton() { return true; } public boolean isLazyInit() { return lazyInit; } public void setLazyInit(boolean lazyInit) { this.lazyInit = lazyInit; } } ``` 2. 配置bean： ``` <bean id="myBeanFactory" class="com.example.MyBeanFactory"> <property name="lazyInit" value="true"/> </bean> ``` 3. 在需要使用MyBean的地方，通过ApplicationContext获取实例： ``` ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); MyBean myBean = (MyBean) context.getBean("myBeanFactory"); ``` 在这个例子中，当ApplicationContext获取MyBean实例时，如果lazyInit属性为true，则不会立即创建MyBean实例，而是在第一次调用getObject()方法时才会创建。如果lazyInit属性为false，则在容器启动时就会创建MyBean实例。 使用FactoryBean可以实现延迟加载，避免在启动时就创建所有的bean，提高了应用程序的启动速度。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值