BeanDefinition的加载过程

BeanDefiniton的介绍

Spring容器的启动过程大致可以分为两步:

  1. BeanDefinition 的加载。
  2. 容器的初始化。

我们知道使用Spring之前我们需要先定义Bean, 一般有两种方式定义,分别是xml和注解,两种方式的大同小异,都需要先将Bean的定义转化为BeanDefinition, BeanDefinition 包含了初始化该Bean所需要的信息,可以认为BeanDefinition 是Bean的一种描述,一种定义。 BeanDefinition 是Spring中重要的一个结构,后续的容器中实例的初始化依赖于BeanDefinition。

具体的加载过程

本文以xml为例来说明BeanDefinition的加载过程。
我们首先来看BeanDefinition的继承体系。
BeanDefinition的加载过程_第1张图片
以上是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 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的加载过程。整个加载过程可以简单的分为两步:

  1. 加载xml文档,通过相应的Reader进行加载。
  2. 解析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相应的继承体系。
BeanDefinition的加载过程_第2张图片
其中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 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> resourcesCurrentlyBeingLoaded =
            new NamedThreadLocal>("XML bean definition resources currently being loaded"){
                @Override
                protected Set 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 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  elements will cause recursion in this method. In
     // order to propagate and preserve  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  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  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  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 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;
}

上述的方法就是具体的属性的解析了,具体的解析步骤如下:

  1. 先创建了一个GenericBeanDefinition,设置了beanName, parentName和beanClassName,如果有classLoader的话,生成beanClass。然后
  2. 解析BeanDefinition的属性,包括scope, factory-bean, factory-method, init-method, destroy-method, lazy-init,descrition等。
  3. 解析meta 子元素。
  4. 解析lookup-method 子元素。
  5. 解析lookup-replace 子元素。
  6. 解析constructor-arg 子元素。
  7. 解析property 子元素。
  8. 解析qualifier 子元素。
  9. 设置 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的加载过程。

  1. 指定Xml文件,封装成Resource。
  2. 保存当前正在加载的Resource到resourcesCurrentlyBeingLoaded中。
  3. 使用JAXP 加载 Xml文件,得到Xml文件对应的Document对象。
  4. 根据XmlBeanDefiniton中的documentReaderClass实例化BeanDefinitionDocumentReader对象。
  5. 通过BeanDefinitionDocumentReader的registerBeanDefinitions()方法解析和注册BeanDefinition。

    1. 创建BeanDefinitionParserDelegate对象,初始化默认的属性设置。
    2. 判断当前Environment与profile是否匹配。
    3. 前置处理
    4. 解析

      1. 根据跟节点的namespace决定解析的方式。
      2. 遍历根节点的子元素,对各个子元素进行解析。
      3. 根据子元素的类型选择不同的解析方式。
      4. 将解析得到BeanDefinition注册到Registry中去
    5. 后置处理
  6. 返回本次解析的BeanDefinition的数量。
  7. 将Resource从resourcesCurrentlyBeingLoaded中移除。

总结

看完了Xml方式的BeanDefinition的解析过程,其实也可以猜测基于注解的BeanDefinition的解析过程大致也差不多,唯一不同就是Xml的方式BeanDefinitionDocumentReader去解析Document对象,而基于注解的方式则需要AnnotatedBeanDefinitionReader去解析相应的注解。两种方式最终的目的都是得到BeanDefinition用于后续的容器初始化。

Tips

  1. 看Spring的源码时,可以先看相应继承体系以及类的属性,更有利于了解相应的功能。
  2. 结合Spring的测试用例进行debug,也是学习Spring源码的一种方式。

你可能感兴趣的