在Spring IOC里面经常能看到BeanFactory与FactoryBean这俩个词，虽然看起来很相似，但真的是千差万别。BeanFactory以factory结尾，说明它是个工厂，而FactoryBean是以bean结尾，说明它是个特殊的bean，但还是属于bean 的范畴。
BeanFactory
- 作为Spring IOC容器里最核心最顶层的接口，它是一个工厂接口，对外提供了获取bean的方法。主要职责是实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。这个不是本章的重点，因为整个系列都在说beanFactory。
FactoryBean
- 什么是FactoryBean呢？凡是实现了FactoryBean<T>接口的bean都可以称之为是FactoryBean。我们来看一下FactoryBean<T>的接口定义了哪些方法：
public interface FactoryBean<T> {
T getObject() throws Exception;
Class<T> getObjectType();
boolean isSingleton();
}
但凡实现了这个接口的bean，通过id来从容器里获取到的不是这个bean的本身，而是实现了getObject方法返回的对象，如果想要获取这个bean的本身，则需要在id前面加上&符号。
- 既然知道了这个接口的作用，那么在IOC容器里它又是如何运作的呢？话不多说直接往下看
直接看源码
//来自于AbstractBeanFactory，235行
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
// 获取一个 “正统的” beanName，处理两种情况，一个是前面说的 FactoryBean(前面带 ‘&’)，
// 一个是别名问题，因为这个方法是 getBean，获取 Bean 用的，你要是传一个别名进来，是完全可以的
final String beanName = transformedBeanName(name);
// 注意跟着这个，这个是返回值
Object bean;
// 检查下是不是已经创建过了
Object sharedInstance = getSingleton(beanName);
// 这里说下 args 呗，虽然看上去一点不重要。前面我们一路进来的时候都是 getBean(beanName)，
// 所以 args 传参其实是 null 的，但是如果 args 不为空的时候，那么意味着调用方不是希望获取 Bean，而是创建 Bean
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("...");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 重点重点本章的聚焦重点方法
// 下面这个方法：如果是普通 Bean 的话，直接返回 sharedInstance，
// 如果是 FactoryBean 的话，返回它创建的那个实例对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
if (isPrototypeCurrentlyInCreation(beanName)) {
// 创建过了此 beanName 的 prototype 类型的 bean，那么抛异常，
// 往往是因为陷入了循环引用
throw new BeanCurrentlyInCreationException(beanName);
}
// 检查一下这个 BeanDefinition 在容器中是否存在
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 如果当前容器不存在这个 BeanDefinition，试试父容器中有没有
String nameToLookup = originalBeanName(name);
if (args != null) {
// 返回父容器的查询结果
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
// typeCheckOnly 为 false，将当前 beanName 放入一个 alreadyCreated 的 Set 集合中。
markBeanAsCreated(beanName);
}
/*
* 稍稍总结一下：
* 到这里的话，要准备创建 Bean 了，对于 singleton 的 Bean 来说，容器中还没创建过此 Bean；
* 对于 prototype 的 Bean 来说，本来就是要创建一个新的 Bean。
*/
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 先初始化依赖的所有 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);
// 先初始化被依赖项
getBean(dep);
}
}
// 如果是 singleton scope 的，创建 singleton 的实例
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
// 执行创建 Bean，详情后面再说
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 如果是 prototype scope 的，创建 prototype 的实例
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
// 执行创建 Bean
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 如果不是 singleton 和 prototype 的话，需要委托给相应的实现类来处理
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, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
// 执行创建 Bean
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;
}
}
// 最后，检查一下类型对不对，不对的话就抛异常，对的话就返回了
if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
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;
}
看完以后可以明白问题聚焦在了bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
继续看源码：
//来自于AbstractBeanFactory，1607行
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
// 如果这里不是对FactoryBean的调用,那么结束处理
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
// 现在我们有了bean实例，它可能是普通bean或factrybean
// 如果它是factorybean，我们使用它来创建bean实例，除非
// 调用方实际上需要对工厂的引用
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
if (mbd == null) {
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中得到Bean
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
继续看
// 来自于FactoryBeanRegistrySupport，98行
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
// 从cache中获取这个对象
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 (object != null && shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
}
this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
}
}
return (object != NULL_OBJECT ? object : null);
}
}
else {
// 从FactoryBean获取这个对象
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (object != null && shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
//来自于FactoryBeanRegistrySupport，148行
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(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
// 重点调用的就是这个方法getObject方法
// 最终调用FactoryBean.getObject()方法
return 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 && isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
return object;
}
- 通过上面的源码解读，那么已经清楚IOC容器里FactoryBean是如何操作的了，那么我们不经问一下，到底什么场景适合使用BeanFactory这个特殊的bean呢？
FactoryBean 适用于 Bean 的创建过程比较复杂的场景，比如数据库连接池的创建h或者是封装Proxy、RMI/JNDI等、AOP的代理相关也是用到了FactoryBean。
我们使用FactoryBean来完成一个功能：用来代理一个对象，对该对象的某个方法做一个拦截，在调用前后都输出一行System.out.println()，模仿ProxyFactoryBean的功能
package com.suxin;
public interface TeacherInterface {
void teach();
void myName();
}
package com.suxin;
public class Teacher implements TeacherInterface{
public void teach() {
System.out.println("进行教学活动");
}
public void myName() {
System.out.println("my name is AD");
}
}
package com.suxin;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MyFactoryBean implements FactoryBean, InitializingBean, DisposableBean {
private String interfaceName;
private Object target;
private Object proxyObj;
public Object getObject() throws Exception {
System.out.println("getObject......");
return proxyObj;
}
public Class<?> getObjectType() {
return proxyObj == null ? Object.class : proxyObj.getClass();
}
public boolean isSingleton() {
return true;
}
public void afterPropertiesSet() throws Exception {
proxyObj = Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{Class.forName(interfaceName)},
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if(method.getName().equals("teach")) {
System.out.println("invoke method......" + method.getName());
System.out.println("invoke method before......" + System.currentTimeMillis());
Object result = method.invoke(target, args);
System.out.println("invoke method after......" + System.currentTimeMillis());
return result;
}
return method.invoke(target, args);
}
});
System.out.println("afterPropertiesSet......");
}
public void destroy() throws Exception {
System.out.println("destroy......");
}
public String getInterfaceName() {
return interfaceName;
}
public void setInterfaceName(String interfaceName) {
this.interfaceName = interfaceName;
}
public Object getTarget() {
return target;
}
public void setTarget(Object target) {
this.target = target;
}
public Object getProxyObj() {
return proxyObj;
}
public void setProxyObj(Object proxyObj) {
this.proxyObj = proxyObj;
}
}
<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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="teacher" class="com.suxin.Teacher"></bean>
<bean id="proxyTeacher" class="com.suxin.MyFactoryBean">
<property name="interfaceName" value="com.suxin.TeacherInterface"></property>
<property name="target" ref="teacher"></property>
</bean>
</beans>
package com.suxin;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
/**
* Hello world!
*
*/
public class App {
public static void main( String[] args ) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
TeacherInterface teacher = (TeacherInterface) context.getBean("proxyTeacher");
teacher.teach();
teacher.myName();
teacher.teach();
}
}
直接看控制台展示
D:\soft\jdk1.8.0_162\bin\java.exe "-javaagent:D:\soft\IntelliJ IDEA2019.1.3\lib\idea_rt.jar=55596:D:\soft\IntelliJ IDEA2019.1.3\bin" -Dfile.encoding=UTF-8 -classpath D:\soft\jdk1.8.0_162\jre\lib\charsets.jar;D:\soft\jdk1.8.0_162\jre\lib\deploy.jar;D:\soft\jdk1.8.0_162\jre\lib\ext\access-bridge-64.jar;D:\soft\jdk1.8.0_162\jre\lib\ext\cldrdata.jar;D:\soft\jdk1.8.0_162\jre\lib\ext\dnsns.jar;D:\soft\jdk1.8.0_162\jre\lib\ext\jaccess.jar;D:\soft\jdk1.8.0_162\jre\lib\ext\jfxrt.jar;D:\soft\jdk1.8.0_162\jre\lib\ext\localedata.jar;D:\soft\jdk1.8.0_162\jre\lib\ext\nashorn.jar;D:\soft\jdk1.8.0_162\jre\lib\ext\sunec.jar;D:\soft\jdk1.8.0_162\jre\lib\ext\sunjce_provider.jar;D:\soft\jdk1.8.0_162\jre\lib\ext\sunmscapi.jar;D:\soft\jdk1.8.0_162\jre\lib\ext\sunpkcs11.jar;D:\soft\jdk1.8.0_162\jre\lib\ext\zipfs.jar;D:\soft\jdk1.8.0_162\jre\lib\javaws.jar;D:\soft\jdk1.8.0_162\jre\lib\jce.jar;D:\soft\jdk1.8.0_162\jre\lib\jfr.jar;D:\soft\jdk1.8.0_162\jre\lib\jfxswt.jar;D:\soft\jdk1.8.0_162\jre\lib\jsse.jar;D:\soft\jdk1.8.0_162\jre\lib\management-agent.jar;D:\soft\jdk1.8.0_162\jre\lib\plugin.jar;D:\soft\jdk1.8.0_162\jre\lib\resources.jar;D:\soft\jdk1.8.0_162\jre\lib\rt.jar;D:\myspace\springDemo\target\classes;C:\Users\Administrator\.m2\repository\org\springframework\spring-context\4.3.11.RELEASE\spring-context-4.3.11.RELEASE.jar;C:\Users\Administrator\.m2\repository\org\springframework\spring-aop\4.3.11.RELEASE\spring-aop-4.3.11.RELEASE.jar;C:\Users\Administrator\.m2\repository\org\springframework\spring-beans\4.3.11.RELEASE\spring-beans-4.3.11.RELEASE.jar;C:\Users\Administrator\.m2\repository\org\springframework\spring-core\4.3.11.RELEASE\spring-core-4.3.11.RELEASE.jar;C:\Users\Administrator\.m2\repository\commons-logging\commons-logging\1.2\commons-logging-1.2.jar;C:\Users\Administrator\.m2\repository\org\springframework\spring-expression\4.3.11.RELEASE\spring-expression-4.3.11.RELEASE.jar com.suxin.App
八月 07, 2019 2:46:20 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@2e0fa5d3: startup date [Wed Aug 07 14:46:20 CST 2019]; root of context hierarchy
八月 07, 2019 2:46:20 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
afterPropertiesSet......
getObject......
invoke method......teach
invoke method before......1565160382423
进行教学活动
invoke method after......1565160382423
my name is AD
invoke method......teach
invoke method before......1565160382423
进行教学活动
invoke method after......1565160382423
Process finished with exit code 0
至此我们就完成了一个动态代理类的功能。FactoryBean在Spring框架中运用的非常频繁，感兴趣的可以去看看。
