Spring（6）-Spring怎么从xml里面去解析bean的
1、给ClassPathXmlApplicationContext设置xml路径
2、refresh内部的BeanFactory，其实这时候BeanFactory都没创建，会先创DefaultListableBeanFactory
3、ClassPathXmlApplication会调用内部的loadBeanDefinitions，将新建的DefaultListableBeanFactory当做参数传进去。
4、ClassPathXmlApplicationContext内部会持有一个XmlBeanDefinitionReader，且内部是持有DefaultListableBeanFactory的，这时候就简单了，XmlBeanDefinitionReader
负责去解析BeanDefinition，丢给DefaultListableBeanFactory注册进去完事了
5、第四步完事之后，DefaultListableBeanFactory里面是一个业务Bean都没有，只有一堆BeanDefinition，后面ClassPathXmlApplicationContext直接去实例化那些需要在
启动过程中实例化的Bean。
6、后续还有BeanDefnitionPostProcessor,BeanPostProcessor，后置处理器对BeanFactory的处理等。
------------------------------------------
这里主要说第四步，怎么解析Xml文件的，它的过程代码是怎么样的
入口代码:
org.springframework.context.support.AbstractRefreshableApplicationContext @Override protected final void refreshBeanFactory() throws BeansException { if (hasBeanFactory()) { destroyBeans(); closeBeanFactory(); } try { //创建一个DefaultListableBeanFactory DefaultListableBeanFactory beanFactory = createBeanFactory(); beanFactory.setSerializationId(getId()); customizeBeanFactory(beanFactory); // 加载 loadBeanDefinitions(beanFactory); this.beanFactory = beanFactory; } catch (IOException ex) { throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex); } }
上面调用了org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions
@Override protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { // Create a new XmlBeanDefinitionReader for the given BeanFactory. //创建一个从xml读取beanDefinition的读取器 XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); // Configure the bean definition reader with this context's // resource loading environment. //配置环境 beanDefinitionReader.setEnvironment(this.getEnvironment()); //配置资源loader，一般就是classpath下去获取xml beanDefinitionReader.setResourceLoader(this); //xml解析的解析器 beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); // Allow a subclass to provide custom initialization of the reader, // then proceed with actually loading the bean definitions. initBeanDefinitionReader(beanDefinitionReader); //核心方法，使用beanDefinitionReader，并将解析后的bean definition放到beanFactory loadBeanDefinitions(beanDefinitionReader); }
xml中的xsd、dtd解析器
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
这个类的接口就是JDK里面的 org.xml.sax.EntityResolver,这个接口只有一个方法，就是负责xml里，外部实体的解析
public abstract InputSource resolveEntity (String publicId, String systemId) throws SAXException, IOException;
看看实现类org.springframework.beans.factory.xml.DelegatingEntityResolver
public class DelegatingEntityResolver implements EntityResolver { /** Suffix for DTD files. */ public static final String DTD_SUFFIX = ".dtd"; /** Suffix for schema definition files. */ public static final String XSD_SUFFIX = ".xsd"; private final EntityResolver dtdResolver; private final EntityResolver schemaResolver; /** * // 主要看这里，感觉就是对我们xml里面的那堆xsd进行解析 * @param publicId * @param systemId * @return * @throws SAXException * @throws IOException */ @Override @Nullable public InputSource resolveEntity(@Nullable String publicId, @Nullable String systemId) throws SAXException, IOException { if (systemId != null) { //以dtd结尾，用dtd解析器 if (systemId.endsWith(DTD_SUFFIX)) { return this.dtdResolver.resolveEntity(publicId, systemId); } //xsd结尾，用xsd解析器,对xml里面那堆xsd进行解析 else if (systemId.endsWith(XSD_SUFFIX)) { return this.schemaResolver.resolveEntity(publicId, systemId); } } // Fall back to the parser's default behavior. return null; } }
上线的代码，就是解析xml里面的xsd文件
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
上面的xmlns应该就是namespaceUri，根据这个去init初始化handler
下面的.xsd文件，就是用EntityResovler的实现类去进行解析xml的规则把
解析获取这里的xsd文件，方便进行语法校验的，这个xml也不能乱写，比如根元素就只有一个，下图是beans.xsd的代码预览
再看看，XmlBeanDefinitionReader是怎么解析xml的
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException { Resource[] configResources = getConfigResources(); if (configResources != null) { reader.loadBeanDefinitions(configResources); } String[] configLocations = getConfigLocations(); //这个方法还在：AbstractXmlApplicationContext，获取资源位置，传给XmlBeanDefinitionReader if (configLocations != null) { reader.loadBeanDefinitions(configLocations); } }
经过几个简单的跳转，进入
org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions
public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException { ResourceLoader resourceLoader = getResourceLoader(); if (resourceLoader == null) { throw new BeanDefinitionStoreException( "Cannot load bean definitions from location [" + location + "]: no ResourceLoader available"); } if (resourceLoader instanceof ResourcePatternResolver) { // Resource pattern matching available. try { Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location); int count = loadBeanDefinitions(resources); if (actualResources != null) { Collections.addAll(actualResources, resources); } if (logger.isTraceEnabled()) { logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]"); } return count; } catch (IOException ex) { throw new BeanDefinitionStoreException( "Could not resolve bean definition resource pattern [" + location + "]", ex); } } else { // Can only load single resources by absolute URL. Resource resource = resourceLoader.getResource(location); int count = loadBeanDefinitions(resource); if (actualResources != null) { actualResources.add(resource); } if (logger.isTraceEnabled()) { logger.trace("Loaded " + count + " bean definitions from location [" + location + "]"); } return count; } }
看看XmlBeanDefinitionReader的类图，
这里又是模板方法设计模式，把具体的流程放在AbstractBeanDefinitionReader里面，具体的实现，交给子类实现。我们这里看看BeanDefinitionReader的代码
public interface BeanDefinitionReader { /** * 获取beanDefinition的注册中心， * 为什么需要这个，因为读取到Bean definition后，需要存到这个里面去； * 如果不提供这个，我读了在哪放 */ BeanDefinitionRegistry getRegistry(); /** * 获取资源加载器 * 加载xml之类，当然作为一个接口，资源是可以来自于任何地方 */ @Nullable ResourceLoader getResourceLoader(); /** * 获取classloader */ @Nullable ClassLoader getBeanClassLoader(); /** * 获取bean名称生成器 */ BeanNameGenerator getBeanNameGenerator(); /** * 从指定的资源，加载bean definition * 从资源load bean definition */ int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException; /** * 重载 */ int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException; /** * 重载 */ int loadBeanDefinitions(String location) throws BeanDefinitionStoreException; /** * 重载 */ int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException; }
AbstractBeanDefinitionReader实现了大部分方法，但是除了这个
int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
这个只是个抽象类，不负责干活，从哪个Resource里面去读取也该交给子类去实现，
比如我们这里的XmlBeanDefinitionReader就是从xml里面去读取的，还有PorpertiesBeanDefinitionReader，还有自定义的JsonBeanDefinitionReader是吧，等等
都是AbstractBeanDefinitonReader的子类。
读取Xml文件为InputSource
org.springframework.beans.factory.xml.XmlBeanDefinitionReader#loadBeanDefinitions
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!"); } // 读取xml文件为文件流 try (InputStream inputStream = encodedResource.getResource().getInputStream()) { //读取为xml资源，InputSource这个类不属于spring，org.xml.sax.InputSource InputSource inputSource = new InputSource(inputStream); if (encodedResource.getEncoding() != null) { inputSource.setEncoding(encodedResource.getEncoding()); } // 解析bean definition去 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(); } } }
这里的InputSource的全路径也是jdk里面的类，org.xml.sax.InputSource.
继续
* 1、获取对xml文件的验证模式 * 2、加载xml文件，并得到对应的Document * 3、根据返回的Document注册Bean信息 */ protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException { try { //初步的解析，是基于xsd，dtd，进行语法检查 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); } }
BeanDefinitionDocumentReader
* 又把读取工作交给BeanDefinitionDocumentReader */ public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader(); int countBefore = getRegistry().getBeanDefinitionCount(); // 这里，调用createReaderContext(resource)创建上下文 documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); return getRegistry().getBeanDefinitionCount() - countBefore; }
这个接口里面有一个抽象方法
public interface BeanDefinitionDocumentReader { /** * * 核心读取方法 */ void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) throws BeanDefinitionStoreException; }
两个参数，Document我们理解就是xml，XmlReaderContext 看起来就是一个大杂烩，把需要的都放在里面
public class XmlReaderContext extends ReaderContext { // 之前的核心类，把自己传进来了 private final XmlBeanDefinitionReader reader; // org.springframework.beans.factory.xml.NamespaceHandlerResolver，这个也是核心类！ private final NamespaceHandlerResolver namespaceHandlerResolver; } public class ReaderContext { //xml资源本身 private final Resource resource; //盲猜是中间处理报错后，报告问题 private final ProblemReporter problemReporter; // event/listener机制吧，方便扩展 private final ReaderEventListener eventListener; // 跳过 private final SourceExtractor sourceExtractor; }
看完这个上下文的定义，你可以知道，XmlBeanDefinitionReader是作为一个参数，传进来的。
这个参数是怎么构造的呢？看看前面的代码
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader(); int countBefore = getRegistry().getBeanDefinitionCount(); // 这里，调用createReaderContext(resource)创建上下文 documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); return getRegistry().getBeanDefinitionCount() - countBefore; }
public XmlReaderContext createReaderContext(Resource resource) { return new XmlReaderContext(resource, this.problemReporter, this.eventListener, this.sourceExtractor, this, getNamespaceHandlerResolver()); }
public NamespaceHandlerResolver getNamespaceHandlerResolver() { if (this.namespaceHandlerResolver == null) { // 创建一个namespacehandler this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver(); } return this.namespaceHandlerResolver; }
namespaceHandlerResolver
太核心的Spring里面的类，看看里面是干嘛的
@FunctionalInterface public interface NamespaceHandlerResolver { /** * 比如解析xml时，我们可能有<bean>，这个是默认命名空间，其namespace就是<beans>; * 如果是<context:component-scan>，这里的namespace，就是context * * 就是根据传入的namespace，找到对应的handler。 */ @Nullable NamespaceHandler resolve(String namespaceUri); }
这个类的用途就是，根据传入的namespaceUri，找到对应的handler
可以在spring-beans包里面的META-INF/spring.handlers找一找
http\://www.springframework.org/schema/c=org.springframework.beans.factory.xml.SimpleConstructorNamespaceHandler http\://www.springframework.org/schema/p=org.springframework.beans.factory.xml.SimplePropertyNamespaceHandler http\://www.springframework.org/schema/util=org.springframework.beans.factory.xml.UtilNamespaceHandler
spring-contexts包也有这样的文件
http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler http\://www.springframework.org/schema/jee=org.springframework.ejb.config.JeeNamespaceHandler http\://www.springframework.org/schema/lang=org.springframework.scripting.config.LangNamespaceHandler http\://www.springframework.org/schema/task=org.springframework.scheduling.config.TaskNamespaceHandler http\://www.springframework.org/schema/cache=org.springframework.cache.config.CacheNamespaceHandler
剩下的jee/lang没用过，怎么没看到这个namespace呢，
看看核心逻辑代码：
protected void doRegisterBeanDefinitions(Element root) {// 一般来说，我们的根节点都是<beans>，这个是默认namespace的 BeanDefinitionParserDelegate parent = this.delegate; this.delegate = createDelegate(getReaderContext(), root, parent); if (this.delegate.isDefaultNamespace(root)) { 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); parseBeanDefinitions(root, this.delegate); //解析后处理，留给子类实现 postProcessXml(root); this.delegate = parent; }
BeanDefinitionParserDelegate
又出现了一个，可能是DefaultBeanDefinitionDocumentReader，可能觉得自己的压力太大了，这里又把任务交给了BeanDefinitionParserDelegate
这个类定义的常量值多的一笔
public class BeanDefinitionParserDelegate { public static final String BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans"; public static final String MULTI_VALUE_ATTRIBUTE_DELIMITERS = ",; "; /** * Value of a T/F attribute that represents true. * Anything else represents false. */ public static final String TRUE_VALUE = "true"; public static final String FALSE_VALUE = "false"; public static final String DEFAULT_VALUE = "default"; public static final String DESCRIPTION_ELEMENT = "description"; public static final String AUTOWIRE_NO_VALUE = "no"; public static final String AUTOWIRE_BY_NAME_VALUE = "byName"; public static final String AUTOWIRE_BY_TYPE_VALUE = "byType"; public static final String AUTOWIRE_CONSTRUCTOR_VALUE = "constructor"; public static final String AUTOWIRE_AUTODETECT_VALUE = "autodetect"; public static final String NAME_ATTRIBUTE = "name"; public static final String BEAN_ELEMENT = "bean"; public static final String META_ELEMENT = "meta"; public static final String ID_ATTRIBUTE = "id"; public static final String PARENT_ATTRIBUTE = "parent"; public static final String CLASS_ATTRIBUTE = "class"; public static final String ABSTRACT_ATTRIBUTE = "abstract"; public static final String SCOPE_ATTRIBUTE = "scope"; private static final String SINGLETON_ATTRIBUTE = "singleton"; public static final String LAZY_INIT_ATTRIBUTE = "lazy-init"; public static final String AUTOWIRE_ATTRIBUTE = "autowire"; public static final String AUTOWIRE_CANDIDATE_ATTRIBUTE = "autowire-candidate"; public static final String PRIMARY_ATTRIBUTE = "primary"; public static final String DEPENDS_ON_ATTRIBUTE = "depends-on"; public static final String INIT_METHOD_ATTRIBUTE = "init-method"; public static final String DESTROY_METHOD_ATTRIBUTE = "destroy-method"; public static final String FACTORY_METHOD_ATTRIBUTE = "factory-method"; public static final String FACTORY_BEAN_ATTRIBUTE = "factory-bean"; public static final String CONSTRUCTOR_ARG_ELEMENT = "constructor-arg"; public static final String INDEX_ATTRIBUTE = "index"; public static final String TYPE_ATTRIBUTE = "type"; public static final String VALUE_TYPE_ATTRIBUTE = "value-type"; public static final String KEY_TYPE_ATTRIBUTE = "key-type"; public static final String PROPERTY_ELEMENT = "property"; public static final String REF_ATTRIBUTE = "ref"; public static final String VALUE_ATTRIBUTE = "value"; public static final String LOOKUP_METHOD_ELEMENT = "lookup-method"; public static final String REPLACED_METHOD_ELEMENT = "replaced-method"; public static final String REPLACER_ATTRIBUTE = "replacer"; public static final String ARG_TYPE_ELEMENT = "arg-type"; public static final String ARG_TYPE_MATCH_ATTRIBUTE = "match"; public static final String REF_ELEMENT = "ref"; public static final String IDREF_ELEMENT = "idref"; public static final String BEAN_REF_ATTRIBUTE = "bean"; public static final String PARENT_REF_ATTRIBUTE = "parent"; public static final String VALUE_ELEMENT = "value"; public static final String NULL_ELEMENT = "null"; public static final String ARRAY_ELEMENT = "array"; public static final String LIST_ELEMENT = "list"; public static final String SET_ELEMENT = "set"; public static final String MAP_ELEMENT = "map"; public static final String ENTRY_ELEMENT = "entry"; public static final String KEY_ELEMENT = "key"; public static final String KEY_ATTRIBUTE = "key"; public static final String KEY_REF_ATTRIBUTE = "key-ref"; public static final String VALUE_REF_ATTRIBUTE = "value-ref"; public static final String PROPS_ELEMENT = "props"; public static final String PROP_ELEMENT = "prop"; public static final String MERGE_ATTRIBUTE = "merge"; public static final String QUALIFIER_ELEMENT = "qualifier"; public static final String QUALIFIER_ATTRIBUTE_ELEMENT = "attribute"; public static final String DEFAULT_LAZY_INIT_ATTRIBUTE = "default-lazy-init"; public static final String DEFAULT_MERGE_ATTRIBUTE = "default-merge"; public static final String DEFAULT_AUTOWIRE_ATTRIBUTE = "default-autowire"; public static final String DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE = "default-autowire-candidates"; public static final String DEFAULT_INIT_METHOD_ATTRIBUTE = "default-init-method"; public static final String DEFAULT_DESTROY_METHOD_ATTRIBUTE = "default-destroy-method";
都是xml里面那些元素，是不是
继续深入核心逻辑代码：
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { //一般来说，我们的根节点都是beans，这个是默认namespace的 //这个方法，里面可以看到通过root得到了childern，可以对children进行遍历 if (delegate.isDefaultNamespace(root)) { NodeList nl = root.getChildNodes(); // 遍历xml <beans>下的每个元素 for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (node instanceof Element) { Element ele = (Element) node; // 判断元素是不是默认命名空间的，比如<bean>是， // <context:component-scan>不是 if (delegate.isDefaultNamespace(ele)) { parseDefaultElement(ele, delegate); } else { //<context:component-scan>，<aop:xxxx>走这边 delegate.parseCustomElement(ele); } } } } else { delegate.parseCustomElement(root); } }
这里判断是不是默认的命名空间，是怎么判断的呢？
public boolean isDefaultNamespace(Node node) { //调用重载方法 return isDefaultNamespace(getNamespaceURI(node)); } public boolean isDefaultNamespace(@Nullable String namespaceUri) { return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri)); } public static final String BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";
默认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); } } public static final String ALIAS_ELEMENT = "alias"; public static final String BEAN_ELEMENT = "bean" public static final String IMPORT_ELEMENT = "import"; public static final String NESTED_BEANS_ELEMENT = "beans";
第一次发现，默认命名空间下，才这么几个元素
alias，bean，import，beans
非默认的解析
主要是处理aop、context等逻辑
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) { String namespaceUri = getNamespaceURI(ele); if (namespaceUri == null) { return null; } //这里通过nameuri找到对应的NamespaceHandler //我们这里，会得到：org.springframework.beans.factory.xml.UtilNamespaceHandler，这里resolve()里面初始化了init()方法 NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri); if (handler == null) { error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele); return null; } //org.springframework.beans.factory.xml.UtilNamespaceHandler return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd)); }
挑一个大家最熟悉的，ContextNamespaceHandler
public class ContextNamespaceHandler extends NamespaceHandlerSupport { @Override public void init() { //有点小熟悉 registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser()); registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser()); //解析annotation-config registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser()); //很熟悉 registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser()); registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser()); registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser()); registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser()); registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser()); } }
啊，不容易，终于结束了。。。。。。。
大佬博客：https://www.cnblogs.com/grey-wolf/p/12114604.html
这下面就是我做的XmlBeanDefinitionReader的解析xml的流程图，有问题请指出！
