之前,我们已尽完成了xml 文档到 GenericBeanDefinition的转换,
也就是说,到这里,所有的配置都可以在GenericBeanDefinition 的实例中找到对应的配置.
GenericBeanDefinition只是子类实现,而大部分功能都是通用属性,都是保存在AbstractBeanDefinition中,
那么我们再次通过AbstractBeanDefinition 的属性来复习一下 我们都解析了哪些对应的配置.
AbstractBeanDefinition 的结果图如下:
我们在来看看源代码!
1 /**
2 * Base class for concrete, full-fledged
3 * {@link org.springframework.beans.factory.config.BeanDefinition} classes, factoring out
4 * common properties of {@link RootBeanDefinition} and {@link ChildBeanDefinition}.
5 *
6 * <p>
7 * The autowire constants match the ones defined in the
8 * {@link org.springframework.beans.factory.config.AutowireCapableBeanFactory} interface.
9 *
10 * @author Rod Johnson
11 * @author Juergen Hoeller
12 * @author Rob Harrop
13 * @author Mark Fisher
14 * @see RootBeanDefinition
15 * @see ChildBeanDefinition
16 */
17 @SuppressWarnings("serial")
18 public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
19 implements BeanDefinition, Cloneable {
20
21 /**
22 * Constant for the default scope name: "", equivalent to singleton status but to be
23 * overridden from a parent bean definition (if applicable).
24 *
25 * 常数为默认作用域的名称:“”,相当于单身状态,但是从父bean定义(如适用)所覆盖。
26 *
27 */
28 public static final String SCOPE_DEFAULT = "";
29
30 /**
31 * Constant that indicates no autowiring at all.
32 *
33 * 常数,指示没有自动装配。
34 *
35 * @see #setAutowireMode
36 */
37 public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;
38
39 /**
40 * Constant that indicates autowiring bean properties by name.
41 *
42 * 常数,表示按name自动装配bean的属性。
43 *
44 * @see #setAutowireMode
45 */
46 public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;
47
48 /**
49 * Constant that indicates autowiring bean properties by type.
50 *
51 * 常数,指示按类型自动装配bean的属性。
52 *
53 * @see #setAutowireMode
54 */
55 public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;
56
57 /**
58 * Constant that indicates autowiring a constructor.
59 *
60 * 常数,表示自动装配一个构造。
61 *
62 * @see #setAutowireMode
63 */
64 public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;
65
66 /**
67 * Constant that indicates determining an appropriate autowire strategy through
68 * introspection of the bean class.
69 *
70 * 常数指示不依赖检查。
71 *
72 * @see #setAutowireMode
73 * @deprecated as of Spring 3.0: If you are using mixed autowiring strategies, use
74 * annotation-based autowiring for clearer demarcation of autowiring
75 * needs.
76 */
77 @Deprecated
78 public static final int AUTOWIRE_AUTODETECT = AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT;
79
80 /**
81 * Constant that indicates no dependency check at all.
82 *
83 * 常数,表示为对象引用的依赖检查。
84 *
85 * @see #setDependencyCheck
86 */
87 public static final int DEPENDENCY_CHECK_NONE = 0;
88
89 /**
90 * Constant that indicates dependency checking for object references.
91 *
92 * 常数,表示为对象引用的依赖检查。
93 *
94 * @see #setDependencyCheck
95 */
96 public static final int DEPENDENCY_CHECK_OBJECTS = 1;
97
98 /**
99 * Constant that indicates dependency checking for "simple" properties.
100 *
101 * 常数,指出“简单”的属性的依赖检查。
102 *
103 * @see #setDependencyCheck
104 * @see org.springframework.beans.BeanUtils#isSimpleProperty
105 */
106 public static final int DEPENDENCY_CHECK_SIMPLE = 2;
107
108 /**
109 * Constant that indicates dependency checking for all properties (object references
110 * as well as "simple" properties).
111 *
112 * 常数,指示所有属性的依赖检查
113 *
114 * @see #setDependencyCheck
115 */
116 public static final int DEPENDENCY_CHECK_ALL = 3;
117
118 /**
119 * Constant that indicates the container should attempt to infer the
120 * {@link #setDestroyMethodName destroy method name} for a bean as opposed to explicit
121 * specification of a method name. The value {@value} is specifically designed to
122 * include characters otherwise illegal in a method name, ensuring no possibility of
123 * collisions with legitimately named methods having the same name.
124 *
125 * 常数,方法检查
126 */
127 public static final String INFER_METHOD = "(inferred)";
128
129 /**
130 * 应该是这个bean的Class类型吧
131 */
132 private volatile Object beanClass;
133
134 /**
135 * bean的作用范围,对应Bean属性scope
136 */
137 private String scope = SCOPE_DEFAULT;
138
139 /**
140 * 是否是抽象Bean ,对应bean属性abstractFlag
141 */
142 private boolean abstractFlag = false;
143
144 /**
145 * 是否延迟加载,对应Bean属性lazy-init
146 */
147 private boolean lazyInit = false;
148
149 /**
150 * 自动注入模式,,对应Bean属性autowire
151 */
152 private int autowireMode = AUTOWIRE_NO;
153
154 /**
155 * 依赖检查,Spring 3.0后弃用这个属性
156 */
157 private int dependencyCheck = DEPENDENCY_CHECK_NONE;
158
159 /**
160 * 用来表示一个Bean的实例化依靠另一个Bean先实例化,对应Bean属性depend-on
161 */
162 private String[] dependsOn;
163
164 /**
165 * autowire-candidate属性设置为false,这样容器在查找自动装配对象时,将不考虑该bean,即它不会被考虑为其他bean自动装配的候选者,
166 * 但是该bean本身还是可以使用自动装配来注入其他属性,
167 *
168 * 对应Bean属性autowire-candidate
169 */
170 private boolean autowireCandidate = true;
171
172 /**
173 * 自动装配当出现多个bean候选者,将作为首选者,是默认不是主要候选者,对应Bean属性primary
174 */
175 private boolean primary = false;
176
177 /**
178 * 用于记录qualifiers ,对应Bean属性qualifier
179 */
180 private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<String, AutowireCandidateQualifier>(
181 0);
182
183 /**
184 * 允许访问非公开的构造器和方法
185 */
186 private boolean nonPublicAccessAllowed = true;
187
188 /**
189 * 是否以一种宽松的模式解析构造函数,默认为true,
190 *
191 * 如果为false,则在如下情况,
192 *
193 * interface Person{}
194 *
195 * class Theacher implemente Person{}
196 *
197 * class Main{
198 *
199 * Main(Person p){}
200 *
201 * Main(Theacher t){}
202 *
203 * 抛出异常,因为Spring无法准确定位哪个构造函数,
204 *
205 * 程序设置
206 *
207 * }
208 *
209 */
210 private boolean lenientConstructorResolution = true;
211
212 /**
213 * 记录构造函数注入属性, 对应Bean属性constructor-arg
214 */
215 private ConstructorArgumentValues constructorArgumentValues;
216
217 /**
218 * 普通属性的集合
219 */
220 private MutablePropertyValues propertyValues;
221
222 /**
223 * 方法重写的持有者 ,记录 lookup-method,replaced-method元素
224 */
225 private MethodOverrides methodOverrides = new MethodOverrides();
226
227 /**
228 * 对应Bean的factory-bean 的属性,用法:
229 *
230 * <bean id = "factoryBean" class = "test.TestFactoryBean">
231 *
232 * <bean id = "ct" factory-bean= "factoryBean" factory-method = "getBean">
233 *
234 *
235 */
236 private String factoryBeanName;
237
238 /**
239 * 这个bean的工厂方法名
240 */
241 private String factoryMethodName;
242
243 /**
244 * 这个bean的初始化方法名
245 */
246 private String initMethodName;
247
248 /**
249 * 这个bean的销毁方法名
250 */
251 private String destroyMethodName;
252
253 /**
254 * 是否执行 init-method 方法,默认执行初始化方法,程序设置
255 */
256 private boolean enforceInitMethod = true;
257
258 /**
259 * 是否执行 destory-method 方法,默认执行销毁方法,程序设置
260 */
261 private boolean enforceDestroyMethod = true;
262
263 /**
264 * 是否是用户定义的而不是应用程序本身定义的, 创建AOP的时候为true,程序设置
265 */
266 private boolean synthetic = false;
267
268 /**
269 * 定义这个bean的应用,
270 *
271 * ROLE_APPLICATION:用户,
272 *
273 * ROLE_INFRASTRUCTURE:完全内部使用,与用户无关;
274 *
275 * ROLE_SUPPORT:某些复杂配置的一部分
276 */
277 private int role = BeanDefinition.ROLE_APPLICATION;
278
279 /**
280 * bean 的描述信息
281 */
282 private String description;
283
284 /**
285 * 这个Bean定义的资源
286 */
287 private Resource resource;
288
289 /**
290 * Create a new AbstractBeanDefinition with default settings.
291 */
292 protected AbstractBeanDefinition() {
293 this(null, null);
294 }
295
296 /**
297 * Create a new AbstractBeanDefinition with the given constructor argument values and
298 * property values.
299 */
300 /*
301 * 创建新的AbstractBeanDefinition实例并给定ConstructorArgumentValues实例和MutabePropertyValues实例
302 */
303 protected AbstractBeanDefinition(ConstructorArgumentValues cargs,
304 MutablePropertyValues pvs) {
305 setConstructorArgumentValues(cargs);
306 setPropertyValues(pvs);
307 }
308
309 /**
310 * Create a new AbstractBeanDefinition as a deep copy of the given bean definition.
311 *
312 * @param original the original bean definition to copy from
313 */
314 /*
315 * 创建一个新的AbstractBeanDefinition并深入拷贝给定的BeanDefinition实例
316 */
317 protected AbstractBeanDefinition(BeanDefinition original) {
318 // 抽象方法,由子类实现,设置父类名
319 setParentName(original.getParentName());
320 // 设置这个bean的类名称
321 setBeanClassName(original.getBeanClassName());
322 // 设置这个bean的工厂bean名称
323 setFactoryBeanName(original.getFactoryBeanName());
324 // 设置这个bean的工厂方法名称
325 setFactoryMethodName(original.getFactoryMethodName());
326 // 设置这个bean的作用范围,如单例的还是原型的,也有可能是其它的
327 setScope(original.getScope());
328 // 设置这个bean是否是抽象的
329 setAbstract(original.isAbstract());
330 // 设置这个bean是否开启延载初始化
331 setLazyInit(original.isLazyInit());
332 // 设置这个bean的角色
333 setRole(original.getRole());
334 // 设置这个bean的构造参数持有者
335 setConstructorArgumentValues(new ConstructorArgumentValues(
336 original.getConstructorArgumentValues()));
337 // 设置这个bean的Property持有者
338 setPropertyValues(new MutablePropertyValues(original.getPropertyValues()));
339 // 设置这个bean的配置源
340 setSource(original.getSource());
341 // 这个bean复制属性组名称
342 copyAttributesFrom(original);
343 // 判断origina是否是AbstractBeanDefinition子类
344 if (original instanceof AbstractBeanDefinition) {
345 AbstractBeanDefinition originalAbd = (AbstractBeanDefinition) original;
346 if (originalAbd.hasBeanClass()) {
347 // 设置这个bean的Class类型
348 setBeanClass(originalAbd.getBeanClass());
349 }
350 // 设置这个bean的自动装配模式
351 setAutowireMode(originalAbd.getAutowireMode());
352 // 设置这个bean的依赖检查
353 setDependencyCheck(originalAbd.getDependencyCheck());
354 // 设置这个bean初始化要依赖的bean名称数组
355 setDependsOn(originalAbd.getDependsOn());
356 // 设置这个bean是否自动装配候选
357 setAutowireCandidate(originalAbd.isAutowireCandidate());
358 // 设置这个bean的qualifier
359 copyQualifiersFrom(originalAbd);
360 // 设置这个bean是否是主要候选者
361 setPrimary(originalAbd.isPrimary());
362 // 设置是否允许访问非public的构造器和方法
363 setNonPublicAccessAllowed(originalAbd.isNonPublicAccessAllowed());
364 // 设置是否以一种宽松的模式解析构造函数
365 setLenientConstructorResolution(originalAbd.isLenientConstructorResolution());
366 // 设置这个bean的初始化方法名
367 setInitMethodName(originalAbd.getInitMethodName());
368 // 设置是否执行初始化方法
369 setEnforceInitMethod(originalAbd.isEnforceInitMethod());
370 // 设置这个bean的销毁方法名
371 setDestroyMethodName(originalAbd.getDestroyMethodName());
372 // 设置是否执行销毁方法
373 setEnforceDestroyMethod(originalAbd.isEnforceDestroyMethod());
374 // 设置这个bean的方法重写持有者
375 setMethodOverrides(new MethodOverrides(originalAbd.getMethodOverrides()));
376 // 设置这个bean是人造的或者是应用程序本身
377 setSynthetic(originalAbd.isSynthetic());
378 // 设置这个Bean定义的资源
379 setResource(originalAbd.getResource());
380 }
381 else {
382 setResourceDescription(original.getResourceDescription());
383 }
384 }
代码中的注释已经相当详细了,这里不多做解释!