Spring源码情操陶冶-PropertyPlaceholderBeanDefinitionParser注解配置解析器

本文针对spring配置的context:property-placeholder作下简单的分析，承接前文Spring源码情操陶冶-自定义节点的解析

spring配置文件应用

<context:property-placeholder location="classpath:context.properties">

PropertyPlaceholderBeanDefinitionParser-继承关系

配置文件解析类的继承关系如下

* AbstractBeanDefinitionParser

	* AbstractSingleBeanDefinitionParser

		* AbstractPropertyLoadingBeanDefinitionParser

			* PropertyPlaceholderBeanDefinitionParser

所以我们将从父类开始慢慢剖析，方便理解的全面

AbstractBeanDefinitionParser-配置文件解析抽象类

直接查看主方法parse()

	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);

				}

				String[] aliases = new String[0];

				//解析context:property-holder的name属性，并支持,分隔

				String name = element.getAttribute(NAME_ATTRIBUTE);

				if (StringUtils.hasLength(name)) {

					aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));

				}

				//包装为BeanDefinitionHolder对象

				BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);

				//注册到bean工厂中

				registerBeanDefinition(holder, parserContext.getRegistry());

				//执行事件

				if (shouldFireEvents()) {

					BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);

					//目前为空

					postProcessComponentDefinition(componentDefinition);

                                        //保存至containingComponents栈中

                                        parserContext.registerComponent(componentDefinition);

				}

			}

			catch (BeanDefinitionStoreException ex) {

				parserContext.getReaderContext().error(ex.getMessage(), element);

				return null;

			}

		}

		return definition;

	}

主要的工作由子类AbstractSingleBeanDefinitionParser#parseInternal()方法来处理

AbstractSingleBeanDefinitionParser#parseInternal-初始解析操作

此方法主要是初始化一些准备工作，并仍采用模板方法doParse()方法供子类去实现解析操作

protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {

		//类似于StringBuilder帮助创建beanDefinition

		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();

		//为null

		String parentName = getParentName(element);

		if (parentName != null) {

			builder.getRawBeanDefinition().setParentName(parentName);

		}

		//子类可复写此方法，譬如PropertyOverrideBeanDefinitionParser/PropertyPlaceholderBeanDefinitionParser

		Class<?> beanClass = getBeanClass(element);

		if (beanClass != null) {

			//设置beanClass

			builder.getRawBeanDefinition().setBeanClass(beanClass);

		}

		else {

			String beanClassName = getBeanClassName(element);

			if (beanClassName != null) {

				builder.getRawBeanDefinition().setBeanClassName(beanClassName);

			}

		}

		builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));

		if (parserContext.isNested()) {

			// Inner bean definition must receive same scope as containing bean.

			builder.setScope(parserContext.getContainingBeanDefinition().getScope());

		}

		//是否需要随spring上下文设置lazy-init属性

		if (parserContext.isDefaultLazyInit()) {

			// Default-lazy-init applies to custom bean definitions as well.

			builder.setLazyInit(true);

		}

		//供子类调用实现解析，并传入BeanDefinitionBuilder对象

		doParse(element, parserContext, builder);

		return builder.getBeanDefinition();

	}

AbstractPropertyLoadingBeanDefinitionParser#doParse-基础解析

查看了下官方注释，对此类的解释是解析context:property-....节点的抽象类，此处可指PropertyOverrideBeanDefinitionParser/PropertyPlaceholderBeanDefinitionParser，可对此方法进行扩展，代码如下

	@Override

	protected void doParse(Element element, BeanDefinitionBuilder builder) {

		//获取location属性，支持,分隔，表明指定读取配置文件的路径

		String location = element.getAttribute("location");

		if (StringUtils.hasLength(location)) {

			String[] locations = StringUtils.commaDelimitedListToStringArray(location);

			builder.addPropertyValue("locations", locations);

		}

		//获取properties-ref属性，设置properties文件的引用名

		String propertiesRef = element.getAttribute("properties-ref");

		if (StringUtils.hasLength(propertiesRef)) {

			builder.addPropertyReference("properties", propertiesRef);

		}

		//获取file-encoding属性，文件解析字符编码集

		String fileEncoding = element.getAttribute("file-encoding");

		if (StringUtils.hasLength(fileEncoding)) {

			builder.addPropertyValue("fileEncoding", fileEncoding);

		}

		//获取order属性，用于排序

		String order = element.getAttribute("order");

		if (StringUtils.hasLength(order)) {

			builder.addPropertyValue("order", Integer.valueOf(order));

		}

		//获取ignore-resource-not-found属性，默认为false，表明找不到资源是否往外抛异常

		builder.addPropertyValue("ignoreResourceNotFound",

				Boolean.valueOf(element.getAttribute("ignore-resource-not-found")));

		//获取local-override属性，默认为false，true表明先使用文件中的属性，找不到再使用环境变量中的属性

		builder.addPropertyValue("localOverride",

				Boolean.valueOf(element.getAttribute("local-override")));

		builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

	}

PropertyPlaceholderBeanDefinitionParser-抽象方法的扩展

复写的抽象方法有两处，分别为getBeanClass()和doParse()方法

getBeanClass(Element element)

指定解析文件的beanClass，beanClass均是BeanFactoryPostProcessor接口的实现类，代码如下

protected Class<?> getBeanClass(Element element) {

		//获取system-properties-mode属性是否为ENVIRONMENT，是则采用PropertySourcesPlaceholderConfigurer.class

		if (element.getAttribute(SYSTEM_PROPERTIES_MODE_ATTRIB).equals(SYSTEM_PROPERTIES_MODE_DEFAULT)) {

			return PropertySourcesPlaceholderConfigurer.class;

		}

		//默认为PropertyPlaceholderConfigurer.class作为beanClass

		return PropertyPlaceholderConfigurer.class;

	}

doParse(Element element, BeanDefinitionBuilder builder)

在父类的基础上再加几个属性判断

protected void doParse(Element element, BeanDefinitionBuilder builder) {

		super.doParse(element, builder);

		//获取ignore-unresolvable属性，默认为false，true代表解析不了属性不抛异常

		builder.addPropertyValue("ignoreUnresolvablePlaceholders",

				Boolean.valueOf(element.getAttribute("ignore-unresolvable")));

		//获取system-properties-mode属性

		String systemPropertiesModeName = element.getAttribute(SYSTEM_PROPERTIES_MODE_ATTRIB);

		if (StringUtils.hasLength(systemPropertiesModeName) &&

				!systemPropertiesModeName.equals(SYSTEM_PROPERTIES_MODE_DEFAULT)) {

			builder.addPropertyValue("systemPropertiesModeName", "SYSTEM_PROPERTIES_MODE_"+systemPropertiesModeName);

		}

	}

小结

PropertyPlaceholderBeanDefinitionParser的作用是初始化配置文件的解析策略，方便spring在invokeBeanFactoryPostProcessors()中解析${}属性使用，具体可看>>>Spring源码情操陶冶-AbstractApplicationContext#invokeBeanFactoryPostProcessors

真正的解析${}这样格式的类是PropertyPlaceholderConfigurer.class或者是PropertySourcesPlaceholderConfigurer.class，前者适合spring 3.0之前，后者适合spring 3.1之后；

前者是默认的实现，后者如果指定local-override为true，则优先找寻本地属性(文件属性)，找不到的情况下再找寻环境属性(Environment)

context:property-placeholder的属性

location-文件资源路径，支持classpath路径，且可指定多个，以,分隔

file-encoding-文件读取编码

properties-ref-属性配置文件应用名

order-排序属性

ignore-resource-not-found-默认为false，表明找不到资源是否往外抛异常

local-override-默认为false，表示优先查找文件(Properties)的属性，不存在则再找寻本地的属性(System)，反之则是先本地后文件

ignore-unresolvable-默认为false，true代表解析不了属性不抛异常

秒客网