mybatis xml文件热加载实现示例详解

 

引言

本文博主给大家带来一篇 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 文件各个节点,解析方法如下:

简单来说,这个方法会解析 xml 文件中的 mapper|resultMap|cache|cache-ref|sql|select|insert|update|delete 等标签。将他们保存在 org.apache.ibatis.session.Configuration 类的对应属性中,如下展示:

到这里,我们就知道了 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

 

最后

欢迎大家使用mybatis-xmlreload-spring-boot-starter,使用中遇到问题可以提交 issue 或者加博主私人微信waynaqua给你解决。 再附项目地址:

  • github.com/wayn111/myb…

希望这个项目能够提升大家的日常开发效率,节约重启次数

以上就是mybatis xml文件热加载实现示例详解的详细内容,更多关于mybatis xml文件热加载的资料请关注编程宝库其它相关文章!

本文讲解"Java数据结构之HashMap和HashSet源码分析",希望能够解决相关问题。1、认识 HashMap 和 HashSetTreeMap 和 TreeSet实现了 So ...