之前,我们已尽完成了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 }
代码中的注释已经相当详细了,这里不多做解释!
转载于:https://www.cnblogs.com/mjorcen/p/3648487.html