• 【Mybatis源码】XPathParser解析器

    XPathParser是Mybatis中定义的进行解析XML文件的类，此类用于读取XML文件中的节点文本与属性；本篇我们主要介绍XPathParser解析XML的原理。

    一、XPathParser构造方法

    这里我们介绍主要的构造方法

    1. public XPathParser(InputStream inputStream, boolean validation, Properties variables, EntityResolver entityResolver) {
    2.   commonConstructor(validation, variables, entityResolver);
    3.   this.document = createDocument(new InputSource(inputStream));
    4. }

    此构造方法有四个参数：

    inputStream：XML文件输入流

    validation：是否验证

    variables：XML文件中的变量属性集

    entityResolver：实体解析器

    此构造方法中主要执行了commonConstrutor、createDocument方法

    1、commonConstructor

    1. private void commonConstructor(boolean validation, Properties variables, EntityResolver entityResolver) {
    2.   this.validation = validation;
    3.   this.entityResolver = entityResolver;
    4.   this.variables = variables;
    5.   XPathFactory factory = XPathFactory.newInstance();
    6.   this.xpath = factory.newXPath();
    7. }

    此方法中主要是将参数赋值给对象的属性，并使用XPathFactory工厂创建XPath对象赋值给对象的xpath属性。

    2、createDocument

    1. private Document createDocument(InputSource inputSource) {
    2.   // important: this must only be called AFTER common constructor
    3.   try {
    4.     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    5.     factory.setValidating(validation);
    6.  
    7.     factory.setNamespaceAware(false);
    8.     factory.setIgnoringComments(true);
    9.     factory.setIgnoringElementContentWhitespace(false);
    10.     factory.setCoalescing(false);
    11.     factory.setExpandEntityReferences(true);
    12.  
    13.     DocumentBuilder builder = factory.newDocumentBuilder();
    14.     builder.setEntityResolver(entityResolver);
    15.     builder.setErrorHandler(new ErrorHandler() {
    16.       @Override
    17.       public void error(SAXParseException exception) throws SAXException {
    18.         throw exception;
    19.       }
    20.  
    21.       @Override
    22.       public void fatalError(SAXParseException exception) throws SAXException {
    23.         throw exception;
    24.       }
    25.  
    26.       @Override
    27.       public void warning(SAXParseException exception) throws SAXException {
    28.       }
    29.     });
    30.     return builder.parse(inputSource);
    31.   } catch (Exception e) {
    32.     throw new BuilderException("Error creating document instance.  Cause: " + e, e);
    33.   }
    34. }

    此方法中使用DocumentBuilderFactory工厂创建了DoucumentBuilder对象，通过DocumentBuilder对象将XML文件流转换成Document对象赋值给对象的document属性。

    二、获取XNode节点

    1. public XNode evalNode(String expression) {
    2.   return evalNode(document, expression);
    3. }

    evalNode方法用于根据XPath表达式获取XNode节点对象，此方法调用了evalNode的重载方法获取XNode节点对象。

    1. public XNode evalNode(Object root, String expression) {
    2.   Node node = (Node) evaluate(expression, root, XPathConstants.NODE);
    3.   if (node == null) {
    4.     return null;
    5.   }
    6.   return new XNode(this, node, variables);
    7. }

    此方法用于从root参数对象中根据XPath表达式获取XNode节点对象，方法中先使用evaluate方法获取Node节点对象，然后使用Node节点对象创建XNode节点对象并返回。

    1. private Object evaluate(String expression, Object root, QName returnType) {
    2.   try {
    3.     return xpath.evaluate(expression, root, returnType);
    4.   } catch (Exception e) {
    5.     throw new BuilderException("Error evaluating XPath.  Cause: " + e, e);
    6.   }
    7. }

    evaluate方法中使用xpath对象在root参数对象中查询XPath表达式对应的指定类型的结果。

    三、获取XNode节点列表

    1. public List evalNodes(String expression) {
    2.   return evalNodes(document, expression);
    3. }

    evalNodes方法用于根据XPath表达式获取XNode节点集合，此方法调用了evalNodes的重载方法获取XNode节点集合。

    1. public List evalNodes(Object root, String expression) {
    2.   List xnodes = new ArrayList();
    3.   NodeList nodes = (NodeList) evaluate(expression, root, XPathConstants.NODESET);
    4.   for (int i = 0; i < nodes.getLength(); i++) {
    5.     xnodes.add(new XNode(this, nodes.item(i), variables));
    6.   }
    7.   return xnodes;
    8. }

    此方法用于从root参数对象中根据XPath表达式获取XNode节点集合，方法中先使用evaluate方法获取Node节点集合，然后遍历Node节点创建XNode节点放入XNode节点集合中，最终返回XNode节点集合。

    1. private Object evaluate(String expression, Object root, QName returnType) {
    2.   try {
    3.     return xpath.evaluate(expression, root, returnType);
    4.   } catch (Exception e) {
    5.     throw new BuilderException("Error evaluating XPath.  Cause: " + e, e);
    6.   }
    7. }

    evaluate方法中使用xpath对象在root参数对象中查询XPath表达式对应的指定类型的结果。

    四、XNode节点类

    1、构造方法

    1. public XNode(XPathParser xpathParser, Node node, Properties variables) {
    2.   this.xpathParser = xpathParser;
    3.   this.node = node;
    4.   this.name = node.getNodeName();
    5.   this.variables = variables;
    6.   this.attributes = parseAttributes(node);
    7.   this.body = parseBody(node);
    8. }

    从构造方法中，可以看出XNode节点对象创建完成后，XNode中包含了XPathParser对象引用、Node节点对象引用、variable变量属性集引用，同时初始化了Node节点的属性、Node节点的内容数据。

    构造方法中使用parseAttributes转换了Node节点的属性，使用parseBody转换了Node节点的内容数据。

    下面我们分别看一下两个方法：

    1）parseAttributes

    1. private Properties parseAttributes(Node n) {
    2.   Properties attributes = new Properties();
    3.   NamedNodeMap attributeNodes = n.getAttributes();
    4.   if (attributeNodes != null) {
    5.     for (int i = 0; i < attributeNodes.getLength(); i++) {
    6.       Node attribute = attributeNodes.item(i);
    7.       String value = PropertyParser.parse(attribute.getNodeValue(), variables);
    8.       attributes.put(attribute.getNodeName(), value);
    9.     }
    10.   }
    11.   return attributes;
    12. }

    方法中先获取到Node的属性节点对象列表，再遍历属性节点对象获取到属性值，并使用PropertyParser类中的parse方法对属性值中的变量进行转换，最终将属性名称与属性值存储到XNode节点对象的attributes属性中。

    2）parseBody

    1. private String parseBody(Node node) {
    2.   String data = getBodyData(node);
    3.   if (data == null) {
    4.     NodeList children = node.getChildNodes();
    5.     for (int i = 0; i < children.getLength(); i++) {
    6.       Node child = children.item(i);
    7.       data = getBodyData(child);
    8.       if (data != null) {
    9.         break;
    10.       }
    11.     }
    12.   }
    13.   return data;
    14. }
    15.  
    16. private String getBodyData(Node child) {
    17.   if (child.getNodeType() == Node.CDATA_SECTION_NODE
    18.       || child.getNodeType() == Node.TEXT_NODE) {
    19.     String data = ((CharacterData) child).getData();
    20.     data = PropertyParser.parse(data, variables);
    21.     return data;
    22.   }
    23.   return null;
    24. }

    调用getBodyData获取Node节点的内容数据，如果获取到的内容数据不为null，则返回内容数据；获取的内容数据为null，则获取Node节点的子节点列表，遍历子节点列表，依次调用getBodyData获取子节点的内容数据，直到获取到不为null的内容数据后返回。

    getBodyData方法：获取节点内容数据，判断Node节点如果是文本节点或者CDATA节点，则直接获取节点的内容数据，再使用PropertyParser类中的parse方法对内容数据中的变量进行转换并返回，否则返回null

    2、获取内容数据

    1. public String getStringBody(String def) {
    2.   if (body == null) {
    3.     return def;
    4.   } else {
    5.     return body;
    6.   }
    7. }

    方法中判断内容数据如果为空，则返回默认值数据（def），否则返回内容数据。

    另外，此类方法还有很多，比如：

    1. public Boolean getBooleanBody(Boolean def) {
    2.   if (body == null) {
    3.     return def;
    4.   } else {
    5.     return Boolean.valueOf(body);
    6.   }
    7. }
    8.  
    9. public Integer getIntBody(Integer def) {
    10.   if (body == null) {
    11.     return def;
    12.   } else {
    13.     return Integer.parseInt(body);
    14.   }
    15. }
    16.  
    17. public Long getLongBody(Long def) {
    18.   if (body == null) {
    19.     return def;
    20.   } else {
    21.     return Long.parseLong(body);
    22.   }
    23. }
    24.  
    25. public Double getDoubleBody(Double def) {
    26.   if (body == null) {
    27.     return def;
    28.   } else {
    29.     return Double.parseDouble(body);
    30.   }
    31. }
    32.  
    33. public Float getFloatBody(Float def) {
    34.   if (body == null) {
    35.     return def;
    36.   } else {
    37.     return Float.parseFloat(body);
    38.   }
    39. }

    与getStringBody不同的是，getStringBody是为了得到String类型的内容数据，而这些方法都是为了得到对应类型的内容数据。

    3、获取属性值

    1. public String getStringAttribute(String name, String def) {
    2.   String value = attributes.getProperty(name);
    3.   if (value == null) {
    4.     return def;
    5.   } else {
    6.     return value;
    7.   }
    8. }

    方法中根据属性名称获取属性值，判断属性值如果为空，则返回默认值属性值（def），否则返回获取到的属性值。

    另外，此类方法还有很多，比如：

    1. public Boolean getBooleanAttribute(String name, Boolean def) {
    2.   String value = attributes.getProperty(name);
    3.   if (value == null) {
    4.     return def;
    5.   } else {
    6.     return Boolean.valueOf(value);
    7.   }
    8. }
    9.  
    10. public Integer getIntAttribute(String name, Integer def) {
    11.   String value = attributes.getProperty(name);
    12.   if (value == null) {
    13.     return def;
    14.   } else {
    15.     return Integer.parseInt(value);
    16.   }
    17. }
    18.  
    19. public Long getLongAttribute(String name, Long def) {
    20.   String value = attributes.getProperty(name);
    21.   if (value == null) {
    22.     return def;
    23.   } else {
    24.     return Long.parseLong(value);
    25.   }
    26. }
    27.  
    28. public Double getDoubleAttribute(String name, Double def) {
    29.   String value = attributes.getProperty(name);
    30.   if (value == null) {
    31.     return def;
    32.   } else {
    33.     return Double.parseDouble(value);
    34.   }
    35. }
    36.  
    37. public Float getFloatAttribute(String name, Float def) {
    38.   String value = attributes.getProperty(name);
    39.   if (value == null) {
    40.     return def;
    41.   } else {
    42.     return Float.parseFloat(value);
    43.   }
    44. }

    与getStringAttribute不同的是，getStringAttribute是为了得到String类型的属性值，而这些方法都是为了得到对应类型的属性值。

    4、获取子节点列表

    1. public List getChildren() {
    2.   List children = new ArrayList();
    3.   NodeList nodeList = node.getChildNodes();
    4.   if (nodeList != null) {
    5.     for (int i = 0, n = nodeList.getLength(); i < n; i++) {
    6.       Node node = nodeList.item(i);
    7.       if (node.getNodeType() == Node.ELEMENT_NODE) {
    8.         children.add(new XNode(xpathParser, node, variables));
    9.       }
    10.     }
    11.   }
    12.   return children;
    13. }
    1. 获取Node节点的所有子节点
    2. 遍历子节点创建了XNode节点对象并放入children集合中
    3. 返回children集合

    5、获取子节点属性集

    1. public Properties getChildrenAsProperties() {
    2.   Properties properties = new Properties();
    3.   for (XNode child : getChildren()) {
    4.     String name = child.getStringAttribute("name");
    5.     String value = child.getStringAttribute("value");
    6.     if (name != null && value != null) {
    7.       properties.setProperty(name, value);
    8.     }
    9.   }
    10.   return properties;
    11. }
    1. 调用getChildren获取到了XNode节点集合
    2. 遍历XNode节点，分别获取节点中的name、value属性对应的属性值name、value，如果name、value都存在，则将name、value作为键值对放到属性集中
    3. 返回属性集

    五、XPathParser的使用

    1、引入依赖

    2.     org.mybatis
    3.     mybatis
    4.     3.4.5
    7.     junit
    8.     junit
    9.     4.13.1
    10.     test

    2、准备XML文件

    在src/test/resources下的新建user_info.xml配置文件

    1. <user id="${id}">
    2.     <name>${name}name>
    3.     <age>20age>
    4.     <birth>
    5.         <year>1999year>
    6.         <month>2month>
    7.         <day>10day>
    8.     birth>
    9.     <educations>
    10.         <education>xx小学education>
    11.         <education>xx中学education>
    12.         <education>xx大学education>
    13.     educations>
    14. user>

    3、解析XML文件

    在src/test/java下的cn.horse.demo.parser包下新建XPathParserTest测试类

    1. package cn.horse.demo.parser;
    2.  
    3. import org.apache.ibatis.io.Resources;
    4. import org.apache.ibatis.parsing.XPathParser;
    5. import org.junit.Assert;
    6. import org.junit.Test;
    7.  
    8. import java.io.IOException;
    9. import java.io.InputStream;
    10. import java.util.Properties;
    11.  
    12. public class XPathParserTest {
    13.  
    14.     @Test
    15.     public void testXPathParserMethods() throws IOException {
    16.         InputStream inputStream = Resources.getResourceAsStream("user_info.xml");
    17.         Properties variables = new Properties();
    18.         variables.put("id", "1");
    19.         variables.put("name", "张三");
    20.         XPathParser parser = new XPathParser(inputStream, false, variables, null);
    21.         Assert.assertEquals("1", parser.evalNode("/user").getStringAttribute("id"));
    22.         Assert.assertEquals("1", parser.evalNode("/user/@id").getStringBody());
    23.         Assert.assertEquals("1", parser.evalNode("/user/@id").toString().trim());
    24.         Assert.assertEquals("张三", parser.evalNode("/user/name").getStringBody());
    25.         Assert.assertEquals((Long) 1999L, parser.evalNode("/user/birth/year").getLongBody());
    26.         Assert.assertEquals((Long) 2L, parser.evalNode("/user/birth/month").getLongBody());
    27.         Assert.assertEquals((Long) 10L, parser.evalNode("/user/birth/day").getLongBody());
    28.         Assert.assertEquals(4, parser.evalNodes("/user/*").size());
    29.         Assert.assertEquals(3, parser.evalNodes("/user/educations/education").size());
    30.     }
    31. }

    执行单元测试通过

  • 相关阅读:
    Docker安装启动Mysql
    32-Docker-常用命令详解-docker start/stop/restart
    【C语言 数据结构】顺序表的使用
    Web Components从技术解析到生态应用个人心得指北
    关于ORM框架多表增删改查
    ClickHouse入门手册1.0
    APISIX、APISIX Dashboard搭建及插件使用
    Python之字符串分割替换移除
    电工三级证(高级)实战项目:PLC控制步进电机正反转
    Html_Css问答集(2)
  • 原文地址：https://blog.csdn.net/m1729339749/article/details/133919176