BeanDefiniton的介绍
Spring容器的启动过程大致可以分为两步：
- BeanDefinition 的加载。
- 容器的初始化。
我们知道使用Spring之前我们需要先定义Bean, 一般有两种方式定义，分别是xml和注解，两种方式的大同小异，都需要先将Bean的定义转化为BeanDefinition, BeanDefinition 包含了初始化该Bean所需要的信息，可以认为BeanDefinition 是Bean的一种描述，一种定义。 BeanDefinition 是Spring中重要的一个结构，后续的容器中实例的初始化依赖于BeanDefinition。
具体的加载过程
本文以xml为例来说明BeanDefinition的加载过程。
我们首先来看BeanDefinition的继承体系。
以上是BeanDefinition的继承体系，其中AbstractBeanDefinitin, GenericBeanDefiniton, RootBeanDefinition, ChildBeanDefiniton是BeanDefiniton加载过程中会用到的，而且其中AbstractBeanDefinitin 是GenericBeanDefiniton, RootBeanDefinition, ChildBeanDefiniton的公共父类。
下面从上到下来看一下这些接口和类。
- AttributeAccessor: 该接口声明了获取或者设置任意对象的元数据（metadata）的方法。
- AttributeAccessorSupport: 该抽象类实现了AttributeAccessor，定义了一个HashMap的属性 attributes 用于存储元数据。
- BeanMetadataElement: 该接口只声明了一个默认方法getSource, 用于获取配置源，配置源指的是元数据对应的源文件。
- BeanMetadataAttributeAccessor：该类继承了AttributeAccessorSupport 同时实现了BeanMetadataElement，使用一个名为source的变量保存配置源，实现了getSource，同时定义setSource用于设置配置源。
BeanDefinition：该接口同时继承了BeanMetadataElement 和 AttributeAccessor 接口，定义了与BeanDefinition相关的常量和操作。这里对定义的常量进行简要的介绍：
/** * 表示Bean的作用域为单例， 容器中只会存在一个实例 */ String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON; /** * 表示Bean的作用域为原型，容器中存在多个实例 */ String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE; /** * ROLE_APPLICATION 通常表示用户自定义的Bean */ int ROLE_APPLICATION = 0; /** * ROLE_SUPPORT 表示这个 Bean 是某些复杂配置的支撑部分 */ int ROLE_SUPPORT = 1; /** * ROLE_INFRASTRUCTURE 表示这个Bean是Spring基础设施的一部分 */ int ROLE_INFRASTRUCTURE = 2;BeanDefinition中定义的操作包括对parentName，beanClassName，scope, lazyInit, dependsOn, autowireCandite, primary, factoryBeanName, factoryMethodName, propertyValues, initMethodName, destroyMethodName, role, description, resourceDescription等属性的设置与获取。
AbstractBeanDefinition: 该抽象类实现了BeanDefinition同时继承了BeanMetadataAttributeAccessor，该抽象类定义了BeanDefinition的基础属性，如下所示：
/** * 默认的作用的域的名字 */ public static final String SCOPE_DEFAULT = ""; /** * Autowire 的几种模式 */ public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO; public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME; public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE; public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR; /** * 表示自动选择一种合适的Autowire模式 */ public static final int AUTOWIRE_AUTODETECT = AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT; /** * 表示不需要对依赖进行检查 */ public static final int DEPENDENCY_CHECK_NONE = 0; /** * 表示对引用进行依赖检查 */ public static final int DEPENDENCY_CHECK_OBJECTS = 1; /** * 表示对简单属性进行依赖检查 */ public static final int DEPENDENCY_CHECK_SIMPLE = 2; /** * 表示对所有的属性进行检查，包括对象的引用 */ public static final int DEPENDENCY_CHECK_ALL = 3; public static final String INFER_METHOD = "(inferred)"; @Nullable private volatile Object beanClass; @Nullable private String scope = SCOPE_DEFAULT; private boolean abstractFlag = false; @Nullable private Boolean lazyInit; private int autowireMode = AUTOWIRE_NO; private int dependencyCheck = DEPENDENCY_CHECK_NONE; @Nullable private String[] dependsOn; private boolean autowireCandidate = true; private boolean primary = false; private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<>(); @Nullable private Supplier<?> instanceSupplier; /** * 是否允许访问非公有的方法 private boolean nonPublicAccessAllowed = true; private boolean lenientConstructorResolution = true; @Nullable private String factoryBeanName; @Nullable private String factoryMethodName; @Nullable private ConstructorArgumentValues constructorArgumentValues; @Nullable private MutablePropertyValues propertyValues; private MethodOverrides methodOverrides = new MethodOverrides(); @Nullable private String initMethodName; @Nullable private String destroyMethodName; private boolean enforceInitMethod = true; private boolean enforceDestroyMethod = true; /** * 表示该Bean是不是合成的，即不是应用定义的，比如Spring的基础设施的Bean，或者自动代理得到的Bean。 */ private boolean synthetic = false; private int role = BeanDefinition.ROLE_APPLICATION; @Nullable private String description; @Nullable private Resource resource;- RootBeanDefinition: 该类继承了AbstractBeanDefinition， 在AbstractBeanDefinition的基础上增加一些属性和方法。该类可以既可以用于表示有继承关系的BeanDefinition，也可以用于无继承关系的BeanDefiniton。
- GenericBeanDefinition: 该类在AbstractBeanDefinition的基础上新增了parentName的属性。GenericBeanDefinition是标准bean定义的一站式服务。与任何bean定义一样，它允许指定类以及可选的构造函数参数值和属性值。此外，可以通过“parentName”属性灵活地配置从父bean定义派生。
- ChildBeanDefinition：该类同样是在AbstractBeanDefinition的基础上新增了parentName的属性。
以上就是整个继承体系涉及到的接口和类，可以看到BeanDefinition中包含的各种属性，也意味着我们可以通过xml或者注解的方式指定相应的属性。
我们可以通过Spring中的测试用例来看一下使用方法：
@Test
public void beanDefinitionEquality() {
RootBeanDefinition bd = new RootBeanDefinition(TestBean.class);
bd.setAbstract(true);
bd.setLazyInit(true);
bd.setScope("request");
RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class);
boolean condition1 = !bd.equals(otherBd);
assertThat(condition1).isTrue();
boolean condition = !otherBd.equals(bd);
assertThat(condition).isTrue();
otherBd.setAbstract(true);
otherBd.setLazyInit(true);
otherBd.setScope("request");
assertThat(bd.equals(otherBd)).isTrue();
assertThat(otherBd.equals(bd)).isTrue();
assertThat(bd.hashCode() == otherBd.hashCode()).isTrue();
}一旦我们有了BeanDefinition, 我们就可以通过BeanDefinition 初始化相应的Bean。
接下来我们以xml文件配置的方式来看一下具体的BeanDefiniton的加载过程。整个加载过程可以简单的分为两步：
- 加载xml文档，通过相应的Reader进行加载。
- 解析xml文档，通过相应的解析器进行解析，解析成BeanDeinition。
使用实例：
SimpleBeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();
Resource resource = new ClassPathResource("test.xml", getClass());
new XmlBeanDefinitionReader(registry).loadBeanDefinitions(resource);
testBeanDefinitions(registry);其中Registry,用于保存BeanDefinition, 然后通过Resource指定了资源文件，最后通过XmlBeanDefinitonReader读取并解析xml文件为BeanDefinition。
可以看到上面的代码中最重要的就是loadBeanDefinitions的方法。在看具体的实现细节之前我们同样先来看一下XmlBeanDefinitonReader相应的继承体系。
其中BeanDefinitionReader 定义了加载BeanDefinition的不同方式对应的方法。AbstractBeanDefinitionReader中定义了registry用于保存BeanDefiniton, resourceLoader用于资源的加载， beanClassLoader用于Class的记载， beanNameGenerator用于Bean名字的生成，同时实现了BeanDefinitionReader中的方法。XmlBeanDefinitonReader中定义了更多的属性，如下：
/**
* 默认的校验模式
*/
private int validationMode = VALIDATION_AUTO;
private boolean namespaceAware = false;
/**
* xml的文件读取器对应的Class，默认为DefaultBeanDefinitionDocumentReader.class
*/
private Class<? extends BeanDefinitionDocumentReader> documentReaderClass =
DefaultBeanDefinitionDocumentReader.class;
/**
* 用于报告解析过程中的问题， 默认为FailFastProblemReporter
*/
private ProblemReporter problemReporter = new FailFastProblemReporter();
/**
* 事件监听器，默认为EmptyReaderEventListener
*/
private ReaderEventListener eventListener = new EmptyReaderEventListener();
/**
* 用于提取Source， 默认为NullSourceExtractor
*/
private SourceExtractor sourceExtractor = new NullSourceExtractor();
/**
* 命名空间解析器
*/
@Nullable
private NamespaceHandlerResolver namespaceHandlerResolver;
/**
* 文档加载器，默认为DefaultDocumentLoader
*/
private DocumentLoader documentLoader = new DefaultDocumentLoader();
/**
* 实体解析器
*/
@Nullable
private EntityResolver entityResolver;
/**
* Sax错误处理器，默认为SimpleSaxErrorHandler
*/
private ErrorHandler errorHandler = new SimpleSaxErrorHandler(logger);
/**
* Xml文档校验模式检测器
*/
private final XmlValidationModeDetector validationModeDetector = new XmlValidationModeDetector();
/**
* 当前线程正在被加载的资源
*/
private final ThreadLocal<Set<EncodedResource>> resourcesCurrentlyBeingLoaded =
new NamedThreadLocal<Set<EncodedResource>>("XML bean definition resources currently being loaded"){
@Override
protected Set<EncodedResource> initialValue() {
return new HashSet<>(4);
}
};resourcesCurrentlyBeingLoaded 使用ThreadLocal用于保存当前线程正在加载的Reousrce,看完了XmlBeanDefinitonReader 的属性，我们对XmlBeanDefinitonReader的功能有了大致的认识，接下来看具体的实现细节。
@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
return loadBeanDefinitions(new EncodedResource(resource));
}
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
Assert.notNull(encodedResource, "EncodedResource must not be null");
if (logger.isTraceEnabled()) {
logger.trace("Loading XML bean definitions from " + encodedResource);
}
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
// 添加当前正在解析的资源
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
}
try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"IOException parsing XML document from " + encodedResource.getResource(), ex);
}
finally {
currentResources.remove(encodedResource);
if (currentResources.isEmpty()) {
this.resourcesCurrentlyBeingLoaded.remove();
}
}
}上述的方法先对Resource做了非空的一个判断，然后将Resource 添加到resourcesCurrentlyBeingLoaded 中去，表示正在加载，然后调用doLoadBeanDefinitions方法，最后清理将Resource从resourcesCurrentlyBeingLoaded移除，表示加载完成。
其中doLoadBeanDefinitions的定义如下：
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
// 加载资源文件
Document doc = doLoadDocument(inputSource, resource);
int count = registerBeanDefinitions(doc, resource);
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + count + " bean definitions from " + resource);
}
return count;
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (SAXParseException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
}
catch (SAXException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"XML document from " + resource + " is invalid", ex);
}
catch (ParserConfigurationException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Parser configuration exception parsing XML from " + resource, ex);
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"IOException parsing XML document from " + resource, ex);
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Unexpected exception parsing XML document from " + resource, ex);
}
}doLoadDocument()方法通过JAXP(JAXP是Java SE中的用来解析和操作XML的应用程序接口，解析XML文档的方法有很多，用得最多的是DOM和SAX。)对xml文件读取解析成Document对象，Document对象包含了xml文件中的各个元素，这里不对JAXP进行展开，只需要知道Document对象包含了xml文件中的各个元素即可。registerBeanDefinitions()方法会对Document对象再次解析成BeanDefintion并将BeanDefinition注册到Registry中，返回本次解析的BeanDefinition的数量。
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
// 创建BeanDefinitionDocumentReader，用于解析BeanDefinition
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
int countBefore = getRegistry().getBeanDefinitionCount();
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}registerBeanDefinitions 先创建了BeanDefinitionDocumentReader，然后通过BeanDefinitionDocumentReader去真正的解析和注册BeanDefiniton，这里传入了Document 和ReaderContext, 通过resource, problemReporter,eventListener,sourceExtractor,getNamespaceHandlerResolver去初始化XmlReaderContext。
/**
* Create the {@link XmlReaderContext} to pass over to the document reader.
*/
public XmlReaderContext createReaderContext(Resource resource) {
return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
this.sourceExtractor, this, getNamespaceHandlerResolver());
}接下来通过DefaultBeanDefinitionDocumentReader去解析和注册了。
@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
doRegisterBeanDefinitions(doc.getDocumentElement());
}
protected void doRegisterBeanDefinitions(Element root) {
// Any nested <beans> elements will cause recursion in this method. In
// order to propagate and preserve <beans> default-* attributes correctly,
// keep track of the current (parent) delegate, which may be null. Create
// the new (child) delegate with a reference to the parent for fallback purposes,
// then ultimately reset this.delegate back to its original (parent) reference.
// this behavior emulates a stack of delegates without actually necessitating one.
BeanDefinitionParserDelegate parent = this.delegate;
// delegate 初始化根结点的属性值，作为子元素的默认值
this.delegate = createDelegate(getReaderContext(), root, parent);
// 判断根结点是否有namespace 的属性
if (this.delegate.isDefaultNamespace(root)) {
// 查询是否有profile的属性，如果当前的profile与当前的环境不匹配，则跳过
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
if (StringUtils.hasText(profileSpec)) {
String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
// We cannot use Profiles.of(...) since profile expressions are not supported
// in XML config. See SPR-12458 for details.
if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
if (logger.isDebugEnabled()) {
logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
"] not matching: " + getReaderContext().getResource());
}
return;
}
}
}
// 前置处理
preProcessXml(root);
// 解析BeanDefinitions
parseBeanDefinitions(root, this.delegate);
// 后置处理
postProcessXml(root);
this.delegate = parent;
}先保存旧的BeanDefinitionParserDelegate，在解析完完成之后再换回去，因为可能含有嵌套的beans元素。
上面的代码中第一步通过createDelegate创建了BeanDefinitionParserDelegate对象,BeanDefinitionParserDelegate对象中有一个DocumentDefaultsDefinition类型的defaults属性用于保存Bean的默认设置，这些默认的配置包括：
@Nullable
private String lazyInit;
@Nullable
private String merge;
@Nullable
private String autowire;
@Nullable
private String autowireCandidates;
@Nullable
private String initMethod;
@Nullable
private String destroyMethod;
@Nullable继续看createDelegate的实现，可以看到如果上述的设置是默认值，先判断有没有parentDefaults， 如果有就使用parentDefaults的值，否则使用默认的，如果不是默认值，则使用指定的值。这里初始化的默认值会在后续解析子元素的时候会用到。
protected BeanDefinitionParserDelegate createDelegate(
XmlReaderContext readerContext, Element root, @Nullable BeanDefinitionParserDelegate parentDelegate) {
BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
delegate.initDefaults(root, parentDelegate);
return delegate;
}
public void initDefaults(Element root, @Nullable BeanDefinitionParserDelegate parent) {
populateDefaults(this.defaults, (parent != null ? parent.defaults : null), root);
this.readerContext.fireDefaultsRegistered(this.defaults);
}
protected void populateDefaults(DocumentDefaultsDefinition defaults, @Nullable DocumentDefaultsDefinition parentDefaults, Element root) {
String lazyInit = root.getAttribute(DEFAULT_LAZY_INIT_ATTRIBUTE);
if (isDefaultValue(lazyInit)) {
// Potentially inherited from outer <beans> sections, otherwise falling back to false.
lazyInit = (parentDefaults != null ? parentDefaults.getLazyInit() : FALSE_VALUE);
}
defaults.setLazyInit(lazyInit);
String merge = root.getAttribute(DEFAULT_MERGE_ATTRIBUTE);
if (isDefaultValue(merge)) {
// Potentially inherited from outer <beans> sections, otherwise falling back to false.
merge = (parentDefaults != null ? parentDefaults.getMerge() : FALSE_VALUE);
}
defaults.setMerge(merge);
String autowire = root.getAttribute(DEFAULT_AUTOWIRE_ATTRIBUTE);
if (isDefaultValue(autowire)) {
// Potentially inherited from outer <beans> sections, otherwise falling back to 'no'.
autowire = (parentDefaults != null ? parentDefaults.getAutowire() : AUTOWIRE_NO_VALUE);
}
defaults.setAutowire(autowire);
if (root.hasAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE)) {
defaults.setAutowireCandidates(root.getAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE));
}
else if (parentDefaults != null) {
defaults.setAutowireCandidates(parentDefaults.getAutowireCandidates());
}
if (root.hasAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE)) {
defaults.setInitMethod(root.getAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE));
}
else if (parentDefaults != null) {
defaults.setInitMethod(parentDefaults.getInitMethod());
}
if (root.hasAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE)) {
defaults.setDestroyMethod(root.getAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE));
}
else if (parentDefaults != null) {
defaults.setDestroyMethod(parentDefaults.getDestroyMethod());
}
defaults.setSource(this.readerContext.extractSource(root));
}回到前面的代码，初始化BeanDefinitionParserDelegate之后就先判断根结点是不是默认的命名空间，即namespace 是否为空，是否为“http://www.springframework.or...”， 如果是默认的namespace url, 则继续判断是否有profile 属性， 如果有的话，会判断当前的environment是否于profile 相匹配，不匹配则直接返回。
接下来是对Document的前置处理preProcessXml(), 解析parseBeanDefinitions(), 以及后置处理postProcessXml()。对于DefaultBeanDefinitionDocumentReader 而言，其preProcessXml()和postProcessXml()的实现为空，继续看parseBeanDefinitions()。
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
// 如果是默认的命名空间，即没有指定namespace 或者位默认值http://www.springframework.org/schema/beans
parseDefaultElement(ele, delegate);
}
else {
// 否则对自定义元素进行解析
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}可以看到在解析root下的各个element的试试，依旧会判断是否是默认的namespace, 如果是则使用delegate进行解析，否则使用namespace 对应的handler进行解析，自定义的namespace和handler之间的映射可以在spring.handlers中指定。假设是默认的namespace，继续往下看。
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
// 如果是import 元素
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
// 如果是alias 元素
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
// 如果是bean元素
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
// 如果是嵌套的beans 元素
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}上面的代码对element的类型进行判断，不同的类型对应不同的解析方式，也可以看到如果当前解析的元素是beans，即是一个嵌套的beans,则递归调用doRegisterBeanDefinitions， 这也是为什么前面要保存旧的BeanDefinitionParserDelegate，然后创建新的，使用完之后在替换回去的原因，因为存在嵌套的beans元素。
同样我们也以bean元素的解析为例继续往下看。
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 解析bean元素
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// 根据是否有自定义的namspace判断是否需要对已有的元素或者属性进行装饰
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
// 注册BeanDefinition,即保存注册BeanDefinition到beanDefinitionMap, 保存beanName到 beanDefinitionName， 以及alias到aliasMap中
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}这里使用了delegate.parseBeanDefinitionElement()对元素进行解析，解析完成之后得到一个基本的BeanDefinition保存到BeanDefinitionHolder中去，之后会根据bean元素的对应的属性是否有namespace来选择是否对BeanDefinition进行装饰，即对bean元素的属性使用namespace对应的handler进行处理。最后就是注册BeanDefinition了。
接下来分别看一下parseBeanDefinitionElement的实现和registerBeanDefinition的实现。
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
return parseBeanDefinitionElement(ele, null);
}
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
String id = ele.getAttribute(ID_ATTRIBUTE);
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
List<String> aliases = new ArrayList<>();
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
// 如果没有id， 则使用alias的第一个元素作为beanName
beanName = aliases.remove(0);
if (logger.isTraceEnabled()) {
logger.trace("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
if (containingBean == null) {
// 检查beanName 和 alias的唯一性
checkNameUniqueness(beanName, aliases, ele);
}
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
if (!StringUtils.hasText(beanName)) {
// 如果没有定义id和name，则生成一个
try {
if (containingBean != null) {
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
}
else {
beanName = this.readerContext.generateBeanName(beanDefinition);
// Register an alias for the plain bean class name, if still possible,
// if the generator returned the class name plus a suffix.
// This is expected for Spring 1.2/2.0 backwards compatibility.
String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null &&
beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
aliases.add(beanClassName);
}
}
if (logger.isTraceEnabled()) {
logger.trace("Neither XML 'id' nor 'name' specified - " +
"using generated bean name [" + beanName + "]");
}
}
catch (Exception ex) {
error(ex.getMessage(), ele);
return null;
}
}
String[] aliasesArray = StringUtils.toStringArray(aliases);
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}解析的过程就是根据xml的定义将相应的属性解析为BeanDefintion的属性，首先解析了id和name, 如果没有id，则使用第一个name作为beanName, 并校验beanName的唯一性。继续通过parseBeanDefinitionElement()进行解析。
@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
try {
// 创建一个GenericBeanDefinition， 设置beanName, parent（如果parent元素不为空）, beanClass(如果readerContex的classLoader不为空)
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
// 解析BeanDefinition的属性，包括scope, factory-bean, factory-method, init-method, destroy-method, lazy-init等
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
// 解析meta 子元素
parseMetaElements(ele, bd);
// 解析lookup-method 子元素
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
// 解析lookup-replace 子元素
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
// 解析constructor-arg 子元素
parseConstructorArgElements(ele, bd);
// 解析property 子元素
parsePropertyElements(ele, bd);
// 解析qualifier 子元素
parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
return bd;
}
catch (ClassNotFoundException ex) {
error("Bean class [" + className + "] not found", ele, ex);
}
catch (NoClassDefFoundError err) {
error("Class that bean class [" + className + "] depends on not found", ele, err);
}
catch (Throwable ex) {
error("Unexpected failure during bean definition parsing", ele, ex);
}
finally {
this.parseState.pop();
}
return null;
}上述的方法就是具体的属性的解析了，具体的解析步骤如下：
- 先创建了一个GenericBeanDefinition，设置了beanName, parentName和beanClassName,如果有classLoader的话，生成beanClass。然后
- 解析BeanDefinition的属性，包括scope, factory-bean, factory-method, init-method, destroy-method, lazy-init，descrition等。
- 解析meta 子元素。
- 解析lookup-method 子元素。
- 解析lookup-replace 子元素。
- 解析constructor-arg 子元素。
- 解析property 子元素。
- 解析qualifier 子元素。
- 设置 source 和 resource。
上述的解析都完成之后，使用BeanDefinitionHolder 保存BeanDefinition, beanName， alias。 一个bean元素的解析到这里就完成了，然后对BeanDefintion进行注册，说简单点就是保存beanName到BeanDefinition的映射,以及beanName 和 alias之间的映射。
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "'beanName' must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
this.beanDefinitionMap.put(beanName, beanDefinition);
}到这里BeanDefinition的加载就完成了。
最后总结一下整个Xml文件的BeanDefinition的加载过程。
- 指定Xml文件，封装成Resource。
- 保存当前正在加载的Resource到resourcesCurrentlyBeingLoaded中。
- 使用JAXP 加载 Xml文件，得到Xml文件对应的Document对象。
- 根据XmlBeanDefiniton中的documentReaderClass实例化BeanDefinitionDocumentReader对象。
通过BeanDefinitionDocumentReader的registerBeanDefinitions()方法解析和注册BeanDefinition。
- 创建BeanDefinitionParserDelegate对象，初始化默认的属性设置。
- 判断当前Environment与profile是否匹配。
- 前置处理
解析
- 根据跟节点的namespace决定解析的方式。
- 遍历根节点的子元素，对各个子元素进行解析。
- 根据子元素的类型选择不同的解析方式。
- 将解析得到BeanDefinition注册到Registry中去
- 后置处理
- 返回本次解析的BeanDefinition的数量。
- 将Resource从resourcesCurrentlyBeingLoaded中移除。
总结
看完了Xml方式的BeanDefinition的解析过程，其实也可以猜测基于注解的BeanDefinition的解析过程大致也差不多，唯一不同就是Xml的方式BeanDefinitionDocumentReader去解析Document对象，而基于注解的方式则需要AnnotatedBeanDefinitionReader去解析相应的注解。两种方式最终的目的都是得到BeanDefinition用于后续的容器初始化。
Tips
- 看Spring的源码时，可以先看相应继承体系以及类的属性，更有利于了解相应的功能。
- 结合Spring的测试用例进行debug，也是学习Spring源码的一种方式。
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。