Mybatis源码学习之parsing包（解析器）（二）

简述

大家都知道mybatis中，无论是配置文件mybatis-config.xml，还是SQL语句，都是写在XML文件中的，那么mybatis是如何解析这些XML文件呢？这就是本文将要学习的就是，mybatis解析器XPathParser。

MyBatis在初始化过程中处理mybatis-config.xml配置文件以及映射文件时，使用的是DOM解析方式，并结合使用XPath解析XML配置文件。DOM会将整个XML文档加载到内存中并形成树状数据结构，而XPath是一种为查询XML文档而设计的语言，它可以与DOM解析方式配合使用，实现对XML文档的解析。

XPath使用路径表达式来选取XML文档中指定的节点或者节点集合，与常见的URL路径有些类似。

XPath中常用的表达式：

XPath 语法概念：http://www.runoob.com/xpath/xpath-tutorial.html

parsing包整体概览

GenericTokenParser——占位符解析器

该类为mybatis中通用占位符解析器，解析xml文件中占位符 “${}”并返回对应的值，为了学习的便利性，我加了日志对入参和结果进行打印。

GenericTokenParser.parse（）方法的逻辑并不复杂，它会顺序查找openToken和closeToken，解析得到占位符的字面值，并将其交给TokenHandler处理，然后将解析结果重新拼装成字符串并返回。

具体看源码：

/**
 * mybatis通用标记解析器，对xml中属性中的占位符进行解析
 *
 * @author Clinton Begin
 */
public class GenericTokenParser {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    /**
     * 开始标记符
     */
    private final String openToken;
    /**
     * 结束标记符
     */
    private final String closeToken;
    /**
     * 标记处理接口，具体的处理操作取决于它的实现方法
     */
    private final TokenHandler handler;

    /**
     * 构造函数
     */
    public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
        this.openToken = openToken;
        this.closeToken = closeToken;
        this.handler = handler;
    }

    /**
     * 文本解析方法
     */
    public String parse(String text) {
        //文本空值判断
        if (text == null || text.isEmpty()) {
            return "";
        }
        // 获取开始标记符在文本中的位置
        int start = text.indexOf(openToken, 0);
        //位置索引值为-1，说明不存在该开始标记符
        if (start == -1) {
            return text;
        }
        //将文本转换成字符数组
        char[] src = text.toCharArray();
        //偏移量
        int offset = 0;
        //解析后的字符串
        final StringBuilder builder = new StringBuilder();
        StringBuilder expression = null;
        while (start > -1) {
            //判断开始标记符前边是否有转移字符，如果存在转义字符则移除转义字符
            if (start > 0 && src[start - 1] == '\') {
                //移除转义字符
                builder.append(src, offset, start - offset - 1).append(openToken);
                //重新计算偏移量
                offset = start + openToken.length();
            } else {
                //开始查找结束标记符
                if (expression == null) {
                    expression = new StringBuilder();
                } else {
                    expression.setLength(0);
                }
                builder.append(src, offset, start - offset);
                offset = start + openToken.length();
                //结束标记符的索引值
                int end = text.indexOf(closeToken, offset);
                while (end > -1) {
                    //同样判断标识符前是否有转义字符，有就移除
                    if (end > offset && src[end - 1] == '\') {
                        // this close token is escaped. remove the backslash and continue.
                        expression.append(src, offset, end - offset - 1).append(closeToken);
                        //重新计算偏移量
                        offset = end + closeToken.length();
                        //重新计算结束标识符的索引值
                        end = text.indexOf(closeToken, offset);
                    } else {
                        expression.append(src, offset, end - offset);
                        offset = end + closeToken.length();
                        break;
                    }
                }
                //没有找到结束标记符
                if (end == -1) {
                    // close token was not found.
                    builder.append(src, start, src.length - start);
                    offset = src.length;
                } else {
                    //找到了一组标记符，对该标记符进行值替换
                    builder.append(handler.handleToken(expression.toString()));
                    offset = end + closeToken.length();
                }
            }
            //接着查找下一组标记符
            start = text.indexOf(openToken, offset);
        }
        if (offset < src.length) {
            builder.append(src, offset, src.length - offset);
        }
        logger.debug("[GenericTokenParser]-[parse]-待解析文本：{},解析结果：{}",text,builder.toString());
        return builder.toString();
    }
}

为了更加深入的了解其解析过程，我们使用其提供的单元测试进行了跟踪调试，这里只复制了部分代码，具体可看其源码：

  @Test
  public void shouldDemonstrateGenericTokenReplacement() {
    GenericTokenParser parser = new GenericTokenParser("${", "}", new VariableTokenHandler(new HashMap<String, String>() {
      {
        put("first_name", "James");
        put("initial", "T");
        put("last_name", "Kirk");
        put("var{with}brace", "Hiya");
        put("", "");
      }
    }));

    assertEquals("James T Kirk reporting.", parser.parse("${first_name} ${initial} ${last_name} reporting."));
    }

输出结果：

DEBUG [main] - [GenericTokenParser]-[parse]-待解析文本：${first_name} ${initial} ${last_name} reporting.,解析结果：James T Kirk reporting.

PropertyParser-默认值解析器

通过对PropertyParser.parse（）方法的学习，我们知道PropertyParser是使用VariableToken-Handler与GenericTokenParser配合完成占位符解析的。VariableTokenHandler是PropertyParser中的一个私有静态内部类。

VariableTokenHandler实现了TokenHandler接口中的handleToken（）方法，该实现首先会按照defaultValueSeparator字段指定的分隔符对整个占位符切分，得到占位符的名称和默认值，然后按照切分得到的占位符名称查找对应的值，如果在＜properties＞节点下未定义相应的键值对，则将切分得到的默认值作为解析结果返回。

GenericTokenParser不仅仅用于这里的默认值解析，还会用于后面对动态SQL语句的解析。很明显，GenericTokenParser只是查找到指定的占位符，而具体的解析行为会根据其持有的TokenHandler实现的不同而有所不同，

/**
 * 属性解析器，主要用于对默认值的解析
 *
 * @author Clinton Begin
 * @author Kazuki Shimizu
 */
public class PropertyParser {
    private static final Logger logger= LoggerFactory.getLogger(PropertyParser.class);

    private static final String KEY_PREFIX = "org.apache.ibatis.parsing.PropertyParser.";
    /**
     * 特殊属性键，指示是否在占位符上启用默认值。
     * <p>
     * 默认值是false，是禁用的占位符上使用默认值，当启用以后（true）可以在占位符上使用默认值。
     * 例如：${db.username:postgres}，表示数据库的用户名默认是postgres
     * <p>
     * </p>
     *
     * @since 3.4.2
     */
    public static final String KEY_ENABLE_DEFAULT_VALUE = KEY_PREFIX + "enable-default-value";

    /**
     * 为占位符上的键和默认值指定分隔符的特殊属性键。
     * <p>
     * 默认分隔符是“:”
     * </p>
     *
     * @since 3.4.2
     */
    public static final String KEY_DEFAULT_VALUE_SEPARATOR = KEY_PREFIX + "default-value-separator";

    private static final String ENABLE_DEFAULT_VALUE = "false";
    private static final String DEFAULT_VALUE_SEPARATOR = ":";


    private PropertyParser() {
        // 私有构造函数，防止实例化
    }

    public static String parse(String string, Properties variables) {
        //解析默认值
        VariableTokenHandler handler = new VariableTokenHandler(variables);
       //解析占位符
        GenericTokenParser parser = new GenericTokenParser("${", "}", handler);
        return parser.parse(string);
    }

    /**
     * 内部私有静态类
     */
    private static class VariableTokenHandler implements TokenHandler {
        /**
         * ＜properties＞节点下定义的键值对，用于替换占位符
         */
        private final Properties variables;
        /**
         * 是否启用默认值
         */
        private final boolean enableDefaultValue;
        /**
         * 默认分隔符
         */
        private final String defaultValueSeparator;

        private VariableTokenHandler(Properties variables) {
            this.variables = variables;
            this.enableDefaultValue = Boolean.parseBoolean(getPropertyValue(KEY_ENABLE_DEFAULT_VALUE, ENABLE_DEFAULT_VALUE));
            this.defaultValueSeparator = getPropertyValue(KEY_DEFAULT_VALUE_SEPARATOR, DEFAULT_VALUE_SEPARATOR);
        }

        private String getPropertyValue(String key, String defaultValue) {
            return (variables == null) ? defaultValue : variables.getProperty(key, defaultValue);
        }

        @Override
        public String handleToken(String content) {
            //解析结果（为方便调试学习，自己加的）
            String parseResult="${" + content + "}";
            //变量值不为空
            if (variables != null) {
                String key = content;
                if (enableDefaultValue) {
                    //分隔符索引值
                    final int separatorIndex = content.indexOf(defaultValueSeparator);
                    String defaultValue = null;
                    if (separatorIndex >= 0) {
                        key = content.substring(0, separatorIndex);
                        //获取默认值
                        defaultValue = content.substring(separatorIndex + defaultValueSeparator.length());
                    }
                    //默认值不为空
                    if (defaultValue != null) {
                        //优先使用变量集合中的值，其次使用默认值
                        parseResult= variables.getProperty(key, defaultValue);
                    }
                }
                if (variables.containsKey(key)) {
                    parseResult= variables.getProperty(key);
                }
            }
            logger.debug("【PropertyParser】-【handleToken】-待解析内容{},解析结果{}",content,parseResult);
            return parseResult;
        }
    }

}

测试事例：

 @Test
  public void replaceToVariableValue() {
    Properties props = new Properties();
    props.setProperty(PropertyParser.KEY_ENABLE_DEFAULT_VALUE, "true");
    props.setProperty("key", "value");
    props.setProperty("tableName", "members");
    props.setProperty("orderColumn", "member_id");
    props.setProperty("a:b", "c");
    Assertions.assertThat(PropertyParser.parse("${key}", props)).isEqualTo("value");
    Assertions.assertThat(PropertyParser.parse("${key:aaaa}", props)).isEqualTo("value");
    Assertions.assertThat(PropertyParser.parse("SELECT * FROM ${tableName:users} ORDER BY ${orderColumn:id}", props)).isEqualTo("SELECT * FROM members ORDER BY member_id");

    //关闭默认值解析
    props.setProperty(PropertyParser.KEY_ENABLE_DEFAULT_VALUE, "false");
    Assertions.assertThat(PropertyParser.parse("${a:b}", props)).isEqualTo("c");

    props.remove(PropertyParser.KEY_ENABLE_DEFAULT_VALUE);
    Assertions.assertThat(PropertyParser.parse("${a:b}", props)).isEqualTo("c");

  }

输出结果：

DEBUG [main] - 【PropertyParser】-【handleToken】-待解析内容key,解析结果value
DEBUG [main] - [GenericTokenParser]-[parse]-待解析文本：${key},解析结果：value
DEBUG [main] - 【PropertyParser】-【handleToken】-待解析内容key:aaaa,解析结果value
DEBUG [main] - [GenericTokenParser]-[parse]-待解析文本：${key:aaaa},解析结果：value
DEBUG [main] - 【PropertyParser】-【handleToken】-待解析内容tableName:users,解析结果members
DEBUG [main] - 【PropertyParser】-【handleToken】-待解析内容orderColumn:id,解析结果member_id
DEBUG [main] - [GenericTokenParser]-[parse]-待解析文本：SELECT * FROM ${tableName:users} ORDER BY ${orderColumn:id},解析结果：SELECT * FROM members ORDER BY member_id
DEBUG [main] - 【PropertyParser】-【handleToken】-待解析内容a:b,解析结果c
DEBUG [main] - [GenericTokenParser]-[parse]-待解析文本：${a:b},解析结果：c
DEBUG [main] - 【PropertyParser】-【handleToken】-待解析内容a:b,解析结果c
DEBUG [main] - [GenericTokenParser]-[parse]-待解析文本：${a:b},解析结果：c

XPathParser

MyBatis提供的XPathParser类封装了XPath、Document和EntityResolver对象

public class XPathParser {

  private final Document document;//Document 对象
  private boolean validation;//是否开启验证
  private EntityResolver entityResolver;//用于加载本地的DTD文
  private Properties variables;//mybatis-config中定义的propteries集合
  private XPath xpath;//XPath对象
    ......省略......
}

默认情况下，对XML文档进行验证时，会根据XML文档开始位置指定的网址加载对应的DTD文件或XSD文件。
如果解析mybatis-config.xml配置文件，默认联网加载http://mybatis.org/dtd/mybatis-3-config.dtd这个DTD文档，当网络比较慢时会导致验证过程缓慢。在实践中往往会提前设置EntityResolver接口对象加载本地的DTD文件，从而避免联网加载DTD文件。XMLMapperEntityResolver是MyBatis提供的EntityResolver接口的实现类，

从类图中可以看出EntityResolver接口的核心方法是 resolveEntity,接下来我们看一下XMLMapperEntityResolver的具体实现

XPathParser.evalNode（）方法返回值类型是XNode，它对org.w3c.dom.Node对象做了封装和解析，其各个字段的含义如下：

private Node node；　//org.w3c.dom.Node对象
private String name；　//Node节点名称 
private String body；　//节点的内容 
private Properties attributes；//节点属性集合 
private Properties variables；//mybatis-config.xml配置文件中＜properties＞节点下定义的键值对

XNode的构造函数中会调用其parseAttributes（）方法和parseBody（）方法解析org.w3c.dom.Node对象中的信息，初始化attributes集合和body字段

private Properties parseAttributes(Node n) {
        Properties attributes = new Properties();
        //获取节点属性集合
        NamedNodeMap attributeNodes = n.getAttributes();
        if (attributeNodes != null) {
            for (int i = 0; i < attributeNodes.getLength(); i++) {
                Node attribute = attributeNodes.item(i);
                //PropertyParser处理每个属性中的占位符
                String value = PropertyParser.parse(attribute.getNodeValue(), variables);
                attributes.put(attribute.getNodeName(), value);
            }
        }
        return attributes;
    }

    private String parseBody(Node node) {
        String data = getBodyData(node);
        //当前节点不是文本节点
        if (data == null) {
            //获取子节点
            NodeList children = node.getChildNodes();
            for (int i = 0; i < children.getLength(); i++) {
                Node child = children.item(i);
                data = getBodyData(child);
                if (data != null) {
                    break;
                }
            }
        }
        return data;
    }

    private String getBodyData(Node child) {
        //只处理文本内容
        if (child.getNodeType() == Node.CDATA_SECTION_NODE
                || child.getNodeType() == Node.TEXT_NODE) {
            String data = ((CharacterData) child).getData();
            //使用PropertyParser处理文本节点中的占位符
            data = PropertyParser.parse(data, variables);
            return data;
        }
        return null;
    }