之前,我们已尽完成了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 * 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 #setDependencyCheck104 * @see org.springframework.beans.BeanUtils#isSimpleProperty105 */106 public static final int DEPENDENCY_CHECK_SIMPLE = 2;107 108 /**109 * Constant that indicates dependency checking for all properties (object references110 * as well as "simple" properties).111 * 112 * 常数，指示所有属性的依赖检查113 * 114 * @see #setDependencyCheck115 */116 public static final int DEPENDENCY_CHECK_ALL = 3;117 118 /**119 * Constant that indicates the container should attempt to infer the120 * { @link #setDestroyMethodName destroy method name} for a bean as opposed to explicit121 * specification of a method name. The value { @value} is specifically designed to122 * include characters otherwise illegal in a method name, ensuring no possibility of123 * 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属性scope136 */137 private String scope = SCOPE_DEFAULT;138 139 /**140 * 是否是抽象Bean ,对应bean属性abstractFlag141 */142 private boolean abstractFlag = false;143 144 /**145 * 是否延迟加载,对应Bean属性lazy-init146 */147 private boolean lazyInit = false;148 149 /**150 * 自动注入模式,,对应Bean属性autowire151 */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-on161 */162 private String[] dependsOn;163 164 /**165 * autowire-candidate属性设置为false,这样容器在查找自动装配对象时,将不考虑该bean,即它不会被考虑为其他bean自动装配的候选者,166 * 但是该bean本身还是可以使用自动装配来注入其他属性,167 * 168 * 对应Bean属性autowire-candidate169 */170 private boolean autowireCandidate = true;171 172 /**173 * 自动装配当出现多个bean候选者,将作为首选者,是默认不是主要候选者,对应Bean属性primary174 */175 private boolean primary = false;176 177 /**178 * 用于记录qualifiers ,对应Bean属性qualifier179 */180 private final Map qualifiers = new LinkedHashMap (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-arg214 */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 * 231 * 232 * 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 and298 * 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 from313 */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的qualifier359 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 } 代码中的注释已经相当详细了,这里不多做解释!