个人随笔
目录
SpringBoot+MyBatis 实现可配置报表与批量导入更新笔记（mybatis模式）
2026-01-14 11:01:42

一、需求核心

  1. 可配置报表系统：报表查询 SQL 存储在数据库，前端传递参数，需利用 MyBatis 预编译防止 SQL 注入。

  2. 批量导入/更新：Excel 导入目标表名、字段映射可配置，同样保证预编译特性与安全性，贴合 MyBatis Mapper+XML 主流开发模式。

二、核心实现思路

  1. 复用 MyBatis 生态：基于 Mapper 接口、SqlSource 解析、预编译机制，不脱离日常开发模式。

  2. SQL 模板设计：数据库中配置的 SQL 直接使用 MyBatis 风格 #{参数名} 占位符，保障预编译能力。

  3. 动态 SQL 执行：通过 MyBatis@SelectProvider/@InsertProvider 注解或 XML 动态 SQL 语法，解析数据库中的 SQL 模板。

  4. 安全校验机制：表名、字段名通过白名单校验（防止注入），参数统一用 #{} 包裹（预编译转义）。

  5. 配置化映射：设计报表 SQL 配置表、Excel 导入配置表，存储 SQL 模板、表名、字段映射关系。

三、具体实现

3.1 数据库表设计（核心配置表）

  2. -- 报表SQL配置表：存储可配置的报表查询模板
  3. CREATE TABLE report_config (
  4.     id BIGINT PRIMARY KEY AUTO_INCREMENT,
  5.     report_code VARCHAR(50) NOT NULL COMMENT '报表编码（唯一）',
  6.     sql_template TEXT NOT NULL COMMENT 'SQL模板（使用#{参数名}占位符，如：SELECT * FROM user WHERE name = #{name}）',
  7.     create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
  8.     update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  9.     UNIQUE KEY uk_report_code (report_code)
  10. ) COMMENT '报表SQL配置表';
  12. -- Excel导入配置表：存储导入规则
  13. CREATE TABLE excel_import_config (
  14.     id BIGINT PRIMARY KEY AUTO_INCREMENT,
  15.     import_code VARCHAR(50) NOT NULL COMMENT '导入编码（唯一）',
  16.     target_table VARCHAR(50) NOT NULL COMMENT '目标表名',
  17.     column_mapping JSON NOT NULL COMMENT '列映射：{"excel列名":"数据库字段名"}',
  18.     create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
  19.     update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  20.     UNIQUE KEY uk_import_code (import_code)
  21. ) COMMENT 'Excel导入配置表';
  23. -- 初始化测试数据
  24. INSERT INTO report_config (report_code, sql_template) VALUES 
  25. ('user_query', 'SELECT * FROM user WHERE name = #{name} AND age = #{age}');
  27. INSERT INTO excel_import_config (import_code, target_table, column_mapping) VALUES 
  28. ('user_import', 'user', '{"姓名":"name","年龄":"age","手机号":"phone"}');

3.2 核心依赖（pom.xml）

  2. <dependencies>
  3.     <!-- SpringBoot核心 -->
  4.     <dependency>
  5.         <groupId>org.springframework.boot</groupId>
  6.         <artifactId>spring-boot-starter-web</artifactId>
  7.     </dependency>
  8.     <!-- MyBatis整合SpringBoot -->
  9.     <dependency>
  10.         <groupId>org.mybatis.spring.boot</groupId>
  11.         <artifactId>mybatis-spring-boot-starter</artifactId>
  12.         <version>3.0.3</version>
  13.     </dependency>
  14.     <!-- MySQL驱动 -->
  15.     <dependency>
  16.         <groupId>com.mysql</groupId>
  17.         <artifactId>mysql-connector-j</artifactId>
  18.         <scope>runtime</scope>
  19.     </dependency>
  20.     <!-- EasyExcel：Excel解析 -->
  21.     <dependency>
  22.         <groupId>com.alibaba</groupId>
  23.         <artifactId>easyexcel</artifactId>
  24.         <version>3.3.2</version>
  25.     </dependency>
  26.     <!-- 工具类 -->
  27.     <dependency>
  28.         <groupId>cn.hutool</groupId>
  29.         <artifactId>hutool-all</artifactId>
  30.         <version>5.8.22</version>
  31.     </dependency>
  32. </dependencies>

3.3 核心通用 Mapper 设计（关键）

定义通用 Mapper 接口，统一处理动态 SQL 执行、批量插入，贴合 MyBatis 开发规范。

  2. import org.apache.ibatis.annotations.Param;
  3. import org.apache.ibatis.annotations.InsertProvider;
  4. import org.apache.ibatis.annotations.SelectProvider;
  6. import java.util.List;
  7. import java.util.Map;
  9. /**
  10.  * 通用动态SQL执行Mapper（支持可配置报表查询、批量导入）
  11.  */
  12. public interface DynamicSqlMapper {
  14.     /**
  15.      * 执行动态查询SQL（报表查询）
  16.      * @param sqlTemplate 从数据库加载的SQL模板（含#{参数}）
  17.      * @param params 前端传递的参数
  18.      * @return 查询结果（Map列表，key为字段名）
  19.      */
  20.     @SelectProvider(type = DynamicSqlProvider.class, method = "buildQuerySql")
  21.     List<Map<String, Object>> executeDynamicQuery(
  22.             @Param("sqlTemplate") String sqlTemplate,
  23.             @Param("params") Map<String, Object> params);
  25.     /**
  26.      * 批量插入（Excel导入核心方法）
  27.      * @param tableName 目标表名（已做白名单校验）
  28.      * @param columns 数据库字段列表
  29.      * @param dataList 导入数据列表（Mapkey为字段名，value为值）
  30.      * @return 影响行数
  31.      */
  32.     @InsertProvider(type = DynamicSqlProvider.class, method = "buildBatchInsertSql")
  33.     int batchInsert(
  34.             @Param("tableName") String tableName,
  35.             @Param("columns") List<String> columns,
  36.             @Param("dataList") List<Map<String, Object>> dataList);
  37. }

3.4 SQL 构建器（Provider）：复用 MyBatis 预编译

通过 Provider 动态构建 SQL，参数仍用 #{} 包裹，保障预编译能力。

  2. import org.apache.ibatis.jdbc.SQL;
  4. import java.util.List;
  5. import java.util.Map;
  7. /**
  8.  * SQL构建器：动态拼接SQL，兼容MyBatis预编译
  9.  */
  10. public class DynamicSqlProvider {
  12.     /**
  13.      * 构建动态查询SQL（直接返回数据库中的模板，MyBatis自动解析预编译）
  14.      */
  15.     public String buildQuerySql(Map<String, Object> paramMap) {
  16.         // paramMap包含@Param传递的sqlTemplate和params
  17.         String sqlTemplate = (String) paramMap.get("sqlTemplate");
  18.         return sqlTemplate; // MyBatis会自动解析#{params.xxx}并预编译
  19.     }
  21.     /**
  22.      * 构建批量插入SQL（表名拼接+参数预编译）
  23.      */
  24.     public String buildBatchInsertSql(Map<String, Object> paramMap) {
  25.         String tableName = (String) paramMap.get("tableName");
  26.         List<String> columns = (List<String>) paramMap.get("columns");
  27.         List<Map<String, Object>> dataList = (List<Map<String, Object>>) paramMap.get("dataList");
  29.         // 1. 拼接插入SQL框架（表名已校验，字段名固定配置）
  30.         SQL sql = new SQL().INSERT_INTO(tableName);
  31.         columns.forEach(sql::INTO_COLUMNS); // 添加字段列表
  33.         // 2. 批量添加值：每个值用#{dataList[索引].字段名}保证预编译
  34.         for (int i = 0; i < dataList.size(); i++) {
  35.             StringBuilder values = new StringBuilder();
  36.             for (int j = 0; j < columns.size(); j++) {
  37.                 String column = columns.get(j);
  38.                 values.append("#{dataList[").append(i).append("].").append(column).append("}");
  39.                 if (j < columns.size() - 1) {
  40.                     values.append(",");
  41.                 }
  42.             }
  43.             sql.VALUES(String.join(",", columns), values.toString());
  44.         }
  46.         return sql.toString();
  47.     }
  48. }

3.5 报表查询服务实现

从数据库加载 SQL 模板，调用通用 Mapper 执行，利用 MyBatis 预编译处理参数。

  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.jdbc.core.JdbcTemplate;
  4. import org.springframework.stereotype.Service;
  5. import org.springframework.util.Assert;
  7. import java.util.List;
  8. import java.util.Map;
  10. @Service
  11. public class ReportService {
  13.     @Autowired
  14.     private JdbcTemplate jdbcTemplate; // 用于查询SQL模板
  15.     @Autowired
  16.     private DynamicSqlMapper dynamicSqlMapper; // 通用动态SQL Mapper
  18.     /**
  19.      * 执行配置化报表查询
  20.      * @param reportCode 报表编码（关联report_config表）
  21.      * @param params 前端传递的查询参数
  22.      * @return 报表结果
  23.      */
  24.     public List<Map<String, Object>> executeReport(String reportCode, Map<String, Object> params) {
  25.         // 1. 从数据库查询SQL模板
  26.         String sqlTemplate = jdbcTemplate.queryForObject(
  27.                 "SELECT sql_template FROM report_config WHERE report_code = ?",
  28.                 new Object[]{reportCode},
  29.                 String.class
  30.         );
  31.         Assert.notNull(sqlTemplate, "报表配置不存在：" + reportCode);
  33.         // 2. 调用通用Mapper执行：MyBatis自动解析#{参数}并预编译
  34.         return dynamicSqlMapper.executeDynamicQuery(sqlTemplate, params);
  35.     }
  36. }

3.6 Excel 批量导入服务实现

加载导入配置，解析 Excel 数据，调用通用 Mapper 批量插入，通过白名单校验表名。

  2. import com.alibaba.excel.EasyExcel;
  3. import com.alibaba.excel.read.listener.PageReadListener;
  4. import com.alibaba.fastjson2.JSON;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.jdbc.core.JdbcTemplate;
  7. import org.springframework.stereotype.Service;
  8. import org.springframework.transaction.annotation.Transactional;
  9. import org.springframework.util.Assert;
  11. import java.util.*;
  13. @Service
  14. public class ExcelImportService {
  16.     @Autowired
  17.     private JdbcTemplate jdbcTemplate;
  18.     @Autowired
  19.     private DynamicSqlMapper dynamicSqlMapper;
  21.     // 表名白名单：仅允许导入指定表，防止恶意注入（可从配置文件/数据库加载）
  22.     private static final Set<String> TABLE_WHITELIST = new HashSet<>(Arrays.asList("user", "order", "product"));
  24.     /**
  25.      * 批量导入Excel数据
  26.      * @param importCode 导入编码（关联excel_import_config表）
  27.      * @param excelFilePath Excel文件路径
  28.      */
  29.     @Transactional(rollbackFor = Exception.class) // 事务保证数据一致性
  30.     public void batchImport(String importCode, String excelFilePath) {
  31.         // 1. 从数据库获取导入配置
  32.         Map<String, Object> config = jdbcTemplate.queryForMap(
  33.                 "SELECT target_table, column_mapping FROM excel_import_config WHERE import_code = ?",
  34.                 importCode
  35.         );
  36.         String targetTable = config.get("target_table").toString();
  37.         String columnMappingStr = config.get("column_mapping").toString();
  38.         Map<String, String> columnMapping = JSON.parseObject(columnMappingStr, Map.class); // Excel列→数据库字段映射
  40.         // 2. 表名安全校验（核心：防止表名注入）
  41.         Assert.isTrue(TABLE_WHITELIST.contains(targetTable), "不允许导入的表名：" + targetTable);
  42.         List<String> dbColumns = new ArrayList<>(columnMapping.values()); // 数据库字段列表
  44.         // 3. EasyExcel解析Excel数据（流式读取，避免内存溢出）
  45.         List<Map<String, Object>> dataList = new ArrayList<>();
  46.         EasyExcel.read(excelFilePath, new PageReadListener<Map<Integer, String>>((data, context) -> {
  47.             // 解析单行数据：映射为数据库字段-值
  48.             Map<String, Object> rowData = parseExcelRow(data, columnMapping);
  49.             dataList.add(rowData);
  51.             // 每1000条批量提交（优化性能）
  52.             if (dataList.size() >= 1000) {
  53.                 dynamicSqlMapper.batchInsert(targetTable, dbColumns, dataList);
  54.                 dataList.clear();
  55.             }
  56.         })).sheet().doRead();
  58.         // 处理剩余不足1000条的数据
  59.         if (!dataList.isEmpty()) {
  60.             dynamicSqlMapper.batchInsert(targetTable, dbColumns, dataList);
  61.         }
  62.     }
  64.     /**
  65.      * 解析Excel行数据：将Excel列索引→值映射为数据库字段→值
  66.      */
  67.     private Map<String, Object> parseExcelRow(Map<Integer, String> excelRow, Map<String, String> columnMapping) {
  68.         Map<String, Object> rowData = new HashMap<>();
  69.         // 模拟Excel列索引→列名映射（实际应先读取Excel表头行）
  70.         Map<Integer, String> indexToExcelName = new HashMap<>();
  71.         indexToExcelName.put(0, "姓名");
  72.         indexToExcelName.put(1, "年龄");
  73.         indexToExcelName.put(2, "手机号");
  75.         // 匹配Excel列名与数据库字段
  76.         excelRow.forEach((index, value) -> {
  77.             String excelColumnName = indexToExcelName.get(index);
  78.             String dbColumn = columnMapping.get(excelColumnName);
  79.             if (dbColumn != null) {
  80.                 rowData.put(dbColumn, value);
  81.             }
  82.         });
  83.         return rowData;
  84.     }
  85. }

3.7 控制器层（测试接口）

提供 HTTP 接口，接收前端参数/Excel 文件，调用服务层执行。

  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.web.bind.annotation.*;
  4. import org.springframework.web.multipart.MultipartFile;
  6. import java.io.File;
  7. import java.util.List;
  8. import java.util.Map;
  10. @RestController
  11. @RequestMapping("/config")
  12. public class ConfigController {
  14.     @Autowired
  15.     private ReportService reportService;
  16.     @Autowired
  17.     private ExcelImportService excelImportService;
  19.     /**
  20.      * 报表查询接口
  21.      * @param reportCode 报表编码
  22.      * @param params 前端传递的查询参数（JSON格式）
  23.      * @return 报表结果
  24.      */
  25.     @PostMapping("/report/{reportCode}")
  26.     public List<Map<String, Object>> queryReport(
  27.             @PathVariable String reportCode,
  28.             @RequestBody Map<String, Object> params) {
  29.         return reportService.executeReport(reportCode, params);
  30.     }
  32.     /**
  33.      * Excel批量导入接口
  34.      * @param importCode 导入编码
  35.      * @param file 上传的Excel文件
  36.      * @return 导入结果
  37.      */
  38.     @PostMapping("/import/{importCode}")
  39.     public String importExcel(
  40.             @PathVariable String importCode,
  41.             @RequestParam("file") MultipartFile file) {
  42.         // 临时保存文件（实际项目建议流式处理，避免文件落地）
  43.         File tempFile = new File(System.getProperty("java.io.tmpdir") + "/" + file.getOriginalFilename());
  44.         try {
  45.             file.transferTo(tempFile);
  46.             excelImportService.batchImport(importCode, tempFile.getAbsolutePath());
  47.             return "导入成功";
  48.         } catch (Exception e) {
  49.             return "导入失败：" + e.getMessage();
  50.         }
  51.     }
  52. }

3.8 MyBatis 配置（Mapper 扫描）

配置 Mapper 接口扫描路径，确保 MyBatis 能识别 Mapper。

  2. import org.mybatis.spring.annotation.MapperScan;
  3. import org.springframework.context.annotation.Configuration;
  5. /**
  6.  * MyBatis核心配置
  7.  */
  8. @Configuration
  9. @MapperScan("com.yourpackage.mapper") // 替换为你的Mapper接口实际包路径
  10. public class MyBatisConfig {
  11. }

四、XML 方式实现动态 SQL（可选，兼容偏好）

若更习惯 XML 编写 SQL，可将 Provider 逻辑迁移到 XML 中，核心逻辑一致（静态拼接+参数预编译）。

  2. <?xml version="1.0" encoding="UTF-8"?>
  3. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.yourpackage.mapper.DynamicSqlMapper">
  5.     <!-- 动态查询（XML版）：sqlTemplate由数据库提供，参数自动预编译 -->
  6.     <!-- 批量插入（XML版）：表名/字段静态拼接，参数预编译 -->
  7.     <insert id="batchInsert">
  8.         INSERT INTO ${tableName} (
  9.             <foreach collection="columns" item="column" separator=",">
  10.                 ${column} <!-- 字段名已通过配置校验，安全 -->
  11.             </foreach>
  12.         ) VALUES<foreach collection="dataList" item="item" separator=",">
  13.             (
  14.                 <foreach collection="columns" item="column" separator=",">
  15.                     #{item.${column}} <!-- 核心：参数预编译，防止注入 -->
  16.                 </foreach>
  17.             )
  18.         </foreach>
  19.     </insert>
  21. </mapper>

五、批量更新扩展实现

批量更新逻辑与批量插入类似，核心是构建动态更新 SQL，参数预编译。

  2. // 1. 在DynamicSqlMapper中添加批量更新方法
  3. @InsertProvider(type = DynamicSqlProvider.class, method = "buildBatchUpdateSql")
  4. int batchUpdate(
  5.         @Param("tableName") String tableName,
  6.         @Param("columns") List<String> columns,
  7.         @Param("dataList") List<Map<String, Object>> dataList);
  9. // 2. 在DynamicSqlProvider中添加构建方法
  10. public String buildBatchUpdateSql(Map<String, Object> paramMap) {
  11.     String tableName = (String) paramMap.get("tableName");
  12.     List<String> columns = (List<String>) paramMap.get("columns");
  13.     List<Map<String, Object>> dataList = (List<Map<String, Object>>) paramMap.get("dataList");
  15.     // 假设主键为id，移除主键字段（更新无需主键字段）
  16.     columns.remove("id");
  17.     // 构建更新SQL框架：UPDATE 表 SET 字段1=?,字段2=? WHERE id=?
  18.     SQL sql = new SQL().UPDATE(tableName);
  19.     columns.forEach(column -> sql.SET(column + "=#{item." + column + "}"));
  20.     sql.WHERE("id=#{item.id}");
  22.     // 批量拼接更新语句（MyBatis支持多条UPDATE语句批量执行）
  23.     StringBuilder batchSql = new StringBuilder();
  24.     for (int i = 0; i < dataList.size(); i++) {
  25.         batchSql.append(sql.toString().replace("item.", "dataList[" + i + "]."));
  26.         if (i < dataList.size() - 1) {
  27.             batchSql.append(";");
  28.         }
  29.     }
  31.     return batchSql.toString();
  32. }

六、关键安全保障说明

  1. 参数预编译：所有前端传递的参数均通过 MyBatis #{} 处理，自动转义特殊字符（如单引号、分号），彻底杜绝参数注入。

  2. 表名/字段名白名单：导入的目标表名必须在白名单内，防止恶意配置 user; DROP TABLE xxx 等危险表名。

  3. SQL 模板校验：可扩展添加模板校验逻辑，禁止配置包含 DROP、ALTER、TRUNCATE 等危险关键字的 SQL 模板。

  4. 权限控制：报表配置、导入配置仅开放给管理员，避免普通用户修改配置引入安全风险。

七、核心总结

  1. Mapper 模式完全兼容：通过 @Provider 注解或 XML 动态 SQL，可在保留 Mapper 体系的前提下实现全配置化。

  2. 预编译不失效：无论 SQL 来源是 XML 还是数据库，只要参数用 #{} 包裹，MyBatis 就会自动触发预编译。

  3. 安全与灵活平衡：静态配置项（表名、字段名）靠白名单校验，动态参数靠预编译，两者结合保障系统安全。

  4. 性能优化：批量操作使用 MyBatis+JDBC 批处理机制（addBatch()+executeBatch()），配合事务提升效率与数据一致性。

    （注：文档部分内容可能由 AI 生成）

 8

啊！这个可能是世界上最丑的留言输入框功能~


当然，也是最丑的留言列表

有疑问发邮件到 : suibibk@qq.com 侵权立删
Copyright : 个人随笔   备案号 : 粤ICP备18099399号-2