mybatis xml檔案熱載入實現範例詳解

2023-03-27 06:00:46

引言

本文博主給大家帶來一篇 mybatis xml 檔案熱載入的實現教學，自博主從事開發工作使用 Mybatis 以來，如果需要修改 xml 檔案的內容，通常都需要重啟專案，因為不重啟的話，修改是不生效的，Mybatis 僅僅會在專案初始化的時候將 xml 檔案載入進記憶體。

本著提升開發效率且網上沒有能夠直接使用的輪子初衷，博主自己開發了 mybatis-xmlreload-spring-boot-starter 這個專案。它能夠幫助我們在Spring Boot + Mybatis的開發環境中修改 xml 後，不需要重啟專案就能讓修改過後 xml 檔案立即生效，實現熱載入功能。這裡先給出專案地址：

一、xml 檔案熱載入實現原理

1.1 xml 檔案怎麼樣解析

在Spring Boot + Mybatis的常規專案中，通過 org.mybatis.spring.SqlSessionFactoryBean 這個類的 buildSqlSessionFactory() 方法完成對 xml 檔案的載入邏輯，這個方法只會在自動設定類 MybatisAutoConfiguration 初始化操作時進行呼叫。這裡把 buildSqlSessionFactory() 方法中 xml 解析核心部分進行展示如下：

通過遍歷 this.mapperLocations 陣列（這個物件就是儲存了編譯後的所有 xml 檔案）完成對所有 xml 檔案的解析以及載入進記憶體。this.mapperLocations 解析邏輯在 MybatisProperties 類的 resolveMapperLocations() 方法中，它會解析 mybatis.mapperLocations 屬性中的 xml 路徑，將編譯後的 xml 檔案讀取進 Resource 陣列中。路徑解析的核心邏輯在 PathMatchingResourcePatternResolver 類的 getResources(String locationPattern) 方法中。大家有興趣可以自己研讀一下，這裡不多做介紹。

通過 xmlMapperBuilder.parse() 方法解析 xml 檔案各個節點，解析方法如下：

到這裡，我們就知道了 Mybatis 對 xml 檔案解析是通過 xmlMapperBuilder.parse() 方法完成並且只會在專案啟動時載入 xml 檔案。

1.2 實現思路

通過對上述 xml 解析邏輯進行分析，我們可以通過監聽 xml 檔案的修改，當監聽到修改操作時，直接呼叫 xmlMapperBuilder.parse() 方法，將修改過後的 xml 檔案進行重新解析，並替換記憶體中的對應屬性以此完成熱載入操作。這裡也就引出了本文所講的主角：mybatis-xmlreload-spring-boot-starter

二、mybatis-xmlreload-spring-boot-starter 登場

mybatis-xmlreload-spring-boot-starter 這個專案完成了博主上述的實現思路，使用技術如下：

修改 xml 檔案的載入邏輯。在原用 mybatis-spring 中，只會載入專案編譯過後的 xml 檔案，也就是 target 目錄下的 xml 檔案。但是在mybatis-xmlreload-spring-boot-starter中，我修改了這一點，它會載入專案 resources 目錄下的 xml 檔案，這樣對於 xml 檔案的修改操作是可以立馬觸發熱載入的。
通過 io.methvin.directory-watcher 來監聽 xml 檔案的修改操作，它底層是通過 java.nio 的WatchService 來實現。
相容 Mybatis-plus3.0，核心程式碼相容了 Mybatis-plus 自定義的 com.baomidou.mybatisplus.core.MybatisConfiguration 類，任然可以使用 xml 檔案熱載入功能。

2.1 核心程式碼

專案的結構如下：

核心程式碼在 MybatisXmlReload 類中，程式碼展示：

/**
 * mybatis-xml-reload核心xml熱載入邏輯
 */
public class MybatisXmlReload {
    private static final Logger logger = LoggerFactory.getLogger(MybatisXmlReload.class);
    /**
     * 是否啟動以及xml路徑的設定類
     */
    private MybatisXmlReloadProperties prop;
    /**
     * 獲取專案中初始化完成的SqlSessionFactory列表，對多資料來源進行處理
     */
    private List<SqlSessionFactory> sqlSessionFactories;
    public MybatisXmlReload(MybatisXmlReloadProperties prop, List<SqlSessionFactory> sqlSessionFactories) {
        this.prop = prop;
        this.sqlSessionFactories = sqlSessionFactories;
    }
    public void xmlReload() throws IOException {
        PathMatchingResourcePatternResolver patternResolver = new PathMatchingResourcePatternResolver();
        String CLASS_PATH_TARGET = File.separator + "target" + File.separator + "classes";
        String MAVEN_RESOURCES = "/src/main/resources";
        // 1. 解析專案所有xml路徑，獲取xml檔案在target目錄中的位置
        List<Resource> mapperLocationsTmp = Stream.of(Optional.of(prop.getMapperLocations()).orElse(new String[0]))
                .flatMap(location -> Stream.of(getResources(patternResolver, location))).toList();

        List<Resource> mapperLocations = new ArrayList<>(mapperLocationsTmp.size() * 2);
        Set<Path> locationPatternSet = new HashSet<>();
        // 2. 根據xml檔案在target目錄下的位置，進行路徑替換找到該xml檔案在resources目錄下的位置
        for (Resource mapperLocation : mapperLocationsTmp) {
            mapperLocations.add(mapperLocation);
            String absolutePath = mapperLocation.getFile().getAbsolutePath();
            File tmpFile = new File(absolutePath.replace(CLASS_PATH_TARGET, MAVEN_RESOURCES));
            if (tmpFile.exists()) {
                locationPatternSet.add(Path.of(tmpFile.getParent()));
                FileSystemResource fileSystemResource = new FileSystemResource(tmpFile);
                mapperLocations.add(fileSystemResource);
            }
        }
        // 3. 對resources目錄的xml檔案修改進行監聽
        List<Path> rootPaths = new ArrayList<>();
        rootPaths.addAll(locationPatternSet);
        DirectoryWatcher watcher = DirectoryWatcher.builder()
                .paths(rootPaths) // or use paths(directoriesToWatch)
                .listener(event -> {
                    switch (event.eventType()) {
                        case CREATE: /* file created */
                            break;
                        case MODIFY: /* file modified */
                            Path modifyPath = event.path();
                            String absolutePath = modifyPath.toFile().getAbsolutePath();
                            logger.info("mybatis xml file has changed:" + modifyPath);
                            // 4. 對多個資料來源進行遍歷，判斷修改過的xml檔案屬於那個資料來源
                            for (SqlSessionFactory sqlSessionFactory : sqlSessionFactories) {
                                try {
                                    // 5. 獲取Configuration物件
                                    Configuration targetConfiguration = sqlSessionFactory.getConfiguration();
                                    Class<?> tClass = targetConfiguration.getClass(), aClass = targetConfiguration.getClass();
                                    if (targetConfiguration.getClass().getSimpleName().equals("MybatisConfiguration")) {
                                        aClass = Configuration.class;
                                    }
                                    Set<String> loadedResources = (Set<String>) getFieldValue(targetConfiguration, aClass, "loadedResources");
                                    loadedResources.clear();

                                    Map<String, ResultMap> resultMaps = (Map<String, ResultMap>) getFieldValue(targetConfiguration, tClass, "resultMaps");
                                    Map<String, XNode> sqlFragmentsMaps = (Map<String, XNode>) getFieldValue(targetConfiguration, tClass, "sqlFragments");
                                    Map<String, MappedStatement> mappedStatementMaps = (Map<String, MappedStatement>) getFieldValue(targetConfiguration, tClass, "mappedStatements");
                                    // 6. 遍歷xml檔案
                                    for (Resource mapperLocation : mapperLocations) {
                                        // 7. 判斷是否是被修改過的xml檔案，否則跳過
                                        if (!absolutePath.equals(mapperLocation.getFile().getAbsolutePath())) {
                                            continue;
                                        }
                                        // 8. 重新解析xml檔案，替換Configuration物件的相對應屬性
                                        XPathParser parser = new XPathParser(mapperLocation.getInputStream(), true, targetConfiguration.getVariables(), new XMLMapperEntityResolver());
                                        XNode mapperXnode = parser.evalNode("/mapper");
                                        List<XNode> resultMapNodes = mapperXnode.evalNodes("/mapper/resultMap");
                                        String namespace = mapperXnode.getStringAttribute("namespace");
                                        for (XNode xNode : resultMapNodes) {
                                            String id = xNode.getStringAttribute("id", xNode.getValueBasedIdentifier());
                                            resultMaps.remove(namespace + "." + id);
                                        }

                                        List<XNode> sqlNodes = mapperXnode.evalNodes("/mapper/sql");
                                        for (XNode sqlNode : sqlNodes) {
                                            String id = sqlNode.getStringAttribute("id", sqlNode.getValueBasedIdentifier());
                                            sqlFragmentsMaps.remove(namespace + "." + id);
                                        }

                                        List<XNode> msNodes = mapperXnode.evalNodes("select|insert|update|delete");
                                        for (XNode msNode : msNodes) {
                                            String id = msNode.getStringAttribute("id", msNode.getValueBasedIdentifier());
                                            mappedStatementMaps.remove(namespace + "." + id);
                                        }
                                        try {
                                            // 9. 重新載入和解析被修改的 xml 檔案
                                            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
                                                    targetConfiguration, mapperLocation.toString(), targetConfiguration.getSqlFragments());
                                            xmlMapperBuilder.parse();
                                        } catch (Exception e) {
                                            logger.error(e.getMessage(), e);
                                        }
                                        logger.info("Parsed mapper file: '" + mapperLocation + "'");
                                    }
                                } catch (Exception e) {
                                    logger.error(e.getMessage(), e);
                                }
                            }
                            break;
                        case DELETE: /* file deleted */
                            break;
                    }
                })
                .build();
        ThreadFactory threadFactory = r -> {
            Thread thread = new Thread(r);
            thread.setName("xml-reload");
            thread.setDaemon(true);
            return thread;
        };
        watcher.watchAsync(new ScheduledThreadPoolExecutor(1, threadFactory));
    }

    /**
     * 根據xml路徑獲取對應實際檔案
     *
     * @param location 檔案位置
     * @return Resource[]
     */
    private Resource[] getResources(PathMatchingResourcePatternResolver patternResolver, String location) {
        try {
            return patternResolver.getResources(location);
        } catch (IOException e) {
            return new Resource[0];
        }
    }

    /**
     * 根據反射獲取 Configuration 物件中屬性
     */
    private static Object getFieldValue(Configuration targetConfiguration, Class<?> aClass,
                                        String filed) throws NoSuchFieldException, IllegalAccessException {
        Field resultMapsField = aClass.getDeclaredField(filed);
        resultMapsField.setAccessible(true);
        return resultMapsField.get(targetConfiguration);
    }
}
複製程式碼

程式碼執行邏輯：

解析組態檔指定的 xml 路徑，獲取 xml 檔案在 target 目錄下的位置
根據 xml 檔案在 target 目錄下的位置，進行路徑替換找到 xml 檔案所在 resources 目錄下的位置
對 resources 目錄的 xml 檔案的修改操作進行監聽
對多個資料來源進行遍歷，判斷修改過的 xml 檔案屬於那個資料來源
根據 Configuration 物件獲取對應的標籤屬性
遍歷 resources 目錄下 xml 檔案列表
判斷是否是被修改過的 xml 檔案，否則跳過
解析被修改的 xml 檔案，替換 Configuration 物件中的相對應屬性
重新載入和解析被修改的 xml 檔案

2.2 安裝方式

在 Spring Boot3.0 中，當前博主提供了mybatis-xmlreload-spring-boot-starter在 Maven 專案中的座標地址如下

<dependency>
    <groupId>com.wayn</groupId>
    <artifactId>mybatis-xmlreload-spring-boot-starter</artifactId>
    <version>3.0.3.m1</version>
</dependency>
複製程式碼

在 Spring Boot2.0 Maven 專案中的座標地址如下

<dependency>
    <groupId>com.wayn</groupId>
    <artifactId>mybatis-xmlreload-spring-boot-starter</artifactId>
    <version>2.0.1.m1</version>
</dependency>
複製程式碼

2.3 使用設定

Maven 專案寫入mybatis-xmlreload-spring-boot-starter座標後即可使用本專案功能，預設是不啟用 xml 檔案的熱載入功能，想要開啟的話通過在專案組態檔中設定 mybatis-xml-reload.enabled 為 true，並指定 mybatis-xml-reload.mapper-locations 屬性，也就是 xml 檔案位置即可啟動。具體設定如下：

# mybatis xml檔案熱載入設定
mybatis-xml-reload:
  # 是否開啟 xml 熱更新，true開啟，false不開啟，預設為false
  enabled: true 
  # xml檔案位置，eg: `classpath*:mapper/**/*Mapper.xml,classpath*:other/**/*Mapper.xml`
  mapper-locations: classpath:mapper/*Mapper.xml
複製程式碼