【Spring源码--IOC容器的实现】（三）BeanDefinition的载入和解析【I】

前言

对于IOC容器而言，BeanDefinition的载入过程，相当于把定义的BeanDefinition在IOC容器中转换成一个Spring内部表示的数据机构的过程。简单说，就是把Spring配置文件中的bean的定义转成Spring的内部数据结构。上一篇博客已经描述了Spring如何通过web.xml的配置读取配置路径，通过Resource接口读取配置文件。简单回忆一下上一篇博客的代码顺序。借用上个博客的一张图来看下代码的顺序：

BeanDefinition的载入和解析

我们接着上一篇的代码，在AbstractBeanDefinitionReader的loadBeanDefinitions方法中，我们定位到了Resource[]，看下简略代码： 代码1.1：AbstractBeanDefinitionReader的loadBeanDefinitions方法 public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException { ... if (resourceLoader instanceof ResourcePatternResolver) { Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location); int loadCount = loadBeanDefinitions(resources); ... }else { Resource resource = resourceLoader.getResource(location); int loadCount = loadBeanDefinitions(resource); ... }}

将xml文件转换成DOM对象

通过getResource()方法得到Resource之后，那么就开始了真正加载Bean资源。因为Spring可以对应不同形式的BeanDefinition，我们这里讲的是xml的形式，所以就需要到XmlBeanDefinitionReader的实现中去看源码。 代码1.2：XmlBeanDefinitionReader的loadBeanDefinitions及doLoadBeanDefinitions方法 //该方法-->调用入口public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException { return loadBeanDefinitions(new EncodedResource(resource));}//该方法-->载入xml形式的BeanDefinition的地方public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException { Assert.notNull(encodedResource, "EncodedResource must not be null"); if (logger.isInfoEnabled()) { logger.info("Loading XML bean definitions from " + encodedResource.getResource()); } //这里是获取线程局部变量 Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get(); if (currentResources == null) { currentResources = new HashSet<EncodedResource>(4); this.resourcesCurrentlyBeingLoaded.set(currentResources); } if (!currentResources.add(encodedResource)) { throw new BeanDefinitionStoreException( "Detected cyclic loading of " + encodedResource + " - check your import definitions!"); } try { //将资源文件转换为IO输入流 InputStream inputStream = encodedResource.getResource().getInputStream(); try { InputSource inputSource = new InputSource(inputStream); if (encodedResource.getEncoding() != null) { inputSource.setEncoding(encodedResource.getEncoding()); } //具体读取过程的方法 return doLoadBeanDefinitions(inputSource, encodedResource.getResource()); } finally { inputStream.close(); } } catch (IOException ex) { throw new BeanDefinitionStoreException( "IOException parsing XML document from " + encodedResource.getResource(), ex); } finally { currentResources.remove(encodedResource); if (currentResources.isEmpty()) { this.resourcesCurrentlyBeingLoaded.remove(); } } } //该方法-->从特定XML文件中实际载入Bean定义资源 protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException { try { int validationMode = getValidationModeForResource(resource); //将XML文件转换为DOM对象，解析过程由documentLoader实现 Document doc = this.documentLoader.loadDocument( inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware()); //这里是启动对Bean定义解析的详细过程，该解析过程会用到Spring的Bean配置规则【下文详解】 return registerBeanDefinitions(doc, resource); } ..... }

上面的过程完成了两个动作：(1)资源文件转换成IO输入流;(2)将xml文件转换成DOM对象。至于解析xml文件的方法，里面是通过创建解析工厂，设置xml解析校检，通过工厂创建解析器，然后parse(),所以这个过程我们就不再看了。

按照Spring的Bean规则对Document对象进行解析

走主线：得到dom对象后，开始启动对bean定义的详细解析。来看registerBeanDefinitions方法。 代码1.3：XmlBeanDefinitionReader的loadBeanDefinitions方法 public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { //得到BeanDefinitionDocumentReader来对xml格式的BeanDefinition解析 BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();、 //获得容器中注册的Bean数量 int countBefore = getRegistry().getBeanDefinitionCount(); //解析过程入口，BeanDefinitionDocumentReader只是个接口，具体的解析实现过程有实现类DefaultBeanDefinitionDocumentReader完成 documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); //统计解析的Bean数量 return getRegistry().getBeanDefinitionCount() - countBefore; }

我觉得看到这里，是个正常人都会想骂人了，搞这么复杂这么饶人，真TM恶心。不过话说回来，我们作为一个学习者，都知道别人是优秀的，这么设计肯定有很多的道理。讲真，我看IOC源码N遍了，有些地方还是不能理解。废话少说，因为马上就要进入真正解析的地方了，我们稍微总结下上面那么多的饶人的代码。其实就2个核心思想：（1）首先，通过调用XML解析器将Bean定义资源文件转换得到Document对象，但是这些Document对象并没有按照Spring的Bean规则进行解析。这一步是载入的过程。（2）其次，在完成通用的XML解析之后，按照Spring的Bean规则对Document对象进行解析。按照Spring的Bean规则对Document对象解析的过程是在接口BeanDefinitionDocumentReader的实现类DefaultBeanDefinitionDocumentReader中实现的。OK,重点来了。（友情提示，会绕好几个方法。）

代码1.4：DefaultBeanDefinitionDocumentReader的registerBeanDefinitions及parseBeanDefinitions方法

//该方法--根据Spring DTD对Bean的定义规则解析Bean定义Document对象public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) { this.readerContext = readerContext; logger.debug("Loading bean definitions"); //获取根元素 Element root = doc.getDocumentElement(); //具体的解析过程由BeanDefinitionParserDelegate实现，BeanDefinitionParserDelegate中定义了Spring Bean定义XML文件的各种元素 (Delegate:代表、委派的意思) BeanDefinitionParserDelegate delegate = createHelper(readerContext, root); preProcessXml(root); //从Document的根元素开始进行Bean定义的Document对象 parseBeanDefinitions(root, delegate); postProcessXml(root); } //该方法--使用Spring的Bean规则从Document的根元素开始进行Bean定义的Document对象 protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { //如果使用了Spring默认的XML命名空间 if (delegate.isDefaultNamespace(root)) { //遍历根元素的所有子节点 NodeList nl = root.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); //如果该节点是XML元素节点 if (node instanceof Element) { Element ele = (Element) node; //如果该节点使用的是Spring默认的XML命名空间 if (delegate.isDefaultNamespace(ele)) { //使用Spring的Bean规则解析元素节点 parseDefaultElement(ele, delegate); } else { //没有使用Spring默认的XML命名空间，则使用用户自定义的解析规则解析元素节点 //（如：自定义的xsd等） delegate.parseCustomElement(ele); } } } } else { //Document的根节点没有使用Spring默认的命名空间，则使用用户自定义的解析规则解析Document根节点 delegate.parseCustomElement(root); } }

上面这段代码又墨迹了一会，这里主要是看节点元素是否是Spring的规范，因为它允许我们自定义解析规范，那么正常我们是利用Spring的规则，所以我们来看parseDefaultElement(ele, delegate)方法。

代码1.5：DefaultBeanDefinitionDocumentReader的parseDefaultElement方法

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>元素，按照Spring的Bean规则解析元素 else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { processBeanDefinition(ele, delegate); } }

不知道大家看到这里是不是有种释放的感觉，终于TM的看到了自己熟悉的一点东西了。

Bean资源的解析

OK,下面的东西大家会更熟悉，我们主要看对Bean的解析。

代码1.6：DefaultBeanDefinitionDocumentReader的processBeanDefinition方法

//解析bean资源 protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { //BeanDefinitionHolder是对BeanDefinition的封装，包括BeanDefinition，beanName,aliases //对Document对象中<Bean>元素的解析由BeanDefinitionParserDelegate实现 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); if (bdHolder != null) { bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); try { //向Spring IoC容器注册解析得到的Bean定义， //这是Bean定义向IoC容器注册的入口 ，实际上是放到一个Map里面 【后面再看】 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)); } }

processBeanDefinition方法又引入了BeanDefinitionHolder的概念，注释上我也写了，是一个封装类。因为BeanDefinition是完完整整的Bean定义的解析，holder加了beanName相当于一个key。我们也看到了register方法，这个我们后续再单独讲下，下面进入parseBeanDefinitionElement具体解析Bean定义的地方。：

代码1.7：BeanDefinitionParserDelegate的parseBeanDefinitionElement方法

//该方法--diaoy 入口 public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) { return parseBeanDefinitionElement(ele, null); } //该方法--解析Bean定义资源文件中的<Bean>元素，这个方法中主要处理<Bean>元素的id，name和别名属性 public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) { String id = ele.getAttribute(ID_ATTRIBUTE);//id String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);//name List<String> aliases = new ArrayList<String>();//aliase if (StringUtils.hasLength(nameAttr)) { String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, BEAN_NAME_DELIMITERS); aliases.addAll(Arrays.asList(nameArr)); } String beanName = id; //如果<Bean>元素中没有配置id属性时，将别名中的第一个值赋值给beanName if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) { beanName = aliases.remove(0); if (logger.isDebugEnabled()) { logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases"); } } //检查<Bean>元素所配置的id或者name的唯一性，containingBean标识<Bean>元素中是否包含子<Bean>元素 if (containingBean == null) { checkNameUniqueness(beanName, aliases, ele); } //详细对<Bean>元素中配置的Bean定义进行解析的地方【property,description,parent等】 AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); if (beanDefinition != null) { if (!StringUtils.hasText(beanName)) { try { if (containingBean != null) { //如果<Bean>元素中没有配置id、别名或者name，且没有包含子 //<Bean>元素，为解析的Bean生成一个唯一beanName并注册 beanName = BeanDefinitionReaderUtils.generateBeanName( beanDefinition, this.readerContext.getRegistry(), true); } else { beanName = this.readerContext.generateBeanName(beanDefinition); //如果<Bean>元素中没有配置id、别名或者name，但包含了子 //<Bean>元素，为解析的Bean使用别名向IoC容器注册 String beanClassName = beanDefinition.getBeanClassName(); //为解析的Bean使用别名注册时，为了向后兼容Spring1.2/2.0，给别名添加类名后缀 if (beanClassName != null && beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() && !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) { aliases.add(beanClassName); } } if (logger.isDebugEnabled()) { logger.debug("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; }

看到这里大家是不是心里舒服多了，我们看到这里还没有对bean进行完整的解析，具体的参数配置在parseBeanDefinitionElement方法中，我们继续看下对参数的解析。

代码1.8：BeanDefinitionParserDelegate的parseBeanDefinitionElement方法

public AbstractBeanDefinition parseBeanDefinitionElement( Element ele, String beanName, BeanDefinition containingBean) { //记录解析的<Bean this.parseState.push(new BeanEntry(beanName)); //这里只读取<Bean>元素中配置的class名字，然后载入到BeanDefinition中去 //只是记录配置的class名字，并不做实例化，对象的实例化在依赖注入时完成 String className = null; //如果<Bean>元素中配置了parent属性，则获取parent属性的值 if (ele.hasAttribute(CLASS_ATTRIBUTE)) { className = ele.getAttribute(CLASS_ATTRIBUTE).trim(); } try { String parent = null; if (ele.hasAttribute(PARENT_ATTRIBUTE)) { parent = ele.getAttribute(PARENT_ATTRIBUTE); } //根据<Bean>元素配置的class名称和parent属性值创建BeanDefinition AbstractBeanDefinition bd = createBeanDefinition(className, parent); //对<Bean>元素的不同的属性解析【不再写注释了，代码很清晰】 parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT)); parseMetaElements(ele, bd); parseLookupOverrideSubElements(ele, bd.getMethodOverrides()); parseReplacedMethodSubElements(ele, bd.getMethodOverrides()); parseConstructorArgElements(ele, bd); parsePropertyElements(ele, bd); 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; }

只要使用过Spring，对Spring配置文件比较熟悉的人，通过对上述源码的分析，就会明白我们在Spring配置文件中<Bean>元素的中配置的属性就是通过该方法解析和设置到Bean中去的。 注意：在解析<Bean>元素过程中没有创建和实例化Bean对象，只是创建了Bean对象的定义类BeanDefinition，将<Bean>元素中的配置信息设置到BeanDefinition中作为记录，当依赖注入时才使用这些记录信息创建和实例化具体的Bean对象。 上面方法中一些对一些配置如元信息(meta)、qualifier等的解析，我们在Spring中配置时使用的也不多，我们在使用Spring的<Bean>元素时，配置最多的是<property>属性。那么我们其实是有必要了解这些属性如何配置的，文章太长了，下一篇文章再说吧。