MyBatis核心概念与高级特性实战指南

1. MyBatis简介与核心概念

1.1 什么是MyBatis

MyBatis是一款优秀的持久层框架，它通过XML或注解的方式将SQL与Java代码解耦，极大地简化了数据库操作。与传统的JDBC相比，MyBatis避免了大量重复的样板代码，让开发者能够更专注于业务逻辑的实现。

在实际项目中，我经常遇到需要频繁修改SQL的场景。使用原生JDBC时，每次修改SQL都需要重新编译Java代码，而MyBatis通过将SQL配置化，实现了热更新的效果。比如在性能优化时，可以随时调整SQL而无需重启应用，这对线上系统的维护特别重要。

1.2 核心组件解析

1.2.1 SqlSessionFactory

这是MyBatis的核心工厂类，负责创建SqlSession实例。最佳实践是将其设计为单例，因为创建它的开销较大。在我的项目中，通常会这样初始化：

java复制String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

注意：SqlSessionFactoryBuilder用完即可丢弃，它的作用仅仅是构建SqlSessionFactory

1.2.2 SqlSession

这是执行CRUD操作的主要接口，每个线程都应该有自己的SqlSession实例。重要特性：

• 非线程安全
• 生命周期应该与一次请求或业务操作对应
• 使用后必须关闭，否则会导致连接泄漏

我习惯使用try-with-resources确保关闭：

java复制try(SqlSession session = sqlSessionFactory.openSession()) {
    UserMapper mapper = session.getMapper(UserMapper.class);
    // 业务操作...
}

1.2.3 Mapper接口

Mapper是MyBatis的灵魂所在，它通过动态代理技术将接口方法与SQL映射关联。在实际开发中，我总结了几点经验：

1. 方法命名要清晰表达意图，如selectActiveUsers比getUsers更明确
2. 参数尽量使用POJO而非Map，提高可读性和类型安全
3. 返回结果要考虑分页场景，集合查询建议返回List而非数组

1.2.4 配置体系

MyBatis的配置分为两个层次：

1. 全局配置（mybatis-config.xml）：数据源、缓存、插件等
2. Mapper配置（XML/注解）：SQL定义、结果映射等

在团队协作中，我们会统一配置规范，比如：

• 所有实体类放在com.example.entity包下
• Mapper接口使用XxxMapper命名规则
• XML映射文件与接口同名且放在相同路径下

1.3 MyBatis的核心优势

经过多个项目的实践验证，我认为MyBatis最突出的优势在于：

1. SQL灵活性：可以编写任意复杂度的SQL，特别适合需要精细优化的场景
2. 结果映射：支持嵌套查询和复杂对象组装，处理一对多、多对多关系游刃有余
3. 动态SQL：通过条件判断、循环等标签实现SQL的动态生成
4. 与Spring集成：通过MyBatis-Spring可以无缝接入Spring事务体系

对比其他ORM框架：

• Hibernate更适合简单的CRUD场景
• JPA规范统一但灵活性不足
• MyBatis在复杂查询和性能优化方面优势明显

2. 环境搭建与配置详解

2.1 依赖管理实践

在Maven项目中，除了核心依赖外，我通常会添加这些实用组件：

xml复制<dependencies>
    <!-- MyBatis核心 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.13</version>
    </dependency>
    
    <!-- 数据库驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
    
    <!-- 连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.18</version>
    </dependency>
    
    <!-- 实用工具 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.28</version>
        <optional>true</optional>
    </dependency>
    
    <!-- 测试支持 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.1.1</version>
    </dependency>
</dependencies>

经验分享：Druid连接池相比HikariCP提供了更丰富的监控功能，适合需要详细监控SQL执行情况的场景

2.2 配置文件深度解析

2.2.1 全局配置文件

完整的mybatis-config.xml配置示例：

xml复制<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 加载外部属性文件 -->
    <properties resource="config/jdbc.properties"/>
    
    <!-- 全局设置 -->
    <settings>
        <!-- 开启二级缓存 -->
        <setting name="cacheEnabled" value="true"/>
        
        <!-- 使用列别名替换列名 -->
        <setting name="useColumnLabel" value="true"/>
        
        <!-- 开启驼峰命名转换 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        
        <!-- 日志实现 -->
        <setting name="logImpl" value="SLF4J"/>
    </settings>
    
    <!-- 类型别名 -->
    <typeAliases>
        <package name="com.example.entity"/>
    </typeAliases>
    
    <!-- 类型处理器 -->
    <typeHandlers>
        <typeHandler handler="com.example.handler.JsonTypeHandler"/>
    </typeHandlers>
    
    <!-- 环境配置 -->
    <environments default="dev">
        <environment id="dev">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
                <!-- 连接池配置 -->
                <property name="poolMaximumActiveConnections" value="20"/>
                <property name="poolMaximumIdleConnections" value="10"/>
            </dataSource>
        </environment>
    </environments>
    
    <!-- 映射器配置 -->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
        <package name="com.example.mapper"/>
    </mappers>
</configuration>

关键配置说明：

1. settings中的mapUnderscoreToCamelCase可以自动将数据库的user_name映射到Java的userName
2. 生产环境建议配置多个environment，通过default属性切换
3. 类型处理器(TypeHandler)可以自定义Java类型与JDBC类型的转换

2.2.2 Spring集成配置

现代项目大多基于SpringBoot，这是我的典型配置类：

java复制@Configuration
@MapperScan("com.example.mapper")
public class MyBatisConfig {
    
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        
        // 配置实体类包路径
        sessionFactory.setTypeAliasesPackage("com.example.entity");
        
        // 配置mapper.xml文件位置
        sessionFactory.setMapperLocations(
            new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/*.xml"));
        
        // 自定义配置
        org.apache.ibatis.session.Configuration configuration = 
            new org.apache.ibatis.session.Configuration();
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setCacheEnabled(true);
        configuration.setDefaultFetchSize(100);
        configuration.setDefaultStatementTimeout(30);
        
        sessionFactory.setConfiguration(configuration);
        return sessionFactory.getObject();
    }
    
    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

避坑指南：如果遇到"Invalid bound statement (not found)"错误，通常是因为Mapper接口与XML文件没有正确匹配，检查MapperScan和mapperLocations配置

2.3 数据库连接优化

生产环境中的数据库连接池配置建议：

properties复制# Druid连接池配置
spring.datasource.druid.initial-size=5
spring.datasource.druid.min-idle=5
spring.datasource.druid.max-active=20
spring.datasource.druid.max-wait=60000
spring.datasource.druid.time-between-eviction-runs-millis=60000
spring.datasource.druid.min-evictable-idle-time-millis=300000
spring.datasource.druid.validation-query=SELECT 1
spring.datasource.druid.test-while-idle=true
spring.datasource.druid.test-on-borrow=false
spring.datasource.druid.test-on-return=false
spring.datasource.druid.filters=stat,wall,log4j

监控配置（Druid特有）：

java复制@Bean
public ServletRegistrationBean<StatViewServlet> druidServlet() {
    ServletRegistrationBean<StatViewServlet> reg = new ServletRegistrationBean<>();
    reg.setServlet(new StatViewServlet());
    reg.addUrlMappings("/druid/*");
    // 白名单
    reg.addInitParameter("allow", "127.0.0.1");
    // 登录查看信息的账号密码
    reg.addInitParameter("loginUsername", "admin");
    reg.addInitParameter("loginPassword", "admin");
    return reg;
}

3. 基础使用与CRUD实践

3.1 实体类设计规范

良好的实体类设计是MyBatis高效使用的基础。这是我的典型User实体类：

java复制@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class User {
    private Long id;
    private String username;
    private String password;
    private Integer age;
    private String email;
    private Integer status;
    private Date createTime;
    private Date updateTime;
    
    // 关联对象
    private List<Role> roles;
    private Department department;
}

设计要点：

1. 使用Lombok简化代码
2. 基本类型使用包装类(Integer而非int)，避免NULL问题
3. 时间字段使用java.util.Date或java.time.*
4. 关联对象通过resultMap处理，不直接参与数据库映射

3.2 Mapper接口设计

UserMapper接口的完整示例：

java复制public interface UserMapper {
    
    // 插入并返回主键
    @Insert("INSERT INTO user(username,password,email) VALUES(#{username},#{password},#{email})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    int insert(User user);
    
    // 批量插入
    int batchInsert(List<User> users);
    
    // 根据ID查询
    @Select("SELECT * FROM user WHERE id = #{id}")
    User selectById(Long id);
    
    // 条件查询
    List<User> selectByCondition(UserQuery query);
    
    // 更新
    @Update("UPDATE user SET username=#{username}, email=#{email} WHERE id=#{id}")
    int update(User user);
    
    // 删除
    @Delete("DELETE FROM user WHERE id = #{id}")
    int deleteById(Long id);
    
    // 分页查询
    List<User> selectPage(UserQuery query, RowBounds rowBounds);
}

接口设计原则：

1. 简单操作使用注解，复杂SQL使用XML
2. 查询方法返回Optional更安全
3. 参数超过3个建议封装为Query对象
4. 分页查询使用RowBounds或PageHelper插件

3.3 XML映射文件详解

完整的UserMapper.xml示例：

xml复制<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
    
    <!-- 基础结果映射 -->
    <resultMap id="BaseResultMap" type="User">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="age" property="age"/>
        <result column="email" property="email"/>
        <result column="create_time" property="createTime"/>
        <result column="update_time" property="updateTime"/>
    </resultMap>
    
    <!-- 包含角色的扩展映射 -->
    <resultMap id="WithRolesResultMap" type="User" extends="BaseResultMap">
        <collection property="roles" ofType="Role">
            <id column="role_id" property="id"/>
            <result column="role_name" property="name"/>
        </collection>
    </resultMap>
    
    <!-- 批量插入 -->
    <insert id="batchInsert" parameterType="list" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO user(username, password, email, create_time)
        VALUES
        <foreach collection="list" item="item" separator=",">
            (#{item.username}, #{item.password}, #{item.email}, NOW())
        </foreach>
    </insert>
    
    <!-- 条件查询 -->
    <select id="selectByCondition" parameterType="UserQuery" resultMap="BaseResultMap">
        SELECT * FROM user
        <where>
            <if test="username != null and username != ''">
                AND username LIKE CONCAT('%', #{username}, '%')
            </if>
            <if test="email != null and email != ''">
                AND email = #{email}
            </if>
            <if test="minAge != null">
                AND age >= #{minAge}
            </if>
            <if test="maxAge != null">
                AND age &lt;= #{maxAge}
            </if>
            <if test="statusList != null and statusList.size() > 0">
                AND status IN
                <foreach collection="statusList" item="status" open="(" separator="," close=")">
                    #{status}
                </foreach>
            </if>
        </where>
        ORDER BY create_time DESC
    </select>
    
    <!-- 分页查询 -->
    <select id="selectPage" resultMap="WithRolesResultMap">
        SELECT u.*, r.id as role_id, r.name as role_name
        FROM user u
        LEFT JOIN user_role ur ON u.id = ur.user_id
        LEFT JOIN role r ON ur.role_id = r.id
        <where>
            <if test="query.keyword != null">
                AND (u.username LIKE CONCAT('%', #{query.keyword}, '%') 
                     OR u.email LIKE CONCAT('%', #{query.keyword}, '%'))
            </if>
        </where>
    </select>
</mapper>

XML编写技巧：

1. 重用resultMap减少重复配置
2. 复杂查询使用<include>重用SQL片段
3. 分页查询在MySQL中使用LIMIT，Oracle使用ROWNUM
4. 关联查询优先考虑JOIN而非多次查询

3.4 注解与XML混合使用

实际项目中，我通常采用混合模式：

java复制public interface UserMapper {
    
    // 简单查询使用注解
    @Select("SELECT * FROM user WHERE id = #{id}")
    User selectById(Long id);
    
    // 复杂查询使用XML
    List<User> selectComplexQuery(UserQuery query);
    
    // 动态SQL使用XML
    int updateSelective(User user);
}

对应的XML配置：

xml复制<update id="updateSelective" parameterType="User">
    UPDATE user
    <set>
        <if test="username != null">username=#{username},</if>
        <if test="password != null">password=#{password},</if>
        <if test="email != null">email=#{email},</if>
        update_time=NOW()
    </set>
    WHERE id=#{id}
</update>

混合使用原则：

1. 静态SQL使用注解更简洁
2. 动态SQL必须使用XML
3. 结果映射复杂的建议使用XML
4. 保持风格一致，同一Mapper中不要混用多种风格

4. 动态SQL深度解析

4.1 条件判断的艺术

4.1.1 if标签的实战技巧

基础if条件判断：

xml复制<select id="searchUsers" resultType="User">
    SELECT * FROM user
    <where>
        <if test="name != null and name != ''">
            AND username LIKE CONCAT('%', #{name}, '%')
        </if>
        <if test="minAge != null">
            AND age >= #{minAge}
        </if>
        <if test="maxAge != null">
            AND age &lt;= #{maxAge}
        </if>
        <if test="statusList != null and statusList.size() > 0">
            AND status IN
            <foreach collection="statusList" item="status" open="(" separator="," close=")">
                #{status}
            </foreach>
        </if>
    </where>
</select>

经验之谈：在字符串判断时，除了检查null还要检查空字符串，避免SQL语法错误

4.1.2 choose/when/otherwise实现多分支

xml复制<select id="selectUsers" resultType="User">
    SELECT * FROM user
    <where>
        <choose>
            <when test="ids != null and ids.size() > 0">
                id IN
                <foreach collection="ids" item="id" open="(" separator="," close=")">
                    #{id}
                </foreach>
            </when>
            <when test="name != null and name != ''">
                username LIKE CONCAT('%', #{name}, '%')
            </when>
            <otherwise>
                status = 1
            </otherwise>
        </choose>
    </where>
</select>

适用场景：

• 权限查询（优先按角色查，没有则按部门查）
• 多条件搜索（精确匹配优先，没有则模糊匹配）

4.2 循环处理实战

4.2.1 foreach批量操作

批量插入的三种方式对比：

1. 简单批量插入：

xml复制<insert id="batchInsert">
    INSERT INTO user(username, email) VALUES
    <foreach collection="list" item="user" separator=",">
        (#{user.username}, #{user.email})
    </foreach>
</insert>

2. 批量插入并返回主键（MySQL）：

xml复制<insert id="batchInsertWithId" useGeneratedKeys="true" keyProperty="id">
    INSERT INTO user(username, email) VALUES
    <foreach collection="list" item="user" separator=",">
        (#{user.username}, #{user.email})
    </foreach>
</insert>

3. 批量更新：

xml复制<update id="batchUpdate">
    <foreach collection="list" item="user" separator=";">
        UPDATE user
        SET username = #{user.username},
            email = #{user.email}
        WHERE id = #{user.id}
    </foreach>
</update>

性能提示：MySQL的批量插入建议每批500-1000条，过大可能导致包大小超限

4.2.2 复杂集合处理

处理Map类型的参数：

xml复制<select id="selectByUserMap" resultType="User">
    SELECT * FROM user
    WHERE id IN
    <foreach collection="userMap.keys" item="key" open="(" separator="," close=")">
        #{key}
    </foreach>
    AND status IN
    <foreach collection="userMap.values" item="value" open="(" separator="," close=")">
        #{value.status}
    </foreach>
</select>

4.3 SQL片段重用

4.3.1 定义可重用SQL片段

xml复制<sql id="Base_Column_List">
    id, username, email, age, status
</sql>

<sql id="Where_Clause">
    <where>
        <if test="username != null and username != ''">
            AND username LIKE CONCAT('%', #{username}, '%')
        </if>
        <if test="status != null">
            AND status = #{status}
        </if>
    </where>
</sql>

4.3.2 引用SQL片段

xml复制<select id="selectByExample" resultType="User">
    SELECT 
    <include refid="Base_Column_List"/>
    FROM user
    <include refid="Where_Clause"/>
    ORDER BY id DESC
</select>

4.4 动态SQL性能优化

4.4.1 索引友好查询

xml复制<select id="selectOptimized" resultType="User">
    SELECT * FROM user
    <where>
        <!-- 等值条件放前面 -->
        <if test="status != null">
            AND status = #{status}
        </if>
        <!-- 范围条件放后面 -->
        <if test="createTimeStart != null">
            AND create_time >= #{createTimeStart}
        </if>
        <!-- 模糊查询放最后 -->
        <if test="keyword != null">
            AND username LIKE CONCAT(#{keyword}, '%')
        </if>
    </where>
    LIMIT 1000
</select>

4.4.2 避免全表扫描

xml复制<select id="countByExample" resultType="int">
    SELECT COUNT(*) FROM user
    <include refid="Where_Clause"/>
</select>

4.4.3 使用绑定变量优化

xml复制<select id="searchWithBind" resultType="User">
    <bind name="pattern" value="'%' + keyword + '%'"/>
    SELECT * FROM user
    WHERE username LIKE #{pattern}
    AND status = #{status}
</select>

5. 高级特性与最佳实践

5.1 缓存机制深度解析

5.1.1 一级缓存特性

一级缓存（SqlSession级别）的特点：

• 默认开启，不能关闭
• 同一个SqlSession内有效
• 执行update/insert/delete或调用clearCache()会清空缓存

缓存验证代码示例：

java复制try(SqlSession session = sqlSessionFactory.openSession()) {
    UserMapper mapper = session.getMapper(UserMapper.class);
    
    // 第一次查询，访问数据库
    User user1 = mapper.selectById(1L);
    
    // 第二次查询，从缓存获取
    User user2 = mapper.selectById(1L);
    
    System.out.println(user1 == user2); // 输出true
    
    // 执行更新操作
    mapper.updateUsername(1L, "newname");
    
    // 第三次查询，缓存已清空，访问数据库
    User user3 = mapper.selectById(1L);
    
    System.out.println(user1 == user3); // 输出false
}

5.1.2 二级缓存配置

启用二级缓存的步骤：

1. 全局配置开启缓存：

xml复制<settings>
    <setting name="cacheEnabled" value="true"/>
</settings>

2. 在Mapper.xml中配置缓存：

xml复制<mapper namespace="com.example.mapper.UserMapper">
    <cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>
    ...
</mapper>

缓存参数说明：

• eviction：缓存回收策略(LRU/FIFO/SOFT/WEAK)
• flushInterval：刷新间隔(毫秒)
• size：缓存对象数量
• readOnly：是否只读

3. 实体类实现Serializable接口：

java复制public class User implements Serializable {
    // ...
}

重要提示：二级缓存是跨SqlSession的，更新操作必须及时刷新缓存，否则会导致数据不一致

5.2 延迟加载实战

5.2.1 基本配置

1. 全局开启延迟加载：

xml复制<settings>
    <setting name="lazyLoadingEnabled" value="true"/>
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

2. 在resultMap中配置延迟加载：

xml复制<resultMap id="UserWithDetail" type="User">
    <id property="id" column="id"/>
    <result property="username" column="username"/>
    <!-- 延迟加载用户详情 -->
    <association property="userDetail" column="id" 
                 select="com.example.mapper.UserDetailMapper.selectByUserId"
                 fetchType="lazy"/>
</resultMap>

5.2.2 使用注意事项

1. 延迟加载原理：

• 使用动态代理创建关联对象
• 当首次访问关联对象时触发查询
• 需要确保SqlSession生命周期足够长

2. 典型问题解决：

• N+1查询问题：合理设置fetchType，必要时使用JOIN查询
• 序列化问题：延迟加载对象序列化前需要先触发加载
• 事务问题：延迟加载需要在事务内完成

5.3 批量操作性能优化

5.3.1 批量插入优化

1. 使用foreach标签：

xml复制<insert id="batchInsert" parameterType="list">
    INSERT INTO user(username, email) VALUES
    <foreach collection="list" item="item" separator=",">
        (#{item.username}, #{item.email})
    </foreach>
</insert>

2. 使用ExecutorType.BATCH：

java复制try(SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH)) {
    UserMapper mapper = session.getMapper(UserMapper.class);
    
    for(int i=0; i<1000; i++) {
        User user = new User("user"+i, "user"+i+"@example.com");
        mapper.insert(user);
        
        if(i % 200 == 0) {
            session.flushStatements(); // 分批提交
        }
    }
    
    session.commit();
}

性能对比：

• 普通模式：1000条记录约5秒
• BATCH模式：1000条记录约0.5秒

5.3.2 批量更新技巧

1. 使用case-when实现单条SQL批量更新：

xml复制<update id="batchUpdate">
    UPDATE user
    SET username = CASE id
        <foreach collection="list" item="user">
            WHEN #{user.id} THEN #{user.username}
        </foreach>
        END,
        email = CASE id
        <foreach collection="list" item="user">
            WHEN #{user.id} THEN #{user.email}
        </foreach>
        END
    WHERE id IN
    <foreach collection="list" item="user" open="(" separator="," close=")">
        #{user.id}
    </foreach>
</update>

2. 使用MySQL的ON DUPLICATE KEY UPDATE：

xml复制<insert id="batchInsertOrUpdate">
    INSERT INTO user(id, username, email) VALUES
    <foreach collection="list" item="user" separator=",">
        (#{user.id}, #{user.username}, #{user.email})
    </foreach>
    ON DUPLICATE KEY UPDATE
    username = VALUES(username),
    email = VALUES(email)
</insert>

5.4 类型处理器高级用法

5.4.1 自定义类型处理器

处理JSON类型的示例：

1. 定义处理器：

java复制@MappedTypes({Map.class, List.class})
@MappedJdbcTypes(JdbcType.VARCHAR)
public class JsonTypeHandler extends BaseTypeHandler<Object> {
    
    private static final ObjectMapper mapper = new ObjectMapper();
    
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, 
                                  Object parameter, JdbcType jdbcType) {
        try {
            ps.setString(i, mapper.writeValueAsString(parameter));
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }
    
    @Override
    public Object getNullableResult(ResultSet rs, String columnName) {
        try {
            String json = rs.getString(columnName);
            return json == null ? null : mapper.readValue(json, Object.class);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    // 其他重载方法...
}

2. 注册处理器：

xml复制<typeHandlers>
    <typeHandler handler="com.example.handler.JsonTypeHandler"/>
</typeHandlers>

3. 使用示例：

java复制public class User {
    private Long id;
    private String username;
    private Map<String, Object> attributes; // 存储为JSON
}

5.4.2 枚举类型处理

1. 实现自定义枚举处理器：

java复制public class StatusEnumTypeHandler extends BaseTypeHandler<StatusEnum> {
    
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, 
                                  StatusEnum parameter, JdbcType jdbcType) {
        ps.setInt(i, parameter.getCode());
    }
    
    @Override
    public StatusEnum getNullableResult(ResultSet rs, String columnName) {
        int code = rs.getInt(columnName);
        return StatusEnum.fromCode(code);
    }
    
    // 其他重载方法...
}

2. 配置枚举处理器：

xml复制<typeHandlers>
    <typeHandler handler="com.example.handler.StatusEnumTypeHandler"
                javaType="com.example.enums.StatusEnum"/>
</typeHandlers>

6. 性能优化与调优实战

6.1 SQL语句优化

6.1.1 查询优化技巧

1. 避免SELECT *：

xml复制<select id="selectEssentialFields" resultType="User">
    SELECT id, username, email FROM user
    WHERE status = 1
</select>

2. 使用索引提示：

xml复制<select id="selectWithIndexHint" resultType="User">
    SELECT /*+ INDEX(user idx_username) */ * FROM user
    WHERE username = #{username}
</select>

3. 分页优化：

xml复制<select id="selectPageOptimized" resultType="User">
    SELECT u.* FROM user u
    JOIN (
        SELECT id FROM user
        WHERE status = 1
        ORDER BY create_time DESC
        LIMIT #{offset}, #{limit}
    ) AS tmp ON u.id = tmp.id
</select>

6.1.2 执行计划分析

通过MyBatis日志分析SQL执行：

xml复制<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

典型执行计划问题：

• 全表扫描：添加适当索引
• 文件排序：优化ORDER BY子句
• 临时表：优化JOIN和GROUP BY

6.2 MyBatis配置调优

6.2.1 全局配置优化

xml复制<settings>
    <!-- 关闭不需要的自动映射 -->
    <setting name="autoMappingBehavior" value="PARTIAL"/>
    
    <!-- 设置默认执行器类型 -->
    <setting name="defaultExecutorType" value="REUSE"/>
    
    <!-- 设置JDBC超时时间 -->
    <setting name="defaultStatementTimeout" value="30"/>
    
    <!-- 设置获取结果集时的批量大小 -->
    <setting name="defaultFetchSize" value="100"/>
</settings>

6.2.2 连接池优化建议

Druid推荐配置：

properties复制# 初始连接数
spring.datasource.druid.initial-size=5
# 最小空闲连接数
spring.datasource.druid.min-idle=5
# 最大活跃连接数
spring.datasource.druid.max-active=20
# 获取连接等待超时时间(ms)
spring.datasource.druid.max-wait=60000
# 间隔多久检测空闲连接(ms)
spring.datasource.druid.time-between-eviction-runs-millis=60000
# 连接最小生存时间(ms)
spring.datasource.druid.min-evictable-idle-time-millis=300000
# 测试连接有效性的SQL
spring.datasource.druid.validation-query=SELECT 1
# 空闲时测试连接
spring.datasource.druid.test-while-idle=true

6.3 监控与诊断

6.3.1 监控SQL执行

1. 使用Druid监控：

java复制@Bean
public ServletRegistrationBean<StatViewServlet> druidServlet() {
    ServletRegistrationBean<StatViewServlet> reg = new ServletRegistrationBean<>();
    reg.setServlet(new StatViewServlet());
    reg.addUrlMappings("/druid/*");
    reg.addInitParameter("loginUsername", "admin");
    reg.addInitParameter("loginPassword", "admin");
    return reg;
}

2. 关键监控指标：

• SQL执行时间分布
• 慢SQL统计
• 连接池活跃度
• 事务提交/回滚比例

6.3.2 慢SQL处理流程

1. 识别慢SQL：

• 通过Druid监控
• MySQL慢查询日志
• 应用性能监控(APM)工具

2. 优化方案：

• 添加适当索引
• 重写复杂SQL
• 引入缓存
• 数据分片

7. 实际应用案例解析

7.1 电商商品搜索系统

7.1.1 商品搜索实现

xml复制<select id="searchProducts" resultType="ProductVO">
    SELECT 
        p.id,
        p.name,
        p.price,
        p.stock,
        c.name AS category_name,
        b.name AS brand_name,
        (SELECT COUNT(*) FROM product_comment pc WHERE pc.product_id = p.id) AS comment_count
    FROM product p
    LEFT JOIN category c ON p.category_id = c.id
    LEFT JOIN brand b ON p.brand_id = b.id
    <where>
        p.status = 1
        <if test="keyword != null and keyword != ''">
            AND (p.name LIKE CONCAT('%', #{keyword}, '%')
                 OR p.keywords LIKE CONCAT('%', #{keyword}, '%'))
        </if>
        <if test="categoryId != null">
            AND (p.category_id = #{categoryId} OR c.parent_id = #{categoryId})
        </if>
        <if test="brandId != null">
            AND p.brand_id = #{brandId}
        </if>
        <if test="minPrice != null">
            AND p.price >= #{minPrice}
        </if>
        <if test="maxPrice != null">
            AND p.price &lt;= #{maxPrice}
        </if>
        <if test="hasStock != null and hasStock">
            AND p.stock > 0
        </if>
    </where>
    <choose>
        <when test="sortBy == 'price_asc'">ORDER BY p.price ASC</when>
        <when test="sortBy == 'price_desc'">ORDER BY p.price DESC</when>
        <when test="sortBy == 'sales'">ORDER BY p.sales DESC</when>
        <when test="sortBy == 'comment'">ORDER BY comment_count DESC</when>
        <otherwise>ORDER BY p.create_time DESC</otherwise>
    </choose>
    LIMIT #{offset}, #{limit}
</select>

7.1.2 商品详情页优化

xml复制<!-- 使用二级缓存 -->
<cache eviction="LRU" flushInterval="3600000