3.8 spring - AbstractBeanDefinition 介绍

　　之前,我们已尽完成了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     }

　　代码中的注释已经相当详细了,这里不多做解释!