SpringIOC源码阅读笔记（5）

分析完默认标签的解析，接下来分析自定义标签的解析：
方法的入口是在DefaultBeanDefinitionDocumentReader的parseBeanDefinitions方法中，转到parseCustomElement，

@Nullable
	public BeanDefinition parseCustomElement(Element ele) {
		return parseCustomElement(ele, null);
	}

@Nullable
	public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
	//获取名称空间的uri
		String namespaceUri = getNamespaceURI(ele);
		if (namespaceUri == null) {
			return null;
		}
		//根据namespaceUri来获得相应的Handler
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		//调用自定义的handler处理
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

//NamespaceHandler解析器，默认的类型是DefaultNamespaceHandlerResolver
	public final NamespaceHandlerResolver getNamespaceHandlerResolver() {
		return this.namespaceHandlerResolver;
	}

接下来是解析Uri

@Override
	@Nullable
	public NamespaceHandler resolve(String namespaceUri) {
	//获取已经配置的Handler映射
		Map<String, Object> handlerMappings = getHandlerMappings();
		//根据uri获得handler信息
		Object handlerOrClassName = handlerMappings.get(namespaceUri);
		if (handlerOrClassName == null) {
			return null;
		}
		//已经初始化就可以缓存中读取
		else if (handlerOrClassName instanceof NamespaceHandler) {
			return (NamespaceHandler) handlerOrClassName;
		}
		else {
		//没有初始化就反射获取
			String className = (String) handlerOrClassName;
			try {
				Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
				if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
					throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
							"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
				}
				//初始化类
				NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
				//调用自定义的初始化方法
				namespaceHandler.init();
				//添加到缓存
				handlerMappings.put(namespaceUri, namespaceHandler);
				return namespaceHandler;
			}
			catch (ClassNotFoundException ex) {
				throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" +
						namespaceUri + "] not found", ex);
			}
			catch (LinkageError err) {
				throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" +
						namespaceUri + "]: problem with handler class file or dependent class", err);
			}
		}
	}

首先是getHandlerMappings方法：

private final ClassLoader classLoader；
//映射配置文件地址
private final String handlerMappingsLocation;
//默认是加载这里面的文件
public static final String DEFAULT_HANDLER_MAPPINGS_LOCATION = "META-INF/spring.handlers";
private Map<String, Object> getHandlerMappings() {
		Map<String, Object> handlerMappings = this.handlerMappings;
		//双重检查锁，形成单例
		if (handlerMappings == null) {
			synchronized (this) {
				handlerMappings = this.handlerMappings;
				if (handlerMappings == null) {
					try {
					//读取所有的配置文件
						Properties mappings =
								PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
						if (logger.isDebugEnabled()) {
							logger.debug("Loaded NamespaceHandler mappings: " + mappings);
						}
						//形成map
						Map<String, Object> mappingsToUse = new ConcurrentHashMap<>(mappings.size());
						CollectionUtils.mergePropertiesIntoMap(mappings, mappingsToUse);
						//其实这时候map中都是命名空间和NamespaceHandler 的类路径的对应，并没有实例化
						handlerMappings = mappingsToUse;
						this.handlerMappings = handlerMappings;
					}
					catch (IOException ex) {
						throw new IllegalStateException(
								"Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
					}
				}
			}
		}
		return handlerMappings;
	}

init()方法主要是将自定义标签解析器进行注册，直接调用的是父类NamespaceHandlerSupport的registerBeanDefinitionParser

protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {
		this.parsers.put(elementName, parser);
	}

其实就是把映射关系放到类中的一个叫parses的map中。
最后调用的是handler.parse，实现在NamespaceHandlerSupport

@Override
	@Nullable
	public BeanDefinition parse(Element element, ParserContext parserContext) {
	//找到对应的解析器
		BeanDefinitionParser parser = findParserForElement(element, parserContext);
		return (parser != null ? parser.parse(element, parserContext) : null);
	}

@Nullable
	private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
	//获取元素名称
		String localName = parserContext.getDelegate().getLocalName(element);
		// 获得 BeanDefinitionParser 对象
		BeanDefinitionParser parser = this.parsers.get(localName);
		if (parser == null) {
			parserContext.getReaderContext().fatal(
					"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
		}
		return parser;
	}

@Override
	@Nullable
	public final BeanDefinition parse(Element element, ParserContext parserContext) {
	//返回 AbstractBeanDefinition 对象
		AbstractBeanDefinition definition = parseInternal(element, parserContext);
		if (definition != null && !parserContext.isNested()) {
			try {
			// 解析 id 属性
				String id = resolveId(element, definition, parserContext);
				if (!StringUtils.hasText(id)) {
					parserContext.getReaderContext().error(
							"Id is required for element '" + parserContext.getDelegate().getLocalName(element)
									+ "' when used as a top-level tag", element);
				}
				// 解析 aliases 属性
				String[] aliases = null;
				if (shouldParseNameAsAliases()) {
					String name = element.getAttribute(NAME_ATTRIBUTE);
					if (StringUtils.hasLength(name)) {
						aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
					}
				}
				// 创建 BeanDefinitionHolder 对象
				BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
				// 注册 BeanDefinition
				registerBeanDefinition(holder, parserContext.getRegistry());
				// 触发事件
				if (shouldFireEvents()) {
					BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
					postProcessComponentDefinition(componentDefinition);
					parserContext.registerComponent(componentDefinition);
				}
			}
			catch (BeanDefinitionStoreException ex) {
				String msg = ex.getMessage();
				parserContext.getReaderContext().error((msg != null ? msg : ex.toString()), element);
				return null;
			}
		}
		return definition;
	}

主要逻辑在parseInternal

@Override
	protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
	// 创建 BeanDefinitionBuilder 对象
		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
		//获取父类元素
		String parentName = getParentName(element);
		if (parentName != null) {
			builder.getRawBeanDefinition().setParentName(parentName);
		}
		//调用子类实现的getBeanClass
		Class<?> beanClass = getBeanClass(element);
		if (beanClass != null) {
			builder.getRawBeanDefinition().setBeanClass(beanClass);
		}
		else {
		//子类没有重写getBeanClass方法，则尝试是否重写了getBeanClassName
			String beanClassName = getBeanClassName(element);
			if (beanClassName != null) {
				builder.getRawBeanDefinition().setBeanClassName(beanClassName);
			}
		}
		builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
		BeanDefinition containingBd = parserContext.getContainingBeanDefinition();
		if (containingBd != null) {
			// Inner bean definition must receive same scope as containing bean.
			builder.setScope(containingBd.getScope());
		}
		if (parserContext.isDefaultLazyInit()) {
			// Default-lazy-init applies to custom bean definitions as well.
			builder.setLazyInit(true);
		}
		//调用子类的doParse
		doParse(element, parserContext, builder);
		return builder.getBeanDefinition();
	}

至此自定义标签解析完成。