目录
Spring 创建普通 bean 除了直接创建方式，还有：
factory_method, factorybean , 这里还会提一下prototype Bean的创建和destroy-method。
factory_method
文件配置
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
">
<bean class="com.jack.ascp.purchase.app.test.spring.getbean.Mobile" factory-method="getInstance"/>
</beans>被创建的bean需要提供一个静态方法作为factory_method
public class Mobile {
private BigDecimal amount;
public Mobile(BigDecimal amount) {
this.amount = amount;
}
public static Mobile getInstance() {
return new Mobile(new BigDecimal("111"));
}
public void show() {
System.out.println("Mobile :" + amount);
}
}
factorybean
实际的bean在refresh阶段是不会创建的，refresh阶段创建的是factorybean，并且容器中注册的是factorybean，当第一次获取bean的时候，才会使用factorybean.getObect创建，并用beanName进行注册当前bean，然后原来的factorybean用 &beaName注册。 划掉是我之前错误理解了，不是这样的。
配置：
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
">
<bean class="com.jack.ascp.purchase.app.test.spring.getbean.factorybean.MobileFactory" id="mobile"/>
</beans>MobileFactory：
public class MobileFactory implements FactoryBean<Mobile> {
Mobile mobile;
@Override
public Mobile getObject() throws Exception {
if (mobile == null) {
mobile = new Mobile(new BigDecimal(1000));
}
return mobile;
}
@Override
public Class<?> getObjectType() {
return BigDecimal.class;
}
@Override
public boolean isSingleton() {
return true;
}
}Test：Mobile mobile1 = context.getBean(Mobile.class); 这行代码会抛异常。
public class FactoryBeanTest {
public static void main(String[] args) throws Exception {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("factory_bean_test.xml");
MobileFactory mobileFactory = (MobileFactory)context.getBean("&mobile");
Mobile mobile = (Mobile)context.getBean("mobile");
// 这样会抛异常
// Mobile mobile1 = context.getBean(Mobile.class);
System.out.println(mobileFactory.getObject() == mobile);
mobile.show();
}
}
源码导读
在DefaultListableBeanFactory#preInstantiateSingletons中会判断当前bean是不是factorybean，如果是factorybean则进入factorybean的链路。
public void preInstantiateSingletons() throws BeansException {
if (logger.isDebugEnabled()) {
logger.debug("Pre-instantiating singletons in " + this);
}
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 遍历所有注册过的beanNames, Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
// 当这个bean存在parent的时候，会对原来的GenericBeanDefinition进行一次融合，融合之后就是RootBeanDefinition了
// 其实在前面invokeBeanFactoryPostProcessors时已经merge过了
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 不是抽象的，是gingleton，并且不是懒加载则创建bean
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 如果是一个FactoryBean，则进入这个链路
if (isFactoryBean(beanName)) {
// 在beanName前加前缀&，然后getBean, 这里虽然加了前缀，但是进入getBean之后有被去掉了
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
// 确定FactoryBean 中的bean是否需要被EagerInit
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
// 判断factory是不是实现了SmartFactoryBean, 并且其中的isEagerInit == true
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
// 如果FactoryBean 中的bean是EagerInit, 才会热加载这个bean
if (isEagerInit) {
// 加载并且将bean加入缓存
getBean(beanName);
}
}
}
else {
// 这里开始以getBean来发起Bean的创建
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
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();
}
}
}
}虽然在getBean之前加了 & 符号 但是在doGetBean 的第一行代码 ： final String beanName = transformedBeanName(name);中去掉了。
所以在refresh阶段后面的链路与普通的bean的getBean是一样的，但是这个阶段创建的是factoryBean, 将其注册:this.singletonObjects.put(beanName, singletonObject); 这里的singletonObject 其实是factoryBean。所以目前为止，它没有什么特别之处。
所以如果factoryBean没有实现SmartFactoryBean, 并且其中的isEagerInit == true。那么第一次是不会创建bean的。当用户再次getBean的时候才会创建：
容器的getBean入口: AbstractApplicationContext#getBean(java.lang.String)
public Object getBean(String name) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name);
}
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}现在仍然进入AbstractBeanFactory#doGetBean但是这次从Object sharedInstance = getSingleton(beanName);就可以获取到我们的factoryBean
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 转化一下传入的beanName.如果是别名转真名，如果是&开头，去掉&。&代表取factoryBean
final String beanName = transformedBeanName(name);
Object bean;
// 1、这里为了解决Singleton循环依赖，如果允许早期暴露，会在这里取到其早期暴露，后面会介绍
// 2、如果是工厂模式，在获取bean的时候，在这里会先获取到factoryBean
Object sharedInstance = getSingleton(beanName);
// 如果 sharedInstance 不为空，说明当前singleton是依赖者在注入属性时创建的。则打印相关日志
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 + "'");
}
}
// 这里会将name和beanName同时传进来, 因为一开始我们的name可能是带&符号的，代表这里需要获取factoryBean而不是bean
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);
}
// 判断是否有父容器，如果有父容器，优先用父容器调用其getBean
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 {
// 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 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.
// 这段代码需要记住，这里开始创建Singleton
if (mbd.isSingleton()) {
// 这里用了一个实现ObjectFactory接口 的 lambda表达式。getSingleton会有对这个createBean，有个前置操作和后置操作，中间调用lambda进行创建
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;
}
});
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 name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
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 && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
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;
}
这次sharedInstance能拿到factoryBean，因此进入AbstractBeanFactory#getObjectForBeanInstance
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 判断是不是在创建中, 我们的factoryBean不是创建中
String currentlyCreatedBean = this.currentlyCreatedBean.get();
if (currentlyCreatedBean != null) {
registerDependentBean(beanName, currentlyCreatedBean);
}
// 因此会调用父类(AbstractBeanFactory)的getObjectForBeanInstance
return super.getObjectForBeanInstance(beanInstance, name, beanName, mbd);
}org.springframework.beans.factory.support.AbstractBeanFactory#getObjectForBeanInstance
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 判断是不是BeanFactory的引用，这里是判断name是不是&开头的。如果&开头代表我想获取factoryBean,而不带的话，我是想获取bean
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
// 如果想获取factoryBean，如果带&我们想获取factoryBean, 要求进来的beanInstance是FactoryBean, 否则会抛出异常
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
}
// beanInstance肯定不为null beanInstance 要么是常规bean (我们知道循环依赖时也会进入该方法, 这时beanInstance不为空, 是常规bean,直接返回) 要么是FactoryBean
// 如果beanInstance不是那就直接返回，或者name是&开头的, &代表想获取FactoryBean，FactoryBean肯定不是空，这里就直接返回
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
if (mbd == null) {
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// 我想获取bean, 所以这里先将beanInstance进行强制类型转换为FactoryBean
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创建bean了
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}FactoryBeanRegistrySupport#getObjectFromFactoryBean：
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
// 如果是singleton
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
// 先从缓存获取
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
// 调用doGetObjectFromFactoryBean
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) {
if (isSingletonCurrentlyInCreation(beanName)) {
// Temporarily return non-post-processed object, not storing it yet..
return object;
}
// 标注bean在创建中
beforeSingletonCreation(beanName);
try {
// 调用beamPostProcessor的postProcessAfterInitialization
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 {
// 如果不是singleton 是不会将其放到缓存的，也不会有before和after
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;
}
}doGetObjectFromFactoryBean：从代码中，我们看到，基于工厂模式的bean是不允许出现循环依赖的。否则会抛BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject") 异常
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final 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 {
// 这里调用了factoryBean的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) {
// 判断 这个bean是否在创建中, factoryBean方式获取的bean是不允许循环依赖的。
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
prototypeBean
prototypeBean不会在refresh阶段进行创建，我们每取一次都会创建一个，并且不会参与注册，不支持循环依赖。
源码比较简单：
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.
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 {
// Prototype不允许单个线程有两个同时创建中：private final ThreadLocal<Object> prototypesCurrentlyInCreation
// 从而Prototype不支持循环依赖
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 (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 {
// 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 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.
if (mbd.isSingleton()) {
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;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 这里处理Prototype
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
// 标注为当前线程创建中
beforePrototypeCreation(beanName);
// 创建，这里和singleton用的同一个方法。
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 name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
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 && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
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;
}
destroy-method
有时候我们的程序退出时是需要关闭某些bean所占用的资源的比如数据库连接的，如果想优雅的关闭bean，可以指定destroy-method=“xxxxx‘，进行关闭，其中可能需要用到JVM提供的钩子(Runtime.getRuntime().addShutdownHook)进行关闭，这里提一下。
AbstractApplicationContext 的 两个相关方法registerShutdownHook(JVM异常关闭会使用到), close(手动调用，需要将钩子移除)
public void registerShutdownHook() {
if (this.shutdownHook == null) {
// No shutdown hook registered yet.
this.shutdownHook = new Thread() {
@Override
public void run() {
synchronized (startupShutdownMonitor) {
doClose();
}
}
};
Runtime.getRuntime().addShutdownHook(this.shutdownHook);
}
}
public void close() {
synchronized (this.startupShutdownMonitor) {
doClose();
// If we registered a JVM shutdown hook, we don't need it anymore now:
// We've already explicitly closed the context.
if (this.shutdownHook != null) {
try {
Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
}
catch (IllegalStateException ex) {
// ignore - VM is already shutting down
}
}
}
}
428
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
