上一篇随笔说到Spring对于默认标签和自定义标签的解析方法是不同的，这里详细看一下Spring对于默认标签的解析。
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if(delegate.nodeNameEquals(ele, "import")) {
this.importBeanDefinitionResource(ele);
} else if(delegate.nodeNameEquals(ele, "alias")) {
this.processAliasRegistration(ele);
} else if(delegate.nodeNameEquals(ele, "bean")) {
this.processBeanDefinition(ele, delegate);
} else if(delegate.nodeNameEquals(ele, "beans")) {
this.doRegisterBeanDefinitions(ele);
}
}
在这里对根节点的子节点的四种不同类型分别做了不同的处理。这四种解析中，对bean的解析最为复杂。所以我们进入函数processBeanDefinition。
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if(bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
} catch (BeanDefinitionStoreException var5) {
this.getReaderContext().error("Failed to register bean definition with name \'" + bdHolder.getBeanName() + "\'", ele, var5);
}
this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
这段代码中：
1、首先委托了BeanDefinitionParseDelegate对节点做了解析，并返回了一个BeanDefinitionHolder的实例，在这个实例中已经包含了配置文件中配置的各种属性了
2、如果在当前子节点中存在自定义属性，则还需要对自定义标签进行解析
3、解析完成后，需要对解析后的bdHolder进行注册，同样注册操作委托给了BeanDefinitionReaderUtils
4、最后发出响应事件，通知相关的监听器
我们先看解析节点的部分
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
String id = ele.getAttribute("id");
String nameAttr = ele.getAttribute("name");
ArrayList aliases = new ArrayList();
if(StringUtils.hasLength(nameAttr)) {
String[] beanName = StringUtils.tokenizeToStringArray(nameAttr, ",; ");
aliases.addAll(Arrays.asList(beanName));
}
String beanName1 = id;
if(!StringUtils.hasText(id) && !aliases.isEmpty()) {
beanName1 = (String)aliases.remove(0);
if(this.logger.isDebugEnabled()) {
this.logger.debug("No XML \'id\' specified - using \'" + beanName1 + "\' as bean name and " + aliases + " as aliases");
}
}
if(containingBean == null) {
this.checkNameUniqueness(beanName1, aliases, ele);
}
AbstractBeanDefinition beanDefinition = this.parseBeanDefinitionElement(ele, beanName1, containingBean);
if(beanDefinition != null) {
if(!StringUtils.hasText(beanName1)) {
try {
if(containingBean != null) {
beanName1 = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);
} else {
beanName1 = this.readerContext.generateBeanName(beanDefinition);
String aliasesArray = beanDefinition.getBeanClassName();
if(aliasesArray != null && beanName1.startsWith(aliasesArray) && beanName1.length() > aliasesArray.length() && !this.readerContext.getRegistry().isBeanNameInUse(aliasesArray)) {
aliases.add(aliasesArray);
}
}
if(this.logger.isDebugEnabled()) {
this.logger.debug("Neither XML \'id\' nor \'name\' specified - using generated bean name [" + beanName1 + "]");
}
} catch (Exception var9) {
this.error(var9.getMessage(), ele);
return null;
}
}
String[] aliasesArray1 = StringUtils.toStringArray(aliases);
return new BeanDefinitionHolder(beanDefinition, beanName1, aliasesArray1);
} else {
return null;
}
}
这段代码中首先提取了当前节点的id和name，beanName默认为id，如果id为空，则spring会去别名中的第一个作为beanName。
然后spring会检查当前beanName是否唯一，在BeanDefinitionParseDelegate中维护了一套已用过的beanName以及alias的集合，如果bean的beanName和alias和已存在的名字重复，则会抛错。
进一步解析节点的所有属性，并统一封装到GenericBeanDefinition中。
如果发现当前bean的beanName为空，则使用默认规则为其自动生成beanName。
最后将所有信息封装到BeanDefinitionHolder中返回。
进入到parseBeanDefinitionElement方法中
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
if(ele.hasAttribute("class")) {
className = ele.getAttribute("class").trim();
}
try {
String ex = null;
if(ele.hasAttribute("parent")) {
ex = ele.getAttribute("parent");
}
AbstractBeanDefinition bd = this.createBeanDefinition(className, ex);
this.parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, "description"));
this.parseMetaElements(ele, bd);
this.parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
this.parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
this.parseConstructorArgElements(ele, bd);
this.parsePropertyElements(ele, bd);
this.parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(this.extractSource(ele));
AbstractBeanDefinition var7 = bd;
return var7;
} catch (ClassNotFoundException var13) {
this.error("Bean class [" + className + "] not found", ele, var13);
} catch (NoClassDefFoundError var14) {
this.error("Class that bean class [" + className + "] depends on not found", ele, var14);
} catch (Throwable var15) {
this.error("Unexpected failure during bean definition parsing", ele, var15);
} finally {
this.parseState.pop();
}
return null;
}
在this.createBeanDefinition方法中，Spring会生产一个GenericBeanDefinition实例，在其属性里设置了当前节点的父类parent，以及className类名的信息。
在this.parseBeanDefinitionAttributes方法中对于一些属性进行了解析
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName, BeanDefinition containingBean, AbstractBeanDefinition bd) {
if(ele.hasAttribute("singleton")) {
this.error("Old 1.x \'singleton\' attribute in use - upgrade to \'scope\' declaration", ele);
} else if(ele.hasAttribute("scope")) {
bd.setScope(ele.getAttribute("scope"));
} else if(containingBean != null) {
bd.setScope(containingBean.getScope());
}
if(ele.hasAttribute("abstract")) {
bd.setAbstract("true".equals(ele.getAttribute("abstract")));
}
String lazyInit = ele.getAttribute("lazy-init");
if("default".equals(lazyInit)) {
lazyInit = this.defaults.getLazyInit();
}
bd.setLazyInit("true".equals(lazyInit));
String autowire = ele.getAttribute("autowire");
bd.setAutowireMode(this.getAutowireMode(autowire));
String dependencyCheck = ele.getAttribute("dependency-check");
bd.setDependencyCheck(this.getDependencyCheck(dependencyCheck));
String autowireCandidate;
if(ele.hasAttribute("depends-on")) {
autowireCandidate = ele.getAttribute("depends-on");
bd.setDependsOn(StringUtils.tokenizeToStringArray(autowireCandidate, ",; "));
}
autowireCandidate = ele.getAttribute("autowire-candidate");
String destroyMethodName;
if(!"".equals(autowireCandidate) && !"default".equals(autowireCandidate)) {
bd.setAutowireCandidate("true".equals(autowireCandidate));
} else {
destroyMethodName = this.defaults.getAutowireCandidates();
if(destroyMethodName != null) {
String[] patterns = StringUtils.commaDelimitedListToStringArray(destroyMethodName);
bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
}
}
if(ele.hasAttribute("primary")) {
bd.setPrimary("true".equals(ele.getAttribute("primary")));
}
if(ele.hasAttribute("init-method")) {
destroyMethodName = ele.getAttribute("init-method");
if(!"".equals(destroyMethodName)) {
bd.setInitMethodName(destroyMethodName);
}
} else if(this.defaults.getInitMethod() != null) {
bd.setInitMethodName(this.defaults.getInitMethod());
bd.setEnforceInitMethod(false);
}
if(ele.hasAttribute("destroy-method")) {
destroyMethodName = ele.getAttribute("destroy-method");
if(!"".equals(destroyMethodName)) {
bd.setDestroyMethodName(destroyMethodName);
}
} else if(this.defaults.getDestroyMethod() != null) {
bd.setDestroyMethodName(this.defaults.getDestroyMethod());
bd.setEnforceDestroyMethod(false);
}
if(ele.hasAttribute("factory-method")) {
bd.setFactoryMethodName(ele.getAttribute("factory-method"));
}
if(ele.hasAttribute("factory-bean")) {
bd.setFactoryBeanName(ele.getAttribute("factory-bean"));
}
return bd;
}
在这里我们可以看到其中不少属性是我们经常使用的，当然也有一些属性不太熟悉。这里大致查了一下资料，简单介绍这些属性的意义：
scope:
对象在spring容器（IOC容器）中的生命周期。共有五中取值。singleton和protoType大家比较熟悉。另外三种request，session和global session只适用于web应用。
abstract:
当前bean是否为抽象类，默认为false
lazy-init:
延迟初始化，在ApplicationContext中默认配置时，spring会在应用启动时就对容器中的bean进行实例化，如果设置了延迟加载，则spring会在第一次使用该bean时初始化该bean。
autowire:
设置bean自动装配模式。可选5种模式 no：不使用自动装配。Bean的引用必须通过ref元素定义。byName：通过名字进行装配 byType:根据类型进行装配 constructor：和byType类似，不过是应用于通过构造函数注入的方式。autoDetect：通过对bean检查类的内部自动选择constructor还是byType。
dependency-check:
依赖检查的模式。
depends-on:
实例化时，依赖的bean，spring会在实例化当前bean之前先实例化依赖的bean。一般不需特别设置，spring会提供一套默认对依赖的检查和实例化的逻辑。
autowire-candidate:
当自动注入的类的实现类有多个时，有两种方案，一种是设置某一个实现类的autowire-candidate属性为false，则该类不参与自动注入。或者设置依赖注入的对象的autowire-candidate为指定实现类。
primary:
primary属性为true时，自动装配时当出现多个Bean的候选者时，属性primary=true的Bean被作为首选者。
init-method:
定义spring 容器在初始化bean之前的所做的操作。
destroy-method:
定义spring 容器在容器销毁之前的所做的操作。
factory-method 和 factory-bean:
spring IoC注入方式除了我们常见的set注入和构造器注入，还可以通过工厂方式注入。工厂分静态工厂和普通工厂。
如果想用某一个静态工厂来实例化bean，可以使用如下配置：
<bean name="production" class="com.wuzhe.factory.StaticFactory" factory-method="getProduction"/>
如果想通过普通工厂来实例化bean，可以使用如下配置：
<bean name="factory" class="com.wuzhe.factory.Factory"/>
<bean name="production" factory-bean="factory" factory-method="getProduction"/>
接下来是解析子节点的meta属性： this.parseMetaElements(ele, bd)
meta属性是在定义bean时额外添加的说明。例如：
<bean id="myBean" class="com.wuzhe.bean.MyBean">
<meta key="author" value="wuzhe"></meta>
</bean>
这里的meta属性并不会体现在myBean中，当需要meta信息的时候可以通过BeanDefinition.getAttribute(key)方法获取
接下来是解析节点的lookup-method:
this.parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
先来看一下这个属性的用法，我们把lookup-method称之为获取器注入。这是一种特殊的方法注入，它是把一个方法声明为返回某个类型的bean，这样可用在设计有些可插拔的功能上，解除程序依赖。
举例说明，假设GetFood类中有一个Food getFood（）方法。然后Bread和Cake分别继承Food类。当我们希望getFood()返回Bread类型的bean，我们可以这样配置：
<bean id="getFoodTest" class="com.wuzhe.lookup.GetFood">
<lookup-method name="getFood" bean="bread"/>
</bean>
<bean id="bread" class="com.wuzhe.food.Bread"/>
<bean id="cake" class="com.wuzhe.food.Cake"/>
如果我们想让getFood（）方法返回cake时，只要修改bean属性就可以了
进入到解析lookup-method方法里面
public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
NodeList nl = beanEle.getChildNodes();
for(int i = 0; i < nl.getLength(); ++i) {
Node node = nl.item(i);
if(this.isCandidateElement(node) && this.nodeNameEquals(node, "lookup-method")) {
Element ele = (Element)node;
String methodName = ele.getAttribute("name");
String beanRef = ele.getAttribute("bean");
LookupOverride override = new LookupOverride(methodName, beanRef);
override.setSource(this.extractSource(ele));
overrides.addOverride(override);
}
}
}
上面这段代码会将lookup-method要mock返回的方法和bean封装在LookupOverride类中，并添加到bd的methodOverrides属性中。
接下来是解析replace-method属性
this.parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
replace-method更加强大，不但可以替换bean，还可以替换原有方法的逻辑。它可以将bean中的方法替换成另一个继承MethodReplace的类reimplement的实现
public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
NodeList nl = beanEle.getChildNodes();
for(int i = 0; i < nl.getLength(); ++i) {
Node node = nl.item(i);
if(this.isCandidateElement(node) && this.nodeNameEquals(node, "replaced-method")) {
Element replacedMethodEle = (Element)node;
String name = replacedMethodEle.getAttribute("name");
String callback = replacedMethodEle.getAttribute("replacer");
ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
List argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, "arg-type");
Iterator var11 = argTypeEles.iterator();
while(var11.hasNext()) {
Element argTypeEle = (Element)var11.next();
String match = argTypeEle.getAttribute("match");
match = StringUtils.hasText(match)?match:DomUtils.getTextValue(argTypeEle);
if(StringUtils.hasText(match)) {
replaceOverride.addTypeIdentifier(match);
}
}
replaceOverride.setSource(this.extractSource(replacedMethodEle));
overrides.addOverride(replaceOverride);
}
}
}
这里解析replace-method的思路和lookup-method类似，都是讲元素的属性封装一下，并添加到bd的methodOverrides属性中。不同的是replace-method属性封装在RepalceOverride中。
接下来看对构造函数的解析
public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
String indexAttr = ele.getAttribute("index");
String typeAttr = ele.getAttribute("type");
String nameAttr = ele.getAttribute("name");
if(StringUtils.hasLength(indexAttr)) {
try {
int value = Integer.parseInt(indexAttr);
if(value < 0) {
this.error("\'index\' cannot be lower than 0", ele);
} else {
try {
this.parseState.push(new ConstructorArgumentEntry(value));
Object valueHolder = this.parsePropertyValue(ele, bd, (String)null);
ValueHolder valueHolder1 = new ValueHolder(valueHolder);
if(StringUtils.hasLength(typeAttr)) {
valueHolder1.setType(typeAttr);
}
if(StringUtils.hasLength(nameAttr)) {
valueHolder1.setName(nameAttr);
}
valueHolder1.setSource(this.extractSource(ele));
if(bd.getConstructorArgumentValues().hasIndexedArgumentValue(value)) {
this.error("Ambiguous constructor-arg entries for index " + value, ele);
} else {
bd.getConstructorArgumentValues().addIndexedArgumentValue(value, valueHolder1);
}
} finally {
this.parseState.pop();
}
}
} catch (NumberFormatException var19) {
this.error("Attribute \'index\' of tag \'constructor-arg\' must be an integer", ele);
}
} else {
try {
this.parseState.push(new ConstructorArgumentEntry());
Object value1 = this.parsePropertyValue(ele, bd, (String)null);
ValueHolder valueHolder2 = new ValueHolder(value1);
if(StringUtils.hasLength(typeAttr)) {
valueHolder2.setType(typeAttr);
}
if(StringUtils.hasLength(nameAttr)) {
valueHolder2.setName(nameAttr);
}
valueHolder2.setSource(this.extractSource(ele));
bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder2);
} finally {
this.parseState.pop();
}
}
}
spring对constructor-arg是否存在index属性的处理流程稍有不同，不同在于如果存在index属性，spring会将type、name和index属性封装在ValueHolder并添加至bd的constructorArgumentValues的indexedArgumentValues属性中，如果不存在则添加至genericArgumentValue属性中。
解析property属性和constructor-arg的过程类似
public void parsePropertyElement(Element ele, BeanDefinition bd) {
String propertyName = ele.getAttribute("name");
if(!StringUtils.hasLength(propertyName)) {
this.error("Tag \'property\' must have a \'name\' attribute", ele);
} else {
this.parseState.push(new PropertyEntry(propertyName));
try {
if(bd.getPropertyValues().contains(propertyName)) {
this.error("Multiple \'property\' definitions for property \'" + propertyName + "\'", ele);
return;
}
Object val = this.parsePropertyValue(ele, bd, propertyName);
PropertyValue pv = new PropertyValue(propertyName, val);
this.parseMetaElements(ele, pv);
pv.setSource(this.extractSource(ele));
bd.getPropertyValues().addPropertyValue(pv);
} finally {
this.parseState.pop();
}
}
}
解析qualifier
Spring在进行自动注入时，容器中候选的Bean有且只有一个，当有多个候选Bean的时候可以通过Qualifier指定注入Bean的名称。
具体解析过程和之前大同小异
public void parseQualifierElement(Element ele, AbstractBeanDefinition bd) {
String typeName = ele.getAttribute("type");
if(!StringUtils.hasLength(typeName)) {
this.error("Tag \'qualifier\' must have a \'type\' attribute", ele);
} else {
this.parseState.push(new QualifierEntry(typeName));
try {
AutowireCandidateQualifier qualifier = new AutowireCandidateQualifier(typeName);
qualifier.setSource(this.extractSource(ele));
String value = ele.getAttribute("value");
if(StringUtils.hasLength(value)) {
qualifier.setAttribute(AutowireCandidateQualifier.VALUE_KEY, value);
}
NodeList nl = ele.getChildNodes();
for(int i = 0; i < nl.getLength(); ++i) {
Node node = nl.item(i);
if(this.isCandidateElement(node) && this.nodeNameEquals(node, "attribute")) {
Element attributeEle = (Element)node;
String attributeName = attributeEle.getAttribute("key");
String attributeValue = attributeEle.getAttribute("value");
if(!StringUtils.hasLength(attributeName) || !StringUtils.hasLength(attributeValue)) {
this.error("Qualifier \'attribute\' tag must have a \'name\' and \'value\'", attributeEle);
return;
}
BeanMetadataAttribute attribute = new BeanMetadataAttribute(attributeName, attributeValue);
attribute.setSource(this.extractSource(attributeEle));
qualifier.addMetadataAttribute(attribute);
}
}
bd.addQualifier(qualifier);
} finally {
this.parseState.pop();
}
}
}
至此，对bean节点的属性解析就完成了，相当于spring将配置文件转换成了内存中的GenericBeanDefinition对象。xml中的属性都可以在GenericBeanDefinition找到储存的位置。
解析完bean后，就需要对beanDefinition进行注册，注册我理解就是把解析的beanDefinition存放在内存中，统一管理。在XmlFactory中，所有的beanDefinition缓存都存放在了它的父类DefaultListableBeanFactory的
beanDefinitionMap中，key值为beanName。
我们看一下注册的源码
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if(beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition)beanDefinition).validate();
} catch (BeanDefinitionValidationException var9) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", var9);
}
}
BeanDefinition oldBeanDefinition = (BeanDefinition)this.beanDefinitionMap.get(beanName);
if(oldBeanDefinition != null) {
if(!this.isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean \'" + beanName + "\': There is already [" + oldBeanDefinition + "] bound.");
}
if(oldBeanDefinition.getRole() < beanDefinition.getRole()) {
if(this.logger.isWarnEnabled()) {
this.logger.warn("Overriding user-defined bean definition for bean \'" + beanName + "\' with a framework-generated bean definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
}
} else if(!beanDefinition.equals(oldBeanDefinition)) {
if(this.logger.isInfoEnabled()) {
this.logger.info("Overriding bean definition for bean \'" + beanName + "\' with a different definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
}
} else if(this.logger.isDebugEnabled()) {
this.logger.debug("Overriding bean definition for bean \'" + beanName + "\' with an equivalent definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
}
this.beanDefinitionMap.put(beanName, beanDefinition);
} else {
if(this.hasBeanCreationStarted()) {
Map var4 = this.beanDefinitionMap;
synchronized(this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
ArrayList updatedDefinitions = new ArrayList(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if(this.manualSingletonNames.contains(beanName)) {
LinkedHashSet updatedSingletons = new LinkedHashSet(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
} else {
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if(oldBeanDefinition != null || this.containsSingleton(beanName)) {
this.resetBeanDefinition(beanName);
}
}
在这段代码中
1、首先对传入的beanDefinition做了合法性的校验
2、然后根据beanName查找当前beanDefinitionMap缓存中是否已有相应的beanDefinion。如果有且当前设置了不允许bean覆盖，则会抛错，若允许覆盖，则用当前beanDefinition覆盖旧的beanDefinition，并清除缓存中旧的bean信息。
3、如果beanDefinitionMap缓存中不存在旧的beanDifinition, 则在beanDefinitionMap中存放当前beanDefinition。
这里涉及到的几个缓存：beanDefinitionMap很好理解，manualSingletonNames的含义并不清楚，这里留个疑问，后续若学习到相关知识，再来补充。
注册好了beanDefinition,接下来就是注册alias。注册的alias和beanName的对应关系存放在了aliasMap中
public void registerAlias(String name, String alias) {
Assert.hasText(name, "\'name\' must not be empty");
Assert.hasText(alias, "\'alias\' must not be empty");
if(alias.equals(name)) {
this.aliasMap.remove(alias);
} else {
String registeredName = (String)this.aliasMap.get(alias);
if(registeredName != null) {
if(registeredName.equals(name)) {
return;
}
if(!this.allowAliasOverriding()) {
throw new IllegalStateException("Cannot register alias \'" + alias + "\' for name \'" + name + "\': It is already registered for name \'" + registeredName + "\'.");
}
}
this.checkForAliasCircle(name, alias);
this.aliasMap.put(alias, name);
}
}
注册别名的过程还是很容易理解的：
1、若beanName和alias相同，则无需处理，并在缓存中删除alias
2、若存在alias注册了其他beanName,则根据是否允许覆盖的设置，进行相应处理
3、循环检查alias
4、注册alias
至此对bean默认标签的解析和注册就完成了