MyBatis动态SQL与逆向工程实战指南

1. MyBatis动态SQL与逆向工程实战解析

作为Java开发者，我们经常需要与数据库打交道。MyBatis作为一款优秀的持久层框架，其动态SQL和逆向工程功能能极大提升开发效率。今天我就结合自己多年使用经验，详细讲解这两个核心功能的原理和实战技巧。

1.1 为什么需要动态SQL

在传统JDBC开发中，我们经常需要根据不同的条件拼接SQL语句，这不仅容易出错，而且代码可读性差。MyBatis的动态SQL功能完美解决了这个问题，它允许我们在XML映射文件中使用条件标签来构建灵活的SQL语句。

举个例子，当我们需要根据用户输入的不同查询条件来检索数据时，动态SQL可以让我们避免编写大量重复的if-else逻辑。这不仅减少了代码量，还提高了可维护性。

1.2 逆向工程的价值

逆向工程(Reverse Engineering)是MyBatis提供的一个强大工具，它可以根据数据库表结构自动生成对应的实体类、Mapper接口和XML映射文件。这个功能特别适合在项目初期快速搭建持久层框架，或者在对已有数据库进行二次开发时使用。

我曾经参与过一个老系统重构项目，数据库中有上百张表，如果手动编写所有实体类和Mapper，至少要花费两周时间。而使用MyBatis逆向工程，配合一些定制化配置，我们仅用半天就完成了基础代码的生成，效率提升了数十倍。

2. 动态SQL深度解析

2.1 核心标签详解

MyBatis提供了多种动态SQL标签，每个都有其特定的使用场景：

1. <if>标签：最基本的条件判断

<select id="findActiveBlogWithTitleLike" resultType="Blog"> SELECT * FROM BLOG WHERE state = 'ACTIVE' <if test="title != null"> AND title like #{title} </if> </select>

2. <choose>/<when>/<otherwise>：实现多条件选择

<select id="findActiveBlogLike" resultType="Blog"> SELECT * FROM BLOG WHERE state = 'ACTIVE' <choose> <when test="title != null"> AND title like #{title} </when> <when test="author != null and author.name != null"> AND author_name like #{author.name} </when> <otherwise> AND featured = 1 </otherwise> </choose> </select>

3. <trim>/<where>/<set>：解决SQL语法问题

<update id="updateAuthorIfNecessary"> update Author <set> <if test="username != null">username=#{username},</if> <if test="password != null">password=#{password},</if> <if test="email != null">email=#{email},</if> </set> where id=#{id} </update>

4. <foreach>：处理集合迭代

<select id="selectPostIn" resultType="domain.blog.Post"> SELECT * FROM POST P WHERE ID in <foreach item="item" index="index" collection="list" open="(" separator="," close=")"> #{item} </foreach> </select>

2.2 动态SQL性能优化

虽然动态SQL很强大，但使用不当也会带来性能问题。以下是我总结的几个优化建议：

1. 避免过度使用动态SQL：不是所有场景都需要动态SQL，简单的CRUD操作使用静态SQL效率更高。

2. 合理使用缓存：对于频繁执行且结果变化不大的动态SQL查询，考虑配置二级缓存。

3. 注意SQL注入风险：虽然MyBatis使用预编译语句，但动态拼接SQL时仍需注意特殊字符处理。

4. 批量操作优化：对于大批量数据操作，使用<foreach>标签时注意设置合理的batchSize。

提示：在开发环境中可以使用MyBatis Log Free插件查看最终执行的SQL，这对调试动态SQL非常有帮助。

3. MyBatis逆向工程实战

3.1 逆向工程配置详解

MyBatis Generator(MBG)是官方提供的逆向工程工具。要使用它，首先需要在项目中添加依赖：

<dependency> <groupId>org.mybatis.generator</groupId> <artifactId>mybatis-generator-core</artifactId> <version>1.4.0</version> </dependency>

然后创建generatorConfig.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd"> <generatorConfiguration> <context id="mysqlTables" targetRuntime="MyBatis3"> <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://localhost:3306/test" userId="root" password="123456"> </jdbcConnection> <javaModelGenerator targetPackage="com.example.model" targetProject="src/main/java"> <property name="enableSubPackages" value="true"/> <property name="trimStrings" value="true"/> </javaModelGenerator> <sqlMapGenerator targetPackage="mapper" targetProject="src/main/resources"> <property name="enableSubPackages" value="true"/> </sqlMapGenerator> <javaClientGenerator type="XMLMAPPER" targetPackage="com.example.mapper" targetProject="src/main/java"> <property name="enableSubPackages" value="true"/> </javaClientGenerator> <table tableName="%"> <generatedKey column="id" sqlStatement="Mysql" identity="true"/> </table> </context> </generatorConfiguration>

3.2 自定义逆向工程策略

MBG提供了丰富的配置选项，可以自定义生成策略：

1. 忽略字段：不生成特定的表字段

<table tableName="user"> <ignoreColumn column="deleted"/> </table>

2. 自定义类型转换：处理特殊数据类型

<columnOverride column="create_time" javaType="java.time.LocalDateTime"/>

3. 生成Example类：用于构建复杂查询条件

<table tableName="user"> <property name="useActualColumnNames" value="true"/> <property name="enableCountByExample" value="false"/> <property name="enableUpdateByExample" value="false"/> <property name="enableDeleteByExample" value="false"/> <property name="enableSelectByExample" value="true"/> <property name="selectByExampleQueryId" value="false"/> </table>

4. 自定义注释：添加有意义的代码注释

<commentGenerator> <property name="suppressAllComments" value="false"/> <property name="suppressDate" value="true"/> <property name="addRemarkComments" value="true"/> </commentGenerator>

3.3 执行逆向工程

配置完成后，可以通过以下方式执行逆向工程：

1. 使用Maven插件：

<plugin> <groupId>org.mybatis.generator</groupId> <artifactId>mybatis-generator-maven-plugin</artifactId> <version>1.4.0</version> <configuration> <configurationFile>src/main/resources/generatorConfig.xml</configurationFile> <overwrite>true</overwrite> </configuration> <dependencies> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.23</version> </dependency> </dependencies> </plugin>

执行命令：mvn mybatis-generator:generate

2. Java代码方式：

public class MyBatisGenerator { public static void main(String[] args) throws Exception { List<String> warnings = new ArrayList<>(); boolean overwrite = true; File configFile = new File("generatorConfig.xml"); ConfigurationParser cp = new ConfigurationParser(warnings); Configuration config = cp.parseConfiguration(configFile); DefaultShellCallback callback = new DefaultShellCallback(overwrite); MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings); myBatisGenerator.generate(null); } }

4. 高级技巧与常见问题

4.1 动态SQL与PageHelper整合

在实际项目中，我们经常需要将动态SQL与分页插件结合使用。以PageHelper为例：

// 在Service层 public PageInfo<User> searchUsers(UserQuery query, int pageNum, int pageSize) { PageHelper.startPage(pageNum, pageSize); List<User> users = userMapper.selectByQuery(query); return new PageInfo<>(users); } // 在Mapper.xml中 <select id="selectByQuery" resultMap="BaseResultMap"> select * from user <where> <if test="username != null and username != ''"> and username like concat('%', #{username}, '%') </if> <if test="status != null"> and status = #{status} </if> </where> order by create_time desc </select>

4.2 枚举类型处理

MyBatis提供了对枚举类型的良好支持。我们可以通过TypeHandler来处理枚举：

public enum UserStatus { ACTIVE(1, "活跃"), INACTIVE(0, "禁用"); private final int code; private final String desc; // 构造方法、getter省略 } public class UserStatusTypeHandler extends BaseTypeHandler<UserStatus> { @Override public void setNonNullParameter(PreparedStatement ps, int i, UserStatus parameter, JdbcType jdbcType) throws SQLException { ps.setInt(i, parameter.getCode()); } // 其他方法实现省略 }

在配置文件中注册TypeHandler：

<typeHandlers> <typeHandler handler="com.example.handler.UserStatusTypeHandler" javaType="com.example.enums.UserStatus"/> </typeHandlers>

4.3 常见问题解决方案

1. SQL注入问题：

   • 问题：动态SQL中直接拼接用户输入可能导致SQL注入
   • 解决方案：始终使用#{}占位符，避免使用${}

2. 特殊字符转义：

   • 问题：XML中特殊字符(<, >, &)需要转义
   • 解决方案：

     <if test="age != null"> AND age <![CDATA[ < ]]> #{age} </if>

3. 批量插入性能差：

   • 问题：使用foreach批量插入时效率低
   • 解决方案：设置rewriteBatchedStatements=true

     jdbc.url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true

4. 主键回写问题：

   • 问题：插入后无法获取自增主键
   • 解决方案：配置useGeneratedKeys

     <insert id="insert" useGeneratedKeys="true" keyProperty="id"> insert into user (name) values (#{name}) </insert>

5. 列名与属性名不一致：

   • 问题：数据库使用下划线命名，Java使用驼峰命名
   • 解决方案：配置mapUnderscoreToCamelCase

     mybatis.configuration.map-underscore-to-camel-case=true

4.4 性能监控与优化

为了确保动态SQL的性能，我们需要进行监控和优化：

1. 启用慢SQL日志：

# 设置慢SQL阈值(毫秒) mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl mybatis.configuration.default-statement-timeout=3000

2. 使用MyBatis-Plus性能分析插件：

@Bean public PerformanceInterceptor performanceInterceptor() { PerformanceInterceptor interceptor = new PerformanceInterceptor(); interceptor.setMaxTime(1000); // SQL执行最大时长，超过自动停止运行 interceptor.setFormat(true); // 是否格式化代码 return interceptor; }

3. SQL优化建议：
   • 避免在循环中执行SQL
   • 合理使用索引
   • 减少不必要的列查询
   • 考虑使用延迟加载

5. 实际项目中的应用

5.1 复杂查询场景

在实际项目中，我们经常遇到复杂的多条件查询需求。下面是一个电商系统中商品查询的示例：

public class ProductQuery { private String name; private BigDecimal minPrice; private BigDecimal maxPrice; private Integer categoryId; private List<Integer> statusList; private Date startDate; private Date endDate; // getter/setter省略 } // Mapper.xml中的动态SQL <select id="searchProducts" resultMap="ProductResultMap"> SELECT * FROM product <where> <if test="name != null and name != ''"> AND name LIKE CONCAT('%', #{name}, '%') </if> <if test="minPrice != null"> AND price >= #{minPrice} </if> <if test="maxPrice != null"> AND price <= #{maxPrice} </if> <if test="categoryId != null"> AND category_id = #{categoryId} </if> <if test="statusList != null and statusList.size() > 0"> AND status IN <foreach collection="statusList" item="status" open="(" separator="," close=")"> #{status} </foreach> </if> <if test="startDate != null and endDate != null"> AND create_time BETWEEN #{startDate} AND #{endDate} </if> </where> ORDER BY <choose> <when test="sortField == 'price'">price</when> <when test="sortField == 'sales'">sales</when> <otherwise>create_time</otherwise> </choose> <choose> <when test="sortOrder == 'desc'">DESC</when> <otherwise>ASC</otherwise> </choose> </select>

5.2 动态表名处理

在某些分表场景下，我们需要动态决定表名。虽然MyBatis官方不建议这样做，但在某些特殊场景下是必要的：

// 使用@Param注解指定表名 List<User> selectFromTable(@Param("tableName") String tableName, @Param("user") User user); // Mapper.xml <select id="selectFromTable" resultType="User"> SELECT * FROM ${tableName} <where> <if test="user.name != null"> AND name = #{user.name} </if> <if test="user.age != null"> AND age = #{user.age} </if> </where> </select>

注意：使用动态表名时务必做好输入验证，防止SQL注入。最好使用白名单机制限制可选的表名。

5.3 与Spring Boot集成

在Spring Boot项目中集成MyBatis非常简便：

1. 添加依赖：

<dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.2.0</version> </dependency>

2. 配置application.yml：

mybatis: mapper-locations: classpath:mapper/*.xml type-aliases-package: com.example.model configuration: map-underscore-to-camel-case: true default-fetch-size: 100 default-statement-timeout: 30

3. 添加Mapper扫描：

@MapperScan("com.example.mapper") @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }

5.4 自定义插件开发

MyBatis允许开发自定义插件来扩展功能。下面是一个简单的SQL执行时间统计插件：

@Intercepts({ @Signature(type = StatementHandler.class, method = "query", args = {Statement.class, ResultHandler.class}), @Signature(type = StatementHandler.class, method = "update", args = {Statement.class}), @Signature(type = StatementHandler.class, method = "batch", args = {Statement.class}) }) public class SqlCostTimeInterceptor implements Interceptor { private static final Logger logger = LoggerFactory.getLogger(SqlCostTimeInterceptor.class); @Override public Object intercept(Invocation invocation) throws Throwable { long startTime = System.currentTimeMillis(); try { return invocation.proceed(); } finally { long endTime = System.currentTimeMillis(); long costTime = endTime - startTime; StatementHandler statementHandler = (StatementHandler) invocation.getTarget(); String sql = statementHandler.getBoundSql().getSql(); logger.info("SQL执行耗时: {}ms - {}", costTime, sql); } } @Override public Object plugin(Object target) { return Plugin.wrap(target, this); } @Override public void setProperties(Properties properties) { // 可以读取配置参数 } }

注册插件：

@Bean public SqlCostTimeInterceptor sqlCostTimeInterceptor() { return new SqlCostTimeInterceptor(); }

6. 最佳实践与经验分享

6.1 项目结构建议

一个良好的MyBatis项目结构能提高代码的可维护性：

src/main/java ├── com.example │ ├── config # MyBatis配置类 │ ├── model # 实体类 │ ├── mapper # Mapper接口 │ ├── service # 业务服务 │ └── handler # TypeHandler src/main/resources ├── mapper # XML映射文件 ├── generator # 逆向工程配置 └── application.yml # 配置文件

6.2 代码生成策略

1. 增量生成：对于已有代码的表，配置<property name="overwrite" value="false"/>避免覆盖手动修改的代码。

2. 自定义模板：可以通过修改Velocity模板来定制生成的代码风格。

3. 注释生成：配置<commentGenerator>添加有意义的注释，方便后续维护。

6.3 性能调优经验

1. 连接池配置：使用高性能连接池如HikariCP：

spring: datasource: hikari: maximum-pool-size: 20 minimum-idle: 5 connection-timeout: 30000 idle-timeout: 600000 max-lifetime: 1800000

2. 二级缓存：对于读多写少的数据，考虑启用二级缓存：

<cache eviction="LRU" flushInterval="60000" size="1024" readOnly="true"/>

3. 批量操作：使用SqlSession的批量模式提高性能：

try (SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH)) { UserMapper mapper = session.getMapper(UserMapper.class); for (int i = 0; i < 1000; i++) { mapper.insert(new User("user" + i)); if (i % 200 == 0) { session.flushStatements(); } } session.commit(); }

6.4 常见陷阱与规避

1. N+1查询问题：

   • 问题：在循环中查询关联数据导致性能问题
   • 解决方案：使用<collection>或<association>实现一次性加载

2. 事务未提交：

   • 问题：忘记调用sqlSession.commit()导致数据未持久化
   • 解决方案：使用@Transactional注解或确保手动提交

3. 缓存一致性问题：

   • 问题：缓存数据与数据库不一致
   • 解决方案：合理设置缓存过期策略，或在数据修改时清除缓存

4. 大结果集内存溢出：

   • 问题：查询返回大量数据导致内存不足
   • 解决方案：使用分页查询或游标方式处理大数据集

6.5 监控与诊断

1. 启用MyBatis日志：

logging: level: org.mybatis: DEBUG

2. 使用Druid监控：

@Bean public ServletRegistrationBean<StatViewServlet> druidStatViewServlet() { ServletRegistrationBean<StatViewServlet> registrationBean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*"); registrationBean.addInitParameter("loginUsername", "admin"); registrationBean.addInitParameter("loginPassword", "admin"); return registrationBean; }

3. 慢SQL监控：

@Bean public FilterRegistrationBean<WebStatFilter> druidWebStatFilter() { FilterRegistrationBean<WebStatFilter> registrationBean = new FilterRegistrationBean<>(new WebStatFilter()); registrationBean.addUrlPatterns("/*"); registrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"); return registrationBean; }

7. 未来发展与替代方案

7.1 MyBatis-Plus扩展

MyBatis-Plus是MyBatis的增强工具，提供了更多便捷功能：

1. 通用Mapper：减少基础CRUD代码

public interface UserMapper extends BaseMapper<User> { // 无需编写基础CRUD方法 }

2. Lambda查询：类型安全的查询条件

List<User> users = userMapper.selectList( Wrappers.<User>lambdaQuery() .eq(User::getName, "张三") .gt(User::getAge, 18) .orderByAsc(User::getCreateTime) );

3. 自动填充：自动处理创建时间、更新时间等字段

@TableField(fill = FieldFill.INSERT) private LocalDateTime createTime; @TableField(fill = FieldFill.INSERT_UPDATE) private LocalDateTime updateTime;

7.2 其他ORM框架比较

虽然MyBatis很强大，但了解其他ORM框架也很重要：

1. JPA/Hibernate：

   • 优点：标准规范、自动DDL、丰富的关联关系支持
   • 缺点：复杂查询性能较差、学习曲线陡峭

2. JOOQ：

   • 优点：类型安全的SQL、丰富的SQL功能支持
   • 缺点：需要生成代码、社区相对较小

3. Spring Data JDBC：

   • 优点：简单轻量、与Spring生态集成好
   • 缺点：功能相对有限

7.3 云原生趋势下的MyBatis

随着云原生的发展，MyBatis也在不断进化：

1. 响应式支持：MyBatis正在试验响应式编程支持

2. Kubernetes集成：动态数据源配置适应云环境

3. Serverless适配：优化冷启动性能

在实际项目中，我通常会根据团队技术栈和项目需求选择合适的持久层方案。对于需要精细控制SQL、处理复杂查询的场景，MyBatis仍然是首选；而对于简单的CRUD操作或快速原型开发，JPA或MyBatis-Plus可能更合适。