上一篇讲到了BeanFactory，那就不得不提一下FactoryBean，先看一下它的定义吧！

定义

public interface FactoryBean<T> {

	String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
    //返回的对象实例
	@Nullable
	T getObject() throws Exception;

     //返回对象类型
	@Nullable
	Class<?> getObjectType();

   //getObject返回的对象是否单例。true代表单例，false代表非单例
	default boolean isSingleton() {
		return true;
	}
}
复制代码

看到里面的三个方法名，我们可以见名知意了。Bean实例、Bean类型、bean是否单例。那接下来我们就实现FactoryBean 接口，看看是怎么使用 FactoryBean 的，然后再从源码的角度去看看 Spring 是怎么解析FactoryBean 中的 Bean 的。

实践

GongjFactoryBean

GongjFactoryBean 实现 FactoryBean ，并重写其三个方法。

@Component
public class GongjFactoryBean implements FactoryBean {

	/**
	 * 当该Bean是单例时，该方法只执行一次
	 * @return
	 * @throws Exception
	 */
	@Override
	public Object getObject() throws Exception {
		User user = new User();
		System.out.println("====" + user);
		return user;
	}

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

	/**
	 * 可以控制该Bean的作用域是单例还是原型
	 * @return
	 */
	@Override
	public boolean isSingleton() {
		return true;
	}
}
复制代码

AppConfig

新建AppConfig作为启动扫描类

@ComponentScan("com.gongj")
public class AppConfig {
}
复制代码

Main

使用 AnnotationConfigApplicationContext 容器启动 Spring

public class Main {
	public static void main(String[] args) {
		//启动spring容器  ----> 创建非懒加载的单例Bean
		//扫描包路径
		AnnotationConfigApplicationContext annotationConfigApplicationContext =
				new AnnotationConfigApplicationContext(AppConfig.class);
  
System.out.println(annotationConfigApplicationContext.getBean("gongjFactoryBean")); 	System.out.println(annotationConfigApplicationContext.getBean("gongjFactoryBean"));
System.out.println(annotationConfigApplicationContext.getBean("&gongjFactoryBean"));
System.out.println(annotationConfigApplicationContext.getBean("&gongjFactoryBean"));
	}
}
复制代码

启动main方法输出以下结果：

====com.gongj.entity.User@cac736f  #这是我在GongjFactoryBean中进行打印的
com.gongj.entity.User@cac736f
com.gongj.entity.User@cac736f
com.gongj.service.GongjFactoryBean@5e265ba4
com.gongj.service.GongjFactoryBean@5e265ba4
复制代码

通过上面启动的这个例子我们可以得出以下几个结论：

GongjFactoryBean#getObject()函数只执行一次
根据 gongjFactoryBean 获取的是 User 对象并每次获取的 User 对象一致。
根据 &gongjFactoryBean 获取的是 GongjFactoryBean 对象并每次获取的 GongjFactoryBean 对象一致。

初步怀疑该现象是 isSingleton 函数进行控制的。那我接下来将isSingleton函数返回的值修改为false。

@Override
	public boolean isSingleton() {
		return false;
	}
复制代码

再次执行main方法，输出以下结果：

====com.gongj.entity.User@cac736f  #这是我在GongjFactoryBean中进行打印的
com.gongj.entity.User@cac736f
====com.gongj.entity.User@5e265ba4  #这是我在GongjFactoryBean中进行打印的
com.gongj.entity.User@5e265ba4
com.gongj.service.GongjFactoryBean@156643d4
com.gongj.service.GongjFactoryBean@156643d4
复制代码

通过上面启动的这个例子我们又可以得出以下几个结论：

isSingleton() 函数控制的是以 gongjFactoryBean 获取的对象是否是单例的。
isSingleton() 函数的修改不影响以 &gongjFactoryBean 获取的对象，它还是单例的。

看到这我们应该就有疑惑了，让我们带着疑惑开始一步一步DEGUG源码。

将 isSingleton() 函数的返回值修改为true。

根据上图我们可以得出结论：

GongjFactoryBean 在启动的时候就已经加入到 Spring 容器中。很显然 GongjFactoryBean 是一个非懒加载的单例 Bean。

调试

进入AbstractApplicationContext#getBean

@Override
	public Object getBean(String name) throws BeansException {
		assertBeanFactoryActive();
		return getBeanFactory().getBean(name);  》》
	}
复制代码

AbstractBeanFactory#getBean

@Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false); 》》
	}
复制代码

AbstractBeanFactory#doGetBean

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

		// 对beanName进行转换 name如果是"&gongjFactoryBean"，那么beanName就是"gongjFactoryBean"
		final String beanName = transformedBeanName(name); 》》
		Object bean;

		//根据beanName去单例池中获取单例Bean
		Object sharedInstance = getSingleton(beanName);  》》
		if (sharedInstance != null && args == null) {
		      //.....省略代码
            // 判断sharedInstance是不是FactoryBean，
			// 如果是FactoryBean，那么真正需要拿到的是getObject方法所返回的对象
			//beanName 是spinrg进行解析后获取到的BeanName  
            //name 我们手动传入的beanName
			//sharedInstance 根据beanName获取到的单例Bean对象
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);  》》
		}

       else{
          //....省略代码 下篇分析
       }
}
复制代码

AbstractBeanFactory#transformedBeanName
先调用 BeanFactoryUtils.transformedBeanName方法，然后拿到返回值，再执行canonicalName方法。

//返回beanName，去掉传入name的&前缀，并且把返回的name当做别名去aliasMap中寻找原始的beanName
protected String transformedBeanName(String name) { 
		return canonicalName(BeanFactoryUtils.transformedBeanName(name));
	}
复制代码

BeanFactoryUtils#transformedBeanName

private static final Map<String, String> transformedBeanNameCache = new ConcurrentHashMap<>();
String FACTORY_BEAN_PREFIX = "&";

public static String transformedBeanName(String name) {
		Assert.notNull(name, "'name' must not be null");
		// 如果beanName没有以&开头，则直接返回
		if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {   // gongjFactoryBean
			return name;
		}
		// 如果beanName以&开头，截取&后的beanName，并且把截取前后的name存在transformedBeanNameCache 中
//可能会有多个&&&，循环截取
		return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
			do {
				beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
			}
			while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
			return beanName;
		});
	}
复制代码

SimpleAliasRegistry#canonicalName

private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);

public String canonicalName(String name) {
		String canonicalName = name;
		String resolvedName;
		do {
//根据传递过来的beanName，去别名Map中查找  获取出来就是真正的BeanName  例如：gjfg = gongjFactoryBean
			resolvedName = this.aliasMap.get(canonicalName); 
			if (resolvedName != null) {
				canonicalName = resolvedName;
			}
		}
		while (resolvedName != null);
		return canonicalName;
	}
复制代码

transformedBeanName 方法到此结束!

getSingleton

再来看一下 Spring 是如何根据 beanName 去单例池中获取单例Bean

@Override
	@Nullable
	public Object getSingleton(String beanName) {
		return getSingleton(beanName, true);
	}
复制代码

@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// 从单例池中获取实例  singletonObjects 一级缓存
		Object singletonObject = this.singletonObjects.get(beanName);

		// 如果从单例池中没有获取到实例 并且指定的单例bean正在创建中
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		//锁定全局变量并进行处理
			synchronized (this.singletonObjects) {
				//earlySingletonObjects 二级缓存
				singletonObject = this.earlySingletonObjects.get(beanName);
				// 没有从二级缓存中获取到
				if (singletonObject == null && allowEarlyReference) {
					//当某些方法需要提前初始化的时候，会调 addSingletonFactory 方法将对
					//ObjectFactory 初始化存储在 singletonFactories Map中
					// singletonFactories 三级缓存
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject(); 
//记录在缓存中 earlySingletonObjects与singletonFactories互斥
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}
复制代码

这个方法首先尝试从 singletonObjects(一级缓存) 里面获取实例，如果取不到再从earlySingletonObjects(二级缓存) 里面获取，如果还获取不到，再尝试从 singletonFactories(三级缓存) 里面获取 beanName 对应的 ObjectFactory ，然后调用这个 ObjectFactory 的 getObject 方法来获取 bean ，并放到 earlySingletonObjects(二级缓存) 里面，并且从 singletonFacotories(三级缓存) 里面 remove 掉这个 ObjectFactorγ。

singletonObjects ：单例对象的缓存：Bean名称到Bean实例，也就是常说的单例池(一级缓存)。
singletonFacotories ：单例工厂的缓存(三级缓存)， Bean名称到ObjectFactory，一旦最终对象被创建(通过objectFactory.getObject())，此引用信息将删除
earlySingletonObjects ：用于存储在创建Bean早期对创建的原始bean的一个引用(二级缓存)，注意这里是原始bean，即使用工厂方法或构造方法创建出来的对象，一旦对象最终创建好，此引用信息将删除

getSingleton 方法到此结束!

AbstractBeanFactory#getObjectForBeanInstance
关键部分就在这个方法中，进入方法代码

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

		// name也就是我传入的beanName 如果是以&符号开头，则直接返回单例池（SingletonObjects）中的对象
		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
//判断单例对象beanInstance是否实现了FactoryBean，如果没有抛出异常
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
			}
			if (mbd != null) {
				mbd.isFactoryBean = true;
			}
            // 返回单例池（SingletonObjects）中的对象
			return beanInstance;
		}

		// 如果 beanInstance 不是 FactoryBean，则直接返回
		if (!(beanInstance instanceof FactoryBean)) {
			return beanInstance;
		}

		Object object = null;
		if (mbd != null) {
			mbd.isFactoryBean = true;
		}
		else {
//根据真正的BeanName从factoryBeanObjectCache缓存中获取Bean对象
			object = getCachedObjectForFactoryBean(beanName);
		}

		// 从factoryBeanObjectCache中没有拿到则进行创建
		if (object == null) {
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
//从beanDefinitionMap判断该Bean是否存在
			if (mbd == null && containsBeanDefinition(beanName)) {
//进行Bean合并
				mbd = getMergedLocalBeanDefinition(beanName); 
			}
//是否是用户定义的而不是应用程序本身定义的
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			// 调用getObject方法得到对象
			object = getObjectFromFactoryBean(factory, beanName, !synthetic); 》》
		}
		return object;
	}
复制代码

FactoryBeanRegistrySupport#getObjectFromFactoryBean

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		// 是不是单例的 && 根据 beanName 判断该名称在 singletonObjects(单例池) 中是否存在
		if (factory.isSingleton() && containsSingleton(beanName)) {
			synchronized (getSingletonMutex()) {
				Object object = this.factoryBeanObjectCache.get(beanName);
				if (object == null) {
					// 调用getObject方法得到一个对象
					object = doGetObjectFromFactoryBean(factory, beanName); 》》
                    //再从缓存中获取一遍
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
					if (alreadyThere != null) {
						object = alreadyThere;
					}
					else {
						if (shouldPostProcess) {
							//返回指定的单例bean当前是否正在创建中
							if (isSingletonCurrentlyInCreation(beanName)) {
								return object;
							}
                          //表示这些bean正常创建中，在没创建完时不能重复创建
							beforeSingletonCreation(beanName);
							try {
								// 调用BeanPostProcessor执行初始化后的逻辑，主要就是进行AOP
								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)) {
						//将创建的Bean放入factoryBeanObjectCache
							this.factoryBeanObjectCache.put(beanName, object);
						}
					}
				}
				return object;
			}
		}
		else {
			// 多例 每次都创建一个，不从factoryBeanObjectCache中获取
			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;
		}
	}
复制代码

FactoryBeanRegistrySupport#doGetObjectFromFactoryBean
在 doGetObjectFromFactoryBean 方法中我们终于看到了我们想要看到的方法，也就是 object = factory.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 {
      //调用了FectoryBean里的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);
		}
		// 如果调用getObject()方法返回的是null，那么则返回一个NullBean
		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 就结束啦！当然 getBean 方法才看到冰山一角。

FactoryBean是一个能生产或修饰对象生成的工厂 Bean。一个 Bean 如果实现了 FactoryBean 接口，那么根据该 Bean 的名称获取到的实际上是 getObject() 返回的对象，而不是这个 Bean 自身实例，如果要获取这个Bean自身实例，那么需要在名称前面加上'&'符号。

文章版权归作者所有，未经允许请勿转载。

THE END

后端