spring启动流程 (4) FactoryBean详解

FactoryBean接口

实现类对象将被用作创建Bean实例的工厂，即调用getObject()方法返回的对象才是真正要使用的Bean实例，而不是直接将FactoryBean对象作为暴露的Bean实例。
FactoryBeans可以支持singleton和prototype，并且可以根据需要懒加载或在启动时立即创建对象。
这个接口在编写扫描接口生成代理对象的场景下经常使用，比如Mybatis Mapper接口扫描、Dubbo接口扫描、Feign接口扫描等。
Spring容器只负责管理FactoryBean实例的生命周期，而不是FactoryBean创建的对象的生命周期。因此不会自动调用暴露的Bean对象的destroy方法。FactoryBean应该实现DisposableBean，并将关闭调用委托给底层对象。

1. public interface FactoryBean<T> {
3.         /**
4.          * Return an instance (possibly shared or independent) of the object
5.          * managed by this factory.
6.          */
7.         T getObject() throws Exception;
9.         /**
10.          * Return the type of object that this FactoryBean creates,
11.          * or null if not known in advance.
12.          */
13.         Class<?> getObjectType();
15.         /**
16.          * Is the object managed by this factory a singleton?
17.          */
18.         default boolean isSingleton() {
19.                 return true;
20.         }
21. }

复制代码

我们可以使用正常的getBean(beanName)方式获取通过getObject()方法暴露的Bean实例，也可以使用getBean("&" + beanName)方式获取FactoryBean的实例。
下文将介绍其实现方式。
FactoryBean的实现方式

Spring创建单例Bean的逻辑在DefaultListableBeanFactory的preInstantiateSingletons()方法中：

1. public void preInstantiateSingletons() throws BeansException {
3.         List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
5.         // Trigger initialization of all non-lazy singleton beans...
6.         for (String beanName : beanNames) {
7.                 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
8.                 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
9.                         if (isFactoryBean(beanName)) {
10.                                 // 此处使用"& + beanName"作为beanName创建FactoryBean实例
11.                                 Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
12.                                 if (bean instanceof FactoryBean) {
13.                                         FactoryBean<?> factory = (FactoryBean<?>) bean;
14.                                         boolean isEagerInit;
15.                                         if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
16.                                                 isEagerInit = AccessController.doPrivileged(
17.                                                                 (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
18.                                                                 getAccessControlContext());
19.                                         } else {
20.                                                 isEagerInit = (factory instanceof SmartFactoryBean &&
21.                                                                 ((SmartFactoryBean<?>) factory).isEagerInit());
22.                                         }
23.                                         if (isEagerInit) {
24.                                                 getBean(beanName);
25.                                         }
26.                                 }
27.                         } else {
28.                                 getBean(beanName);
29.                         }
30.                 }
31.         }
33.         // Trigger post-initialization callback for all applicable beans...
34.         // ...
35. }
37. public Object getBean(String name) throws BeansException {
38.         return doGetBean(name, null, null, false);
39. }
41. protected <T> T doGetBean(
42.                 String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly)
43.                 throws BeansException {
45.         // 此步骤将&符移除
46.         String beanName = transformedBeanName(name);
47.         Object bean;
49.         Object sharedInstance = getSingleton(beanName);
50.         if (sharedInstance != null && args == null) {
51.                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
52.         } else {
53.                 if (isPrototypeCurrentlyInCreation(beanName)) {
54.                         throw new BeanCurrentlyInCreationException(beanName);
55.                 }
57.                 BeanFactory parentBeanFactory = getParentBeanFactory();
58.                 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
59.                         String nameToLookup = originalBeanName(name);
60.                         if (parentBeanFactory instanceof AbstractBeanFactory) {
61.                                 return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
62.                                                 nameToLookup, requiredType, args, typeCheckOnly);
63.                         } else if (args != null) {
64.                                 return (T) parentBeanFactory.getBean(nameToLookup, args);
65.                         } else if (requiredType != null) {
66.                                 return parentBeanFactory.getBean(nameToLookup, requiredType);
67.                         } else {
68.                                 return (T) parentBeanFactory.getBean(nameToLookup);
69.                         }
70.                 }
72.                 if (!typeCheckOnly) {
73.                         markBeanAsCreated(beanName);
74.                 }
76.                 try {
77.                         RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
78.                         checkMergedBeanDefinition(mbd, beanName, args);
80.                         String[] dependsOn = mbd.getDependsOn();
81.                         if (dependsOn != null) {
82.                                 for (String dep : dependsOn) {
83.                                         if (isDependent(beanName, dep)) {
84.                                                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
85.                                                                 "Circular depends-on relationship between");
86.                                         }
87.                                         registerDependentBean(dep, beanName);
88.                                         try {
89.                                                 getBean(dep);
90.                                         } catch (NoSuchBeanDefinitionException ex) {
91.                                                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
92.                                                                 "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
93.                                         }
94.                                 }
95.                         }
97.                         if (mbd.isSingleton()) {
98.                                 // getSingleton方法中会先从单例池查找Bean
99.                                 // 如果没有则会调用lambda中的createBean(beanName, mbd, args)创建Bean并将其注册到单例池
100.                                 // 所以此时放入单例池的是FactoryBean实例
101.                                 sharedInstance = getSingleton(beanName, () -> {
102.                                         try {
103.                                                 // 此处的beanName参数是不带&符的字符串
104.                                                 return createBean(beanName, mbd, args);
105.                                         } catch (BeansException ex) {
106.                                                 destroySingleton(beanName);
107.                                                 throw ex;
108.                                         }
109.                                 });
110.                                 // beanName参数是不带&符的字符串
111.                                 // name是原始的带&符的字符串
112.                                 // 该方法里面会判断name是否有&符，如果有直接返回FactoryBean实例
113.                                 // 如果没有&符会调用getObject()方法获取真正要暴露的Bean实例
114.                                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
115.                         } else if (mbd.isPrototype()) {
116.                                 Object prototypeInstance = null;
117.                                 try {
118.                                         beforePrototypeCreation(beanName);
119.                                         prototypeInstance = createBean(beanName, mbd, args);
120.                                 } finally {
121.                                         afterPrototypeCreation(beanName);
122.                                 }
123.                                 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
124.                         } else {
125.                                 String scopeName = mbd.getScope();
126.                                 if (!StringUtils.hasLength(scopeName)) {
127.                                         throw new IllegalStateException("No scope name defined for bean");
128.                                 }
129.                                 Scope scope = this.scopes.get(scopeName);
130.                                 if (scope == null) {
131.                                         throw new IllegalStateException("No Scope registered for scope name");
132.                                 }
133.                                 try {
134.                                         Object scopedInstance = scope.get(beanName, () -> {
135.                                                 beforePrototypeCreation(beanName);
136.                                                 try {
137.                                                         return createBean(beanName, mbd, args);
138.                                                 } finally {
139.                                                         afterPrototypeCreation(beanName);
140.                                                 }
141.                                         });
142.                                         bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
143.                                 } catch (IllegalStateException ex) {
144.                                         throw new BeanCreationException(beanName, "", ex);
145.                                 }
146.                         }
147.                 } catch (BeansException ex) {
148.                         cleanupAfterBeanCreationFailure(beanName);
149.                         throw ex;
150.                 }
151.         }
153.         return (T) bean;
154. }
156. protected Object getObjectForBeanInstance(
157.                 Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
159.         // 判断name有&符，直接返回FactoryBean实例
160.         if (BeanFactoryUtils.isFactoryDereference(name)) {
161.                 if (beanInstance instanceof NullBean) {
162.                         return beanInstance;
163.                 }
164.                 if (!(beanInstance instanceof FactoryBean)) {
165.                         throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
166.                 }
167.                 if (mbd != null) {
168.                         mbd.isFactoryBean = true;
169.                 }
170.                 return beanInstance;
171.         }
173.         if (!(beanInstance instanceof FactoryBean)) {
174.                 return beanInstance;
175.         }
177.         Object object = null;
178.         if (mbd != null) {
179.                 mbd.isFactoryBean = true;
180.         } else {
181.                 // 从factoryBeanObjectCache池获取
182.                 object = getCachedObjectForFactoryBean(beanName);
183.         }
184.         if (object == null) {
185.                 // Return bean instance from factory.
186.                 FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
187.                 // Caches object obtained from FactoryBean if it is a singleton.
188.                 if (mbd == null && containsBeanDefinition(beanName)) {
189.                         mbd = getMergedLocalBeanDefinition(beanName);
190.                 }
191.                 boolean synthetic = (mbd != null && mbd.isSynthetic());
192.                 // 调用getObject()方法获取真正要暴露的Bean实例并将其放入factoryBeanObjectCache池
193.                 object = getObjectFromFactoryBean(factory, beanName, !synthetic);
194.         }
195.         return object;
196. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！