2. 程式人生 > 其它 >【Mybatis】單獨使用mybatis的SQL模板解析

【Mybatis】單獨使用mybatis的SQL模板解析

阿新 • • 發佈：2021-11-30

前言

由於公司的專案歷史設計問題坑多不見底，新專案沒時間改，舊專案改不動。生產存在非常多的需要且只能通過資料庫指令碼改資料的違規操作。
每次開發到一半，一個工單就丟過來讓去生產改資料，天天寫指令碼，這怎麼受得了。
幾個季度下來，忍無可忍，我一拍桌子，決定chi.....從頭開發一個指令碼執行工具，管理寫過的指令碼，指令碼間可關聯執行，可跨資料庫。以解決臨時寫指令碼，及指令碼共享的問題。

設計上，指令碼執行工具的指令碼最早僅是佔位符，如 "{引數名}"，然後replaceAll，後面想了下，為啥不能像mybatis一樣，或者說，為啥不直接借mybatis的xml模板解析功能來解析指令碼呢。
————————————————————————————————

正文

通過走查程式碼，可以發現mybatis在XMLLanguageDriver類裡的createSqlSource裡實現SQL解析，並且支援使用<script></script>執行字串模板。
OK，既然如此，就想辦法按這裡的程式碼執行即可。

直接修改XPathParser的話太過複雜，還得理內部邏輯，這裡走模擬法

構建配置Configuration

首先需要一個mybatis的xml最小配置，這裡寫為字串：

  String EMPTY_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\r\n" //
            + "<!DOCTYPE configuration\r\n" //
            + " PUBLIC \"-//mybatis.org//DTD Config 3.0//EN\"\r\n" //
            + " \"http://mybatis.org/dtd/mybatis-3-config.dtd\">\r\n"//
            + "<configuration>\r\n" //
            + "</configuration>";

然後根據mybatis的實現構建Configuration

點選檢視程式碼 
InputStream inputStream = new ByteArrayInputStream(EMPTY_XML.getBytes(StandardCharsets.UTF_8));
XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder(inputStream, null, null);
Configuration configuration = xmlConfigBuilder.parse();

有了Configuration就可以建立XPathParser來解析SQL了

點選檢視程式碼 
String script = "<script>\nSELECT COUNT(0) FROM TABLE_NAME where 1=1 <if test=\"param!=null\"> AND num = #{param}</if> \n</script>";
XPathParser parser = new XPathParser(script, false, new Properties(), new XMLMapperEntityResolver());
SqlSource source = createSqlSource(configuration, parser.evalNode("/script"), null);

Map<String, String> params = new HashMap<>();
param.put("param", "1");
BoundSql boundSql = source.getBoundSql(params);
String sql = boundSql.getSql();

結果

通過上述程式碼解析出來的SQL，若帶了引數number，則為
SELECT COUNT(0) FROM TABLE_NAME where 1=1 AND num = ?

是帶佔位符的安全度高的預編譯SQL，使用時需要構建PrepareStatement，然後通過如jdbc傳入prepareStatement及手動set引數。

自動化prepareStatement引數設定

參照Mybatis的DefaultParameterHandler類的setParameters

建立PrepareStatement可以通過如springJdbc進行構建：
PreparedStatement ps = jdbcTemplate.getDataSource().getConnection().prepareStatement(boundSql.getSql());

然後呼叫DefaultParameterHandler的setParameters即可

獲取完整SQL

參照mybatis-plus的PerformanceInterceptor類，該類可通過Statement獲取SQL
需要的程式碼如下：

點選檢視程式碼 
    /**
     * COPY FROM {@link PerformanceInterceptor}
     */
    private static final String DruidPooledPreparedStatement = "com.alibaba.druid.pool.DruidPooledPreparedStatement";
    private static final String T4CPreparedStatement = "oracle.jdbc.driver.T4CPreparedStatement";
    private static final String OraclePreparedStatementWrapper = "oracle.jdbc.driver.OraclePreparedStatementWrapper";
    private Method oracleGetOriginalSqlMethod;
    private Method druidGetSQLMethod;

    /**
     * 獲取原始SQL， COPY FROM {@link PerformanceInterceptor}
     */
    private String getOriginSql(PreparedStatement statement) {
        String originalSql = null;
        String stmtClassName = statement.getClass().getName();
        if (DruidPooledPreparedStatement.equals(stmtClassName)) {
            try {
                if (druidGetSQLMethod == null) {
                    Class<?> clazz = Class.forName(DruidPooledPreparedStatement);
                    druidGetSQLMethod = clazz.getMethod("getSql");
                }
                Object stmtSql = druidGetSQLMethod.invoke(statement);
                if (stmtSql instanceof String) {
                    originalSql = (String) stmtSql;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else if (T4CPreparedStatement.equals(stmtClassName) || OraclePreparedStatementWrapper.equals(stmtClassName)) {
            try {
                if (oracleGetOriginalSqlMethod != null) {
                    Object stmtSql = oracleGetOriginalSqlMethod.invoke(statement);
                    if (stmtSql instanceof String) {
                        originalSql = (String) stmtSql;
                    }
                } else {
                    Class<?> clazz = Class.forName(stmtClassName);
                    oracleGetOriginalSqlMethod = getMethodRegular(clazz, "getOriginalSql");
                    if (oracleGetOriginalSqlMethod != null) {
                        // OraclePreparedStatementWrapper is not a public class, need set this.
                        oracleGetOriginalSqlMethod.setAccessible(true);
                        if (null != oracleGetOriginalSqlMethod) {
                            Object stmtSql = oracleGetOriginalSqlMethod.invoke(statement);
                            if (stmtSql instanceof String) {
                                originalSql = (String) stmtSql;
                            }
                        }
                    }
                }
            } catch (Exception e) {
                // ignore
            }
        }
        if (originalSql == null) {
            originalSql = statement.toString();
        }

        return originalSql;
    }

獲取出來的SQL在mybatis中為com.mxxxx : SELECT....，大概是這樣，需要擷取：

點選檢視程式碼 
    /**
     * 獲取sql語句開頭部分, COPY FROM {@link PerformanceInterceptor}
     */
    private int indexOfSqlStart(String sql) {
        String upperCaseSql = sql.toUpperCase();
        Set<Integer> set = new HashSet<>();
        set.add(upperCaseSql.indexOf("SELECT "));
        set.add(upperCaseSql.indexOf("UPDATE "));
        set.add(upperCaseSql.indexOf("INSERT "));
        set.add(upperCaseSql.indexOf("DELETE "));
        set.remove(-1);
        if (CollectionUtils.isEmpty(set)) {
            return -1;
        }
        List<Integer> list = new ArrayList<>(set);
        list.sort(Comparator.naturalOrder());
        return list.get(0);
    }

這樣就獲取出來完整的SQL了，可喜可賀。但是！

Oracle資料庫使用該方法無效，打印出來還是預編譯SQL

完整SQL第二方案

在第一個方案執行失敗的情況下（可遍歷字串看有沒有?），增加該方案：
參照：https://www.cnblogs.com/aipan/p/7237854.html
增加LoggableStatement，改造DefaultParameterHandler的setParameters（Copy出來作為新方法）：

點選檢視程式碼 
    @SuppressWarnings({"unchecked", "rawtypes"})
    private LoggableStatement buildPreparedStatement(JdbcTemplate jdbcTemplate, BoundSql boundSql) throws SQLException {
        PreparedStatement ps = jdbcTemplate.getDataSource().getConnection().prepareStatement(boundSql.getSql());
        // 改造點
        LoggableStatement ls = new LoggableStatement(ps, boundSql.getSql());
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        Object parameterObject = boundSql.getParameterObject();
        if (parameterMappings != null) {
            for (int i = 0; i < parameterMappings.size(); i++) {
                ParameterMapping parameterMapping = parameterMappings.get(i);
                if (parameterMapping.getMode() != ParameterMode.OUT) {
                    Object value;
                    String propertyName = parameterMapping.getProperty();
                    if (boundSql.hasAdditionalParameter(propertyName)) {
                        value = boundSql.getAdditionalParameter(propertyName);
                    } else if (parameterObject == null) {
                        value = null;
                    } else {
                        MetaObject metaObject = configuration.newMetaObject(parameterObject);
                        value = metaObject.getValue(propertyName);
                    }
                    TypeHandler typeHandler = parameterMapping.getTypeHandler();
                    JdbcType jdbcType = parameterMapping.getJdbcType();
                    if (value == null && jdbcType == null) {
                        jdbcType = configuration.getJdbcTypeForNull();
                    }
                    try {
                        typeHandler.setParameter(ls, i + 1, value, jdbcType);
                    } catch (TypeException | SQLException e) {
                        throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
                    }
                }
            }
        }

        return ls;
    }

在獲取完整SQL失敗後，即可通過LoggableStatement來獲取SQL：

if (!isCorrectGetSql(boundSql, originalSql)) {
   originalSql = statement.getQueryString();
}

————————————————————————————

上面提到專案的該類完整程式碼：

點選檢視程式碼 
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.nio.charset.StandardCharsets;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import org.apache.ibatis.builder.xml.XMLConfigBuilder;
import org.apache.ibatis.builder.xml.XMLMapperEntityResolver;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.ParameterMode;
import org.apache.ibatis.mapping.SqlSource;
import org.apache.ibatis.parsing.XNode;
import org.apache.ibatis.parsing.XPathParser;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.scripting.xmltags.XMLScriptBuilder;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeException;
import org.apache.ibatis.type.TypeHandler;
import org.springframework.jdbc.core.JdbcTemplate;

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;

/**
 * 使用Mybatis的XML解析來進行SQL構建的執行器
 */
public class MybatisTemplateSqlExcutor {

    /**
     * 指令碼模板
     */
    private static final String SCRIPT_TEMPLATE = "<script>\n%s\n</script>";

    /**
     * MP環境配置
     */
    private Configuration configuration;

    /**
     * COPY FROM {@link PerformanceInterceptor}
     */
    private static final String DruidPooledPreparedStatement = "com.alibaba.druid.pool.DruidPooledPreparedStatement";
    private static final String T4CPreparedStatement = "oracle.jdbc.driver.T4CPreparedStatement";
    private static final String OraclePreparedStatementWrapper = "oracle.jdbc.driver.OraclePreparedStatementWrapper";
    private Method oracleGetOriginalSqlMethod;
    private Method druidGetSQLMethod;

    /**
     * 構造器，初始化MP環境配置
     */
    public MybatisTemplateSqlExcutor() {
        InputStream inputStream = new ByteArrayInputStream(EMPTY_XML.getBytes(StandardCharsets.UTF_8));
        XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder(inputStream, null, null);
        configuration = xmlConfigBuilder.parse();
    }

    public String parseSql(JdbcTemplate jdbcTemplate, String sqlTemplate, Map<String, Object> params) throws SQLException {
        String script = String.format(SCRIPT_TEMPLATE, sqlTemplate);
        XPathParser parser = new XPathParser(script, false, new Properties(), new XMLMapperEntityResolver());
        SqlSource source = createSqlSource(configuration, parser.evalNode("/script"), Map.class);
        BoundSql boundSql = source.getBoundSql(params);
        LoggableStatement statement = buildPreparedStatement(jdbcTemplate, boundSql);
        String originalSql = getOriginSql(statement.getPreparedStatement());
        int index = indexOfSqlStart(originalSql);
        if (index > 0) {
            originalSql = originalSql.substring(index);
        }
        if (!isCorrectGetSql(boundSql, originalSql)) {
            originalSql = statement.getQueryString();
        }
        return originalSql;
    }

    /**
     * 從MP複製過來的指令碼解析方法
     */
    private SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
        XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
        return builder.parseScriptNode();
    }

    /**
     * 根據BoundSql組裝PreparedStatement，用於獲取實際SQL
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    private LoggableStatement buildPreparedStatement(JdbcTemplate jdbcTemplate, BoundSql boundSql) throws SQLException {
        PreparedStatement ps = jdbcTemplate.getDataSource().getConnection().prepareStatement(boundSql.getSql());
        LoggableStatement ls = new LoggableStatement(ps, boundSql.getSql());
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        Object parameterObject = boundSql.getParameterObject();
        if (parameterMappings != null) {
            for (int i = 0; i < parameterMappings.size(); i++) {
                ParameterMapping parameterMapping = parameterMappings.get(i);
                if (parameterMapping.getMode() != ParameterMode.OUT) {
                    Object value;
                    String propertyName = parameterMapping.getProperty();
                    if (boundSql.hasAdditionalParameter(propertyName)) {
                        value = boundSql.getAdditionalParameter(propertyName);
                    } else if (parameterObject == null) {
                        value = null;
                    } else {
                        MetaObject metaObject = configuration.newMetaObject(parameterObject);
                        value = metaObject.getValue(propertyName);
                    }
                    TypeHandler typeHandler = parameterMapping.getTypeHandler();
                    JdbcType jdbcType = parameterMapping.getJdbcType();
                    if (value == null && jdbcType == null) {
                        jdbcType = configuration.getJdbcTypeForNull();
                    }
                    try {
                        typeHandler.setParameter(ls, i + 1, value, jdbcType);
                    } catch (TypeException | SQLException e) {
                        throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
                    }
                }
            }
        }

        return ls;
    }

    /**
     * 獲取sql語句開頭部分
     */
    private int indexOfSqlStart(String sql) {
        String upperCaseSql = sql.toUpperCase();
        Set<Integer> set = new HashSet<>();
        set.add(upperCaseSql.indexOf("SELECT "));
        set.add(upperCaseSql.indexOf("UPDATE "));
        set.add(upperCaseSql.indexOf("INSERT "));
        set.add(upperCaseSql.indexOf("DELETE "));
        set.remove(-1);
        if (CollectionUtils.isEmpty(set)) {
            return -1;
        }
        List<Integer> list = new ArrayList<>(set);
        list.sort(Comparator.naturalOrder());
        return list.get(0);
    }

    /**
     * 獲取原始SQL， COPY FROM {@link PerformanceInterceptor}
     */
    private String getOriginSql(PreparedStatement statement) {
        String originalSql = null;
        String stmtClassName = statement.getClass().getName();
        if (DruidPooledPreparedStatement.equals(stmtClassName)) {
            try {
                if (druidGetSQLMethod == null) {
                    Class<?> clazz = Class.forName(DruidPooledPreparedStatement);
                    druidGetSQLMethod = clazz.getMethod("getSql");
                }
                Object stmtSql = druidGetSQLMethod.invoke(statement);
                if (stmtSql instanceof String) {
                    originalSql = (String) stmtSql;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else if (T4CPreparedStatement.equals(stmtClassName) || OraclePreparedStatementWrapper.equals(stmtClassName)) {
            try {
                if (oracleGetOriginalSqlMethod != null) {
                    Object stmtSql = oracleGetOriginalSqlMethod.invoke(statement);
                    if (stmtSql instanceof String) {
                        originalSql = (String) stmtSql;
                    }
                } else {
                    Class<?> clazz = Class.forName(stmtClassName);
                    oracleGetOriginalSqlMethod = getMethodRegular(clazz, "getOriginalSql");
                    if (oracleGetOriginalSqlMethod != null) {
                        // OraclePreparedStatementWrapper is not a public class, need set this.
                        oracleGetOriginalSqlMethod.setAccessible(true);
                        if (null != oracleGetOriginalSqlMethod) {
                            Object stmtSql = oracleGetOriginalSqlMethod.invoke(statement);
                            if (stmtSql instanceof String) {
                                originalSql = (String) stmtSql;
                            }
                        }
                    }
                }
            } catch (Exception e) {
                // ignore
            }
        }
        if (originalSql == null) {
            originalSql = statement.toString();
        }

        return originalSql;
    }

    /**
     * 獲取此方法名的具體 Method
     *
     * @param clazz class 物件
     * @param methodName 方法名
     * @return 方法
     */
    public Method getMethodRegular(Class<?> clazz, String methodName) {
        if (Object.class.equals(clazz)) {
            return null;
        }
        for (Method method : clazz.getDeclaredMethods()) {
            if (method.getName().equals(methodName)) {
                return method;
            }
        }
        return getMethodRegular(clazz.getSuperclass(), methodName);
    }

    /**
     * 判斷是否正確的獲取了SQL
     */
    private boolean isCorrectGetSql(BoundSql boundSql, String originSql) {
        return countQuestionMark(boundSql.getSql()) > countQuestionMark(originSql);
    }

    /**
     * 統計佔位符
     */
    private int countQuestionMark(String sql) {
        int result = 0;
        for (char c : sql.toCharArray())
            if (c == '?')
                result++;
        return result;
    }

    /**
     * 空MP配置模板，用於構建MP環境配置，（放這裡是由於部落格的編輯器識別問題，會導致高亮錯誤）
     */
    private static final String EMPTY_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\r\n"
            + "<!DOCTYPE configuration\r\n"
            + " PUBLIC \"-//mybatis.org//DTD Config 3.0//EN\"\r\n"
            + " \"http://mybatis.org/dtd/mybatis-3-config.dtd\">\r\n"
            + "<configuration>\r\n"
            + "</configuration>";
}

稱之為Excutor是因為這其實是個子類，只提供parseSql

其他

若有更好的方法，請務必告訴我(๑•̀ㅂ•́)و✧

相關推薦

【Mybatis】單獨使用mybatis的SQL模板解析

前言 由於公司的專案歷史設計問題坑多不見底，新專案沒時間改，舊專案改不動。生產存在非常多的需要且只能通過資料庫指令碼改資料的違規操作。

【轉】一張圖解析FastAdmin中的表格列表的功能

一張圖解析FastAdmin中的表格列表的功能 功能描述請根據圖片上的數字索引檢視對應功能說明。

【SpringMVC】檢視和檢視解析器

檢視和檢視解析器 Spring MVC如何解析檢視 檢視和檢視解析器 請求處理方法執行完成後，最終返回一個 ModelAndView物件。對於那些返回 String，View 或 ModeMap 等型別的處理方法，Spring MVC 也會在內部將它們裝配

【Mybatis】Mybatis實戰1

MyBatis 框架 資料持久層框架(DAO將資料持久化到資料庫),實現DAO層的程式碼。對JDBC程式碼的封裝。

【Mybatis】Mybatis實戰2

6).多表查詢-“一對多”(表設計、實體設計、DAO(mapper)設計) （1）關聯關係操作(一對多)

【LeetCode】簡單演算法模板（JAVA實現）

背景 總結部分簡單演算法的JAVA樣例模板 一、氣泡排序（BubbleSort） 1//氣泡排序

【MyBatis】多對多條件下插入中間表（使用insert標籤的屬性）

此文轉載自：https://blog.csdn.net/weixin_44757863/article/details/110010556 文章目錄 需求解決方案測試編寫Dao層Service層Test類

JDBC【4】-- SPI底層原理解析

前面已經講過SPI的基本實現原理了，demo也基本實現了，再來說說SPI。 http://aphysia.cn/archives/jdbcspi

【Golang】sync.WaitGroup原始碼解析

技術標籤：Golang原始碼解析gogolang sync.WaitGroup介紹 當我們在開發過程中，經常需要在開啟多個goroutine後，等待全部的goroutine執行完畢後才進行下一步的業務邏輯執行。此時我們可能會採用輪詢的方式去定時

【MyBatis】MyBatis CRUD

MyBtis CRUD 文章原始碼 基於代理 DAO 的 CRUD 根據 ID 查詢操作 在持久層介面中新增 findById 方法：

【MyBatis】MyBatis 連線池和事務控制

MyBatis 連線池和事務控制 MyBaits 連線池 實際開發中都會使用連線池，因為它可以減少獲取連線所消耗的時間。具體可檢視

【MyBatis】Spring整合原理（二）：建立 SqlSession

我們現在已經有一個DefaultSqlSessionFactory，按照程式設計式的開發過程，我們接下來就會建立一個 SqlSession 的實現類，但是在 Spring 裡面，我們不是直接使用 DefaultSqlSession 的，而是對它進行了一個封

【MyBatis】MyBatis 動態 SQL

MyBatis 動態SQL if 可以根據實體類的不同取值，使用不同的 SQL 語句來進行查詢。

【MyBatis】MyBatis 多表操作

MyBatis 多表操作 文章原始碼 一對一查詢 需求：查詢所有賬戶資訊，關聯查詢下單使用者資訊。

【MyBatis】MyBatis 延遲載入策略

MyBatis 延遲載入策略 文章原始碼 什麼是延遲載入 延遲載入，就是在需要用到資料時才進行載入，不需要用到資料時就不載入資料，也被成為懶載入。

【MyBatis】MyBatis 快取

MyBatis 快取 文章原始碼 什麼是快取 像大多數的持久化框架一樣，MyBatis 也提供了快取策略，通過快取策略來減少資料庫的查詢次數，從而提高效能。

【Mybatis】LRU緩衝的實現

Cache 介面定義 LRUCache 實現類 LRU (least recently used) 即“最近最少使用”緩衝淘汰演算法。

【Python】configparser - 配置檔案解析

技術標籤：Pythonpython 目錄 一. 介紹 二. 說明 三. 示例 四. 參考 一. 介紹 ConfigParse 類實現一個基本配置檔案解析器語言，提供了一個類似於Microsoft Windows INI 檔案的結構。

一個${}引發的慘案【MyBatis】

技術標籤：javamybatis 想必大家在MyBatis開發過程中，對#{}和${}符號很熟悉吧，很多面試官都很喜歡問#{}和${}之間的區別，那它們到底有什麼區別呢？

【MyBatis】Spring和Mybatis的整合

技術標籤：# MyBatismybatisspringjava 文章目錄 Spring和Mybatis的整合1、整合思想2、整合步驟（1）引入依賴（2）建立bean類（User.java）（3）Mapper介面檔案（UserMapper.java）（4）Mapper.xml檔案（UserM