mybatis xpath實現

原創 pro_tian 2020-02-22 13:38

Java 5 推出了 javax.xml.xpath 包，這是一個用於 XPath 文檔查詢的獨立於 XML 對象模型的庫。

強大的xpath表達式支持對xml document文檔檢索信息。

 

 

<?xml version="1.0" encoding="UTF-8"?>

<inventory>
    <book year="2000">
        <title>Snow Crash</title>
        <author>Neal Stephenson</author>
        <publisher>Spectra</publisher>
        <isbn>0553380958</isbn>
        <price>14.95</price>
    </book>
 
    <book year="2005">
        <title>Burning Tower</title>
        <author>Larry Niven</author>
        <author>Jerry Pournelle</author>
        <publisher>Pocket</publisher>
        <isbn>0743416910</isbn>
        <price>5.99</price>
    </book>
 
    <book year="1995">
        <title>Zodiac</title>
        <author>Neal Stephenson</author>
        <publisher>Spectra</publisher>
        <isbn>0553573862</isbn>
        <price>7.50</price>
    </book>
</inventory>

 

import java.io.IOException;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import javax.xml.parsers.*;
import javax.xml.xpath.*;
public class XPathExample {
	 public static void main(String[] args) 
	   throws ParserConfigurationException, SAXException, 
	          IOException, XPathExpressionException {
		//創建 XPathFactory：
	    DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
	    domFactory.setNamespaceAware(true); // never forget this!
	    DocumentBuilder builder = domFactory.newDocumentBuilder();
	    Document doc = builder.parse("book.xml");
	    
	    XPathFactory factory = XPathFactory.newInstance();
	    //這個工廠創建 XPath 對象：
	    XPath xpath = factory.newXPath();
	    //設置命名空間
//	    xpath.setNamespaceContext(new PersonalNamespaceContext());
	    //XPath 對象編譯 XPath 表達式：
	    XPathExpression expr  = xpath.compile("//book[author='Neal Stephenson']/title/text()");
	    //doc是整個節點
	    /**
	     * XPathConstants.NODESET
			XPathConstants.BOOLEAN
			XPathConstants.NUMBER
			XPathConstants.STRING
			XPathConstants.NODE
			定義了返回類型
			xpath 和java的映射關係
			number 映射爲 java.lang.Double
			string 映射爲 java.lang.String
			boolean 映射爲 java.lang.Boolean
			node-set 映射爲 org.w3c.dom.NodeList
	     */
	    Object result = expr.evaluate(doc, XPathConstants.NODESET);
	    //類型轉換
	    NodeList nodes = (NodeList) result;
	    for (int i = 0; i < nodes.getLength(); i++) {
	        System.out.println(nodes.item(i).getNodeValue()); 
	    }
	  }
}

 

 

xpath 表達式代碼

 

XPathExpression expr  = xpath.compile("//book[author='Neal Stephenson']/title/text()");

 //book[author='Neal Stephenson'book標籤 下的text爲Neal Stephenson的author標籤

 

/title/test()是title 標籤的文本

 

 

很簡單吧，再說一下

 

實體解析器SAX EntityResolver

這裏有它詳細的解釋：http://www.ibm.com/developerworks/cn/xml/tips/x-tipent/

讓xml文檔包含外部實體引用

 

package com.ibm.developerWorks;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
public class CopyrightResolver implements EntityResolver {
 public InputSource resolveEntity(String publicID, String systemID)
 throws SAXException {
 if (systemID.equals("http://www.ibm.com/developerworks/copyright.xml")) {
 // Return local copy of the copyright.xml file
 return new InputSource("/usr/local/content/localCopyright.xml");
 }
 // If no match, returning null makes process continue normally
 return null;
 }

 再你的xml解析類中每次解析都會調用這個方法，這樣就避免了每次都要加載外部資源的消耗。

 

xpase的公用類：

 

 

import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import javax.xml.namespace.QName;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathFactory;

import org.apache.ibatis.builder.BuilderException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.EntityResolver;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

public class XPathParser {

  private Document document;//dom對象
  private boolean validation;//是否驗證 domFactory.setNamespaceAware(validation);
  private EntityResolver entityResolver;//實體解析器
  private Properties variables;//配置文件
  private XPath xpath;//xpath

  public XPathParser(String xml) {
    commonConstructor(false, null, null);//初始化XPath對象
    this.document = createDocument(new InputSource(new StringReader(xml)));//獲取dom對象
  }

  public XPathParser(Reader reader) {
    commonConstructor(false, null, null);
    this.document = createDocument(new InputSource(reader));
  }

  public XPathParser(InputStream inputStream) {
    commonConstructor(false, null, null);
    this.document = createDocument(new InputSource(inputStream));
  }

  public XPathParser(Document document) {
    commonConstructor(false, null, null);
    this.document = document;
  }

  public XPathParser(String xml, boolean validation) {
    commonConstructor(validation, null, null);
    this.document = createDocument(new InputSource(new StringReader(xml)));
  }

  public XPathParser(Reader reader, boolean validation) {
    commonConstructor(validation, null, null);
    this.document = createDocument(new InputSource(reader));
  }

  public XPathParser(InputStream inputStream, boolean validation) {
    commonConstructor(validation, null, null);
    this.document = createDocument(new InputSource(inputStream));
  }

  public XPathParser(Document document, boolean validation) {
    commonConstructor(validation, null, null);
    this.document = document;
  }

  public XPathParser(String xml, boolean validation, Properties variables) {
    commonConstructor(validation, variables, null);
    this.document = createDocument(new InputSource(new StringReader(xml)));
  }

  public XPathParser(Reader reader, boolean validation, Properties variables) {
    commonConstructor(validation, variables, null);
    this.document = createDocument(new InputSource(reader));
  }

  public XPathParser(InputStream inputStream, boolean validation, Properties variables) {
    commonConstructor(validation, variables, null);
    this.document = createDocument(new InputSource(inputStream));
  }

  public XPathParser(Document document, boolean validation, Properties variables) {
    commonConstructor(validation, variables, null);
    this.document = document;
  }

  public XPathParser(String xml, boolean validation, Properties variables, EntityResolver entityResolver) {
    commonConstructor(validation, variables, entityResolver);
    this.document = createDocument(new InputSource(new StringReader(xml)));
  }

  public XPathParser(Reader reader, boolean validation, Properties variables, EntityResolver entityResolver) {
    commonConstructor(validation, variables, entityResolver);
    this.document = createDocument(new InputSource(reader));
  }

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

  public XPathParser(Document document, boolean validation, Properties variables, EntityResolver entityResolver) {
    commonConstructor(validation, variables, entityResolver);
    this.document = document;
  }

  public void setVariables(Properties variables) {
    this.variables = variables;
  }

  public String evalString(String expression) {
    return evalString(document, expression);
  }

  public String evalString(Object root, String expression) {
    String result = (String) evaluate(expression, root, XPathConstants.STRING);
    result = PropertyParser.parse(result, variables);
    return result;
  }

  public Boolean evalBoolean(String expression) {
    return evalBoolean(document, expression);
  }

  public Boolean evalBoolean(Object root, String expression) {
    return (Boolean) evaluate(expression, root, XPathConstants.BOOLEAN);
  }

  public Short evalShort(String expression) {
    return evalShort(document, expression);
  }

  public Short evalShort(Object root, String expression) {
    return Short.valueOf(evalString(root, expression));
  }

  public Integer evalInteger(String expression) {
    return evalInteger(document, expression);
  }

  public Integer evalInteger(Object root, String expression) {
    return Integer.valueOf(evalString(root, expression));
  }

  public Long evalLong(String expression) {
    return evalLong(document, expression);
  }

  public Long evalLong(Object root, String expression) {
    return Long.valueOf(evalString(root, expression));
  }

  public Float evalFloat(String expression) {
    return evalFloat(document, expression);
  }

  public Float evalFloat(Object root, String expression) {
    return Float.valueOf(evalString(root, expression));
  }

  public Double evalDouble(String expression) {
    return evalDouble(document, expression);
  }

  public Double evalDouble(Object root, String expression) {
    return (Double) evaluate(expression, root, XPathConstants.NUMBER);
  }

  public List<XNode> evalNodes(String expression) {
    return evalNodes(document, expression);
  }

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

  public XNode evalNode(String expression) {
    return evalNode(document, expression);
  }

  public XNode evalNode(Object root, String expression) {
    Node node = (Node) evaluate(expression, root, XPathConstants.NODE);
    if (node == null) {
      return null;
    }
    return new XNode(this, node, variables);
  }

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

  private Document createDocument(InputSource inputSource) {
    // important: this must only be called AFTER common constructor
    try {
      DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
      factory.setValidating(validation);

      factory.setNamespaceAware(false);
      factory.setIgnoringComments(true);
      factory.setIgnoringElementContentWhitespace(false);
      factory.setCoalescing(false);
      factory.setExpandEntityReferences(true);

      DocumentBuilder builder = factory.newDocumentBuilder();
      builder.setEntityResolver(entityResolver);//設置實體解析器
      builder.setErrorHandler(new ErrorHandler() {
        public void error(SAXParseException exception) throws SAXException {
          throw exception;
        }

        public void fatalError(SAXParseException exception) throws SAXException {
          throw exception;
        }

        public void warning(SAXParseException exception) throws SAXException {
        }
      });
      return builder.parse(inputSource);
    } catch (Exception e) {
      throw new BuilderException("Error creating document instance.  Cause: " + e, e);
    }
  }

  private void commonConstructor(boolean validation, Properties variables, EntityResolver entityResolver) {
    this.validation = validation;
    this.entityResolver = entityResolver;
    this.variables = variables;
    XPathFactory factory = XPathFactory.newInstance();
    this.xpath = factory.newXPath();
  }

}

 

 

 

這裏用到了一個字符串解析器：

PropertyParser 它是來處理字符串中${}這樣的字符，去配置文件中查找。

 

解析器模式：

 

 

 

import java.util.Properties;

public class 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 {
    private Properties variables;

    public VariableTokenHandler(Properties variables) {
      this.variables = variables;
    }

    public String handleToken(String content) {
      if (variables != null && variables.containsKey(content)) {
        return variables.getProperty(content);
      }
      return "${" + content + "}";
    }
  }
}

 

 

GenericTokenParser.java

 

public class GenericTokenParser {

  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) {
    StringBuilder builder = new StringBuilder();
    if (text != null && text.length() > 0) {//如果傳入的字符串有值
      //將字符串轉爲字符數組
      char[] src = text.toCharArray();
      int offset = 0;
      //判斷openToken在text中的位置，注意indexOf函數的返回值-1表示不存在，0表示在在開頭的位置
      int start = text.indexOf(openToken, offset);
      while (start > -1) {
        if (start > 0 && src[start - 1] == '\\') {
          //如果text中在openToken前存在轉義符就將轉義符去掉。如果openToken前存在轉義符，start的值必然大於0，最小也爲1
          //因爲此時openToken是不需要進行處理的，所以也不需要處理endToken。接着查找下一個openToken
          builder.append(src, offset, start - 1).append(openToken);
          offset = start + openToken.length();//重設offset
        } else {
          int end = text.indexOf(closeToken, start);
          if (end == -1) {//如果不存在openToken，則直接將offset位置後的字符添加到builder中
            builder.append(src, offset, src.length - offset);
            offset = src.length;//重設offset
          } else {
            builder.append(src, offset, start - offset);//添加openToken前offset後位置的字符到bulider中
            offset = start + openToken.length();//重設offset
            String content = new String(src, offset, end - offset);//獲取openToken和endToken位置間的字符串
            builder.append(handler.handleToken(content));//調用handler進行處理
            offset = end + closeToken.length();//重設offset
          }
        }
        start = text.indexOf(openToken, offset);//開始下一個循環
      }
      //只有當text中不存在openToken且text.length大於0時纔會執行下面的語句
      if (offset < src.length) {
        builder.append(src, offset, src.length - offset);
      }
    }
    return builder.toString();
  }

}

 簡單的說，這個函數的作用就是將openToken和endToken間的字符串取出來用handler處理下，然後再拼接到一塊。我們接下來看一個具體的handler，瞭解下它對傳入的字符串做了怎樣的處理。

 

 

在XMLConfigBuilder這個類中有它的調用實例:

 

 

 

  //很關鍵是xpath的表達式語言 匹配對象 放入configuration中 
  private void parseConfiguration(XNode root) {
    try {
      propertiesElement(root.evalNode("properties")); //issue #117 read properties first
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      settingsElement(root.evalNode("settings"));
      environmentsElement(root.evalNode("environments")); // read it after objectFactory and objectWrapperFactory issue #631
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers"));
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

 這裏使用瞭解析器設計模式，這裏的文件可以單獨作爲我們以後對xml文件解析的使用。

pro_tian
發佈了35 篇原創文章 · 獲贊 1 · 訪問量 1萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

淺談MyBatis-Plus學習之公共字段自動填充

一、公共字段自動填充簡介 顧名思義：就是在更新或插入數據時，如果數據項沒有設置，則會填充默認的值 在這裏就會涉及到元數據處理接口以及它的兩個方法： com.baomidou.mybatisplus.mapper.MetaObjectHan

osc_27sxxx5r 2024-05-13 23:34:29

Spring開發：動態代理的藝術與實踐

本文分享自華爲雲社區《Spring高手之路17——動態代理的藝術與實踐》，作者： 磚業洋__。 1. 背景 動態代理是一種強大的設計模式，它允許開發者在運行時創建代理對象，用於攔截對真實對象的方法調用。這種技術在實現面向切面編程（AOP）

原創 2024-04-16 22:33:07

代碼生成器之如何快速生成後端接口

前言 在現代軟件開發中，重複性的增刪改查邏輯代碼的編寫往往非常耗時且容易出錯。爲了提高開發效率，減少手動維護的成本，代碼生成器就成爲了一個非常重要的工具，本文小編就將爲大家介紹一下如何利用一個開源項目快速生成數據接口。 實現方式 環境準備

原創 2024-03-11 23:29:01

mybatis使用，UpdateWrapper時間更新問題

//批量更訂單刪除狀態：需要set時間 NeoCrmOrder updateNeoCrmCustomer = new NeoCrmOrder(); return neoCrmOrderMapper.update(updateNeoCrmCu

原創 2024-03-08 00:44:23

迄今爲止最完整的DDD實踐

一、爲什麼需要DDD 複雜系統設計：系統多，業務邏輯複雜，概念不清晰，有什麼合適的方法幫助我們理清楚邊界，邏輯和概念？ 多團隊協同：邊界不清晰，系統依賴複雜，語言不統一導致溝通和理解困難。有沒有一種方式把業務和技術概念統一，大家用一種語

原創 2023-08-24 00:29:34

crabc-源碼閱讀記錄

crabc 項目地址： https://gitee.com/linebyte/crabc.git 一、接口地址匹配功能 控制器 匹配 /api/web 開頭的請求，參數通過 @RequestParam Map<String, Object

原創 2023-08-11 23:59:49

【架構與設計】常見微服務分層架構的區別和落地實踐

作者：京東科技 康志興 前言 從強調內外隔離的六邊形架構，逐漸發展衍生出的層層遞進、注重領域模型的洋蔥架構，再到和DDD完美契合的整潔架構。架構風格的不斷演進，其實就是爲了適應軟件需求越來越複雜的特點。 可以看到，越現代的架構風格越傾向於

原創 2023-04-18 12:00:15

StarRocks簡單使用

從clickhouse遷移到StarRocks，研究討論後，決定使用flink進行kafka同步到StarRocks 1、數據模型 StarRocks 的數據模型主要分爲3類: Aggregate，聚合模型 Unique，主鍵模型 Dup

原創 2023-03-29 21:24:49

Mybatis的五種分頁方式詳解

  第一種：LIMIT關鍵字 1，mapper代碼 select * from tb_user limit #{pageNo}, #{pageSize} 2，業務層直接調用 public List findByPageInfo

原創 2023-03-27 00:18:32

MyBatis轉義符號問題集

MyBatis轉義符號問題集 MyBatis 在XML文件、註解中編寫sql語句時，對於>=、<=、<等符號需要轉義後或使用 <![CDATA[]]>包裹(註解中無法使用)才正常使用 下面代碼片段沒有對<=符號進行轉義，無法正常運行 ...

原創 2023-02-25 13:09:19

IDEA插件Easy Code自定義模板

EasyCode 介紹 EasyCode是基於IntelliJ IDEA Ultimate版開發的一個代碼生成插件，主要通過自定義模板（基於velocity）來生成各種你想要的代碼。 通常用於生成Entity、Dao、Service、C

荼靡旖旎 2023-02-25 00:26:51

Mybatis源碼解析06-關鍵組件ParameterHandler

ParameterHandler顯然是用來處理參數的，主要是用來設置PreparedStatement的參數，接口只有兩個方法，一個是獲取參數對象，一個是設置PreparedStatement的參數。PreparementStatement

原創 2023-02-14 23:57:34

Mybatis源碼解析-配置、啓動加載

mybatis是目前非常流行的ORM框架，在其基礎上還衍生了mybatis-plus)等優秀的框架。mybatis簡單，易用，易擴展。 接下來我們用一個簡單的例子（幾乎包含所有配置）來看一下mybatis相關的配置項 下面是一個包含用戶、商

原創 2023-01-19 23:36:19

開源十年，AOSuite 開發平臺停止維護 [EOL]

AOSuite 是我在 2006 - 2016 年間開發和維護的一節開源項目。那還是一個 jQuery UI 和 ExtJS 橫行的年代。現在想來還滿滿都是回憶。隨着前端技術的發展和後端微服務技術的流行，AOSuite 到了該退場的時候了。

原創 2022-12-24 22:05:18

Haskell 實現京東優惠券爬取的詳細步驟解析

在當今的電商行業中，優惠券活動是吸引用戶的一種重要方式。京東作爲中國領先的電商平臺之一，其優惠券活動頻繁且多樣，爲用戶提供了豐富的購物體驗。然而，想要及時獲取最新的京東優惠券信息並非易事，尤其是在優惠券數量龐大的情況下。爲了解決這一問題，

原創 2024-04-28 23:27:18