Spring Boot中使用MyBatis Generator生成动态SQL

惜鸟2025-06-20 10:14

概述

我们将在Spring Boot项目中集成MyBatis Generator，并配置其生成MyBatis Dynamic SQL风格的代码。 MyBatis Dynamic SQL是MyBatis 3的一个特性，它允许使用Java API构建动态SQL查询，避免编写XML或使用Example类。

MyBatis Dynamic SQL 核心优势

  • 类型安全：所有列引用都是类型安全的
  • 流畅的API：链式调用构建查询
  • 动态SQL：自然处理条件逻辑
  • 无XML：避免XML配置的繁琐
  • IDE支持：自动补全和类型检查

步骤概述：

  1. 创建Spring Boot项目，添加必要的依赖（包括MyBatis Spring Boot Starter、数据库驱动、MyBatis Generator等）。

  2. 配置MyBatis Generator（通过Maven插件方式）。

  3. 编写generatorConfig.xml配置文件，指定生成Dynamic SQL风格的代码。

  4. 运行MyBatis Generator生成代码。

  5. 在Spring Boot中配置MyBatis，使用生成的Mapper。

详细步骤

一、创建Spring Boot项目并添加依赖

使用Spring Initializr创建一个新项目，选择以下依赖：

  • Spring Web (如果构建Web应用)

  • MyBatis Framework

  • MySQL Driver (以MySQL为例，或者根据你的数据库选择)

然后在pom.xml中添加MyBatis Generator Maven插件以及MyBatis Dynamic SQL依赖：

xml 复制代码 
<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- MyBatis Spring Boot Starter -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>3.0.3</version>
    </dependency>
    <!-- MySQL 驱动 -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- MyBatis Dynamic SQL -->
    <dependency>
        <groupId>org.mybatis.dynamic-sql</groupId>
        <artifactId>mybatis-dynamic-sql</artifactId>
        <version>1.5.0</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <!-- MyBatis Generator 插件 -->
        <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.4.2</version>
            <dependencies>
                <dependency>
                    <groupId>com.mysql</groupId>
                    <artifactId>mysql-connector-j</artifactId>
                    <version>8.0.33</version>
                </dependency>
                <!-- 支持生成 Dynamic SQL -->
                <dependency>
                    <groupId>org.mybatis.dynamic-sql</groupId>
                    <artifactId>mybatis-dynamic-sql</artifactId>
                    <version>1.5.0</version>
                </dependency>
            </dependencies>
            <configuration>
                <configurationFile>src/main/resources/generatorConfig.xml</configurationFile>
                <overwrite>true</overwrite>
                <verbose>true</verbose>
            </configuration>
        </plugin>
    </plugins>
</build>

二、编写generatorConfig.xml配置文件

在src/main/resources目录下创建generatorConfig.xml文件。我们需要配置生成Dynamic SQL风格的代码，这通过设置targetRuntime="MyBatis3DynamicSql"来实现。

示例配置：

xml 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "https://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
    <!-- 引入 application.properties 中的配置(可选) -->
    <properties resource="application.properties"/>

    <!-- 数据库驱动路径（如果未通过Maven依赖管理） -->
    <!-- <classPathEntry location="/path/to/mysql-connector-java-8.0.33.jar"/> -->

    <context id="mysql" targetRuntime="MyBatis3DynamicSql">
        <!-- 生成的Java文件编码 -->
        <property name="javaFileEncoding" value="UTF-8"/>

        <!-- 生成的Java文件的注释 -->
        <commentGenerator>
            <!-- 注释配置：不生成注释 -->
            <property name="suppressAllComments" value="true"/>
            <!-- 生成注释 -->
            <!--            <property name="addRemarkComments" value="true"/>-->
        </commentGenerator>
        <!-- 数据库连接信息 -->
        <jdbcConnection driverClass="${spring.datasource.driver-class-name}"
                        connectionURL="${spring.datasource.url}"
                        userId="${spring.datasource.username}"
                        password="${spring.datasource.password}">
        </jdbcConnection>
        <!-- Java模型生成配置 -->
        <javaModelGenerator targetPackage="com.example.demo.model.entity" targetProject="src/main/java">
            <property name="enableSubPackages" value="true"/>
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>
        <!-- 注意：如果使用Dynamic SQL方式，不需要XML映射文件 -->
        <!-- 生成 SQL Map XML 文件的配置 -->
        <!--        <sqlMapGenerator targetPackage="mapper" targetProject="src/main/resources">-->
        <!--            <property name="enableSubPackages" value="true" />-->
        <!--        </sqlMapGenerator>-->
        <!-- Mapper接口生成配置 -->
        <javaClientGenerator type="ANNOTATEDMAPPER"
                             targetPackage="com.example.demo.repository.generated"
                             targetProject="src/main/java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>
        <!-- 指定要生成的表 -->
        <table tableName="user" domainObjectName="User">
            <generatedKey column="id" sqlStatement="MySql" identity="true"/>
        </table>
        <table tableName="rule" domainObjectName="RuleEntity" mapperName="RuleMapper">
            <generatedKey column="id" sqlStatement="MySql" identity="true"/>
        </table>

        <table tableName="rule_version" domainObjectName="RuleVersionEntity" mapperName="RuleVersionMapper">
            <generatedKey column="id" sqlStatement="MySql" identity="true"/>
        </table>
        <!-- 生成所有表 -->
        <!--         <table tableName="%" />-->
    </context>
</generatorConfiguration>

注意：

  1. 我们使用了targetRuntime="MyBatis3DynamicSql"，这会生成Dynamic SQL风格的代码。

  2. 不需要配置sqlMapGenerator，因为Dynamic SQL不生成XML映射文件。

  3. javaClientGenerator的type设置为ANNOTATEDMAPPER，表示使用注解方式（实际上Dynamic SQL的Mapper接口是通过Java API构建的，由Dynamic SQL的运行时库提供支持）。

  4. 在jdbcConnection中，我们使用了Spring Boot的application.properties中的数据库配置（通过${}占位符引用）。需要在generatorConfig.xml文件中配置 <properties resource="application.properties"/>，并且确保application.properties中有这些属性。

三、配置application.properties

在src/main/resources/application.properties中配置数据源：

properties 复制代码 
spring.application.name=demo
server.port=8088
# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=root
spring.datasource.password=mysecretpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

四、运行MyBatis Generator生成代码

在项目根目录下运行命令：

bash 复制代码 
mvn mybatis-generator:generate

或者在IDE中运行Maven插件的mybatis-generator:generate目标。

生成的文件将包括：

  1. 实体类（POJO）：在com.example.demo.model.entity包下。

  2. Mapper接口：在com.example.demo.repository.generated包下。注意，生成的Mapper接口会继承MyBatis Dynamic SQL提供的MyBatis3Mapper接口（比如CommonCountMapper, CommonDeleteMapper, CommonUpdateMapper），这些接口提供了一些基本的CRUD方法。

五、在Spring Boot中使用生成的Mapper

  1. 在目录 com.example.demo.config 创建 MyBatisConfig.java 配置类：
java 复制代码 
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
@MapperScan("com.example.demo.repository")
public class MyBatisConfig {
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setTypeAliasesPackage("com.example.demo.model.entity");

        return sessionFactory.getObject();
    }

}

在Spring Boot项目中，使用@MapperScan注解可以方便地扫描并注册MyBatis的Mapper接口。这样，我们就不需要在每个Mapper接口上都添加@Mapper注解。

注意事项：

  • @MapperScan与@Mapper ：如果使用了@MapperScan，则不需要在每个Mapper接口上再写@Mapper。但是，如果有些Mapper接口不在扫描路径下，那么仍然需要在该接口上使用@Mapper。

  • 包路径 ：确保@MapperScan指定的包路径正确，否则Spring容器无法创建Mapper的Bean，导致注入失败。

  • 多模块项目：如果项目有多个模块，并且Mapper接口分布在不同的模块中，确保这些模块的包路径都被扫描到。

  1. 在Service中注入Mapper并使用：
java 复制代码 
@Service
@RequiredArgsConstructor
public class UserService {
    
    private final UserMapper userMapper;
    
    // 创建用户
    public int createUser(User user) {
        return userMapper.insert(user);
    }
    
    // 根据ID获取用户
    public Optional<User> getUserById(Long id) {
        return userMapper.selectByPrimaryKey(id);
    }
    
    // 更新用户
    public int updateUser(User user) {
        return userMapper.updateByPrimaryKeySelective(user);
    }
    
    // 删除用户
    public int deleteUser(Long id) {
        return userMapper.deleteByPrimaryKey(id);
    }
    
    // 动态查询用户
    public List<User> findUsers(String username, Integer minAge, Integer maxAge) {
        return userMapper.select(c -> c
            .where(UserDynamicSqlSupport.username, isLikeIfPresent(username).map(s -> s + "%")
            .and(UserDynamicSqlSupport.age, isBetweenWhenPresent(minAge, maxAge))
            .orderBy(UserDynamicSqlSupport.createTime.descending())
            .build()
            .execute());
    }
    
    // 辅助方法：条件存在时使用 LIKE
    private Optional<Condition> isLikeIfPresent(String value) {
        return Optional.ofNullable(value)
            .filter(v -> !v.isEmpty())
            .map(v -> UserDynamicSqlSupport.username.like(v));
    }
    
    // 辅助方法：条件存在时使用 BETWEEN
    private Optional<BetweenCondition> isBetweenWhenPresent(Integer min, Integer max) {
        if (min != null && max != null) {
            return Optional.of(UserDynamicSqlSupport.age.between(min, max));
        }
        return Optional.empty();
    }
}

注意：上面的user是一个自动生成的表对应的对象（在UserMapper中有一个静态字段user，用于构建查询）。实际使用时，需要导入生成的Mapper和表对象。

例如，在UserService中导入：

java 复制代码 
import static com.example.demo.mapper.UserDynamicSqlSupport.*;

import static org.mybatis.dynamic.sql.SqlBuilder.*;
  1. 在controller中注入service并使用
java 复制代码 
@RestController
@RequestMapping("/api/users")
@RequiredArgsConstructor
public class UserController {
    
    private final UserService userService;
    
    @PostMapping
    public ResponseEntity<?> createUser(@RequestBody User user) {
        int result = userService.createUser(user);
        return result > 0 
            ? ResponseEntity.ok("User created")
            : ResponseEntity.badRequest().body("Create failed");
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        return userService.getUserById(id)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }
    
    @PutMapping("/{id}")
    public ResponseEntity<?> updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        int result = userService.updateUser(user);
        return result > 0 
            ? ResponseEntity.ok("User updated")
            : ResponseEntity.badRequest().body("Update failed");
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<?> deleteUser(@PathVariable Long id) {
        int result = userService.deleteUser(id);
        return result > 0 
            ? ResponseEntity.ok("User deleted")
            : ResponseEntity.badRequest().body("Delete failed");
    }
    
    @GetMapping("/search")
    public List<User> searchUsers(
            @RequestParam(required = false) String username,
            @RequestParam(required = false) Integer minAge,
            @RequestParam(required = false) Integer maxAge) {
        
        return userService.findUsers(username, minAge, maxAge);
    }
}

六、MyBatis Dynamic SQL 生成代码的特点

  1. 生成的Mapper接口包含的方法：

  • insert：插入记录

  • insertMultiple：批量插入

  • insertSelective：选择性插入（忽略null）

  • selectByPrimaryKey：根据主键查询

  • select：根据条件查询（可返回多条）

  • selectOne：根据条件查询一条

  • update：更新

  • delete：删除

  • 等等

  1. 同时会生成一个与表同名的辅助类（如UserDynamicSqlSupport），其中包含表的列定义，用于构建动态SQL。

  2. 不需要XML映射文件，所有SQL通过Java API动态构建。

七、注意事项

  1. 确保数据库表有主键，否则生成代码时可能会出现问题。

  2. 如果表名或列名是SQL关键字，需要在配置中使用<columnOverride>或<table>的delimitIdentifiers属性处理。

  3. 生成的代码可能会覆盖已有的文件，注意备份自定义代码（通常不要修改生成的代码，而是通过扩展方式）。

八、总结

本方案在 Spring Boot 中集成了 MyBatis Generator，并配置生成 MyBatis Dynamic SQL 风格的代码，具有以下特点：

  1. 代码简洁：使用 Lombok 减少样板代码
  2. 类型安全：Dynamic SQL 提供编译时检查
  3. 易于维护：无需 XML 配置
  4. 动态查询：灵活构建复杂查询
  5. 高效开发：自动生成基础 CRUD 代码

通过这种方式，你可以专注于业务逻辑开发，而无需手动编写重复的数据访问层代码。

相关推荐
肉肉不想干后端5 分钟前
DDD架构中的Assembler转换：从混乱到清晰的架构演进
java
GalaxyPokemon5 分钟前
RPC - Response模块
java·前端·javascript
武昌库里写JAVA12 分钟前
大模型更重要关注工艺
java·开发语言·spring boot·学习·课程设计
幻奏岚音33 分钟前
Java数据结构——第一章Java基础回顾
java·开发语言·jvm·笔记·学习
岁忧35 分钟前
(LeetCode 每日一题) 2016. 增量元素之间的最大差值 (数组)
java·c++·算法·leetcode·职场和发展·go
爬虫程序猿43 分钟前
如何利用 Java 爬虫按关键字搜索 Amazon 商品：实战指南
java·开发语言·爬虫
鸡窝头on2 小时前
Spring Boot 多 Profile 配置详解
spring boot·后端
风之旅人2 小时前
开发必备"节假日接口"
java·后端·开源
2201_753169472 小时前
implement用法
java·开发语言
不会编程的阿成3 小时前
spring aop的概念与实战以及面试项目题
java·spring·面试
热门推荐
01扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解02Coze扣子平台完整体验和实践（附国内和国际版对比）03KGG转MP3工具|非KGM文件|解密音频04DeepSeek各版本说明与优缺点分析05零代码入门 | Coze——让大模型接入自己的数据库06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07【云原生】动态资源分配（DRA）深度洞察报告08AI Agent | Coze 插件使用指南：从功能解析到实操步骤09YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】10扣子空间的使用教程与大模型技术思考