深度解析MyBatis动态SQL与缓存机制

一、动态SQL体系解析

1. 核心元素架构

graph TD
    A[动态SQL] --> B[if元素]
    A --> C[choose/when/otherwise]
    A --> D[trim/set/where]
    A --> E[foreach]
    A --> F[bind]
    B -->|OGNL表达式| G[条件判断]
    C -->|类似switch-case| H[多路选择]
    D -->|智能处理前后缀| I[语句优化]
    E -->|集合遍历| J[批量操作]

2. 高级用法实现原理

2.1 if元素的多条件嵌套

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

2.2 foreach批量插入优化

// 配合@Param注解使用
@Insert("<script>" +
        "INSERT INTO user(name, age) VALUES " +
        "<foreach collection='users' item='user' separator=','>" +
        "(#{user.name}, #{user.age})" +
        "</foreach>" +
        "</script>")
int batchInsert(@Param("users") List<User> users);

3. SQL片段复用策略

<!-- 定义可重用SQL片段 -->
<sql id="userColumns"> 
  ${alias}.id,${alias}.username,${alias}.password 
</sql>

<!-- 引用SQL片段 -->
<select id="selectUsers" resultType="map">
  select
    <include refid="userColumns">
      <property name="alias" value="t1"/>
    </include>
  from some_table t1
</select>

二、缓存机制深度剖析

1. 缓存层级架构

classDiagram
    class Cache{
        <<interface>>
        +String getId()
        +void putObject(Object key, Object value)
        +Object getObject(Object key)
        +Object removeObject(Object key)
        +void clear()
    }

    class PerpetualCache{
        -Map<Object, Object> cache
        +实现Cache接口方法
    }

    class LruCache{
        -Cache delegate
        +实现LRU算法
    }

    class BlockingCache{
        -Cache delegate
        +线程安全控制
    }

    Cache <|-- PerpetualCache
    Cache <|-- LruCache
    Cache <|-- BlockingCache

2. 一级缓存（本地缓存）

2.1 工作流程

sequenceDiagram
    participant Executor
    participant LocalCache
    participant DB

    Executor->>LocalCache: 查询缓存(key=sql+params)
    alt 命中缓存
        LocalCache-->>Executor: 返回缓存结果
    else 未命中
        Executor->>DB: 执行查询
        DB-->>Executor: 返回结果集
        Executor->>LocalCache: 缓存结果
    end

2.2 失效场景

执行了UPDATE/DELETE/INSERT操作
调用了SqlSession.clearCache()
执行了flushCache=true的查询
提交/回滚事务

3. 二级缓存（全局缓存）

3.1 配置启用流程

<!-- mybatis-config.xml -->
<settings>
  <setting name="cacheEnabled" value="true"/>
</settings>

<!-- Mapper.xml -->
<cache 
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

3.2 跨Session共享机制

// 序列化缓存值示例
public class SerializableCacheValue implements Serializable {
    private Object value;
    private long createTime;
    // 必须实现序列化接口
}

三、性能优化实战

1. 动态SQL优化方案

1.1 避免过度动态化

<!-- 反模式：过度使用动态SQL -->
<select id="findUser" resultType="User">
  SELECT * FROM user
  <where>
    <if test="name != null">AND name = #{name}</if>
    <if test="age != null">AND age = #{age}</if>
    <if test="email != null">AND email = #{email}</if>
    <!-- 可能产生WHERE后直接跟AND的错误 -->
  </where>
</select>

<!-- 优化方案：使用<where>标签自动处理 -->
<select id="findUserOptimized" resultType="User">
  SELECT * FROM user
  <where>
    <if test="name != null">name = #{name}</if>
    <if test="age != null">AND age = #{age}</if>
    <if test="email != null">AND email = #{email}</if>
  </where>
</select>

2. 缓存调优策略

2.1 缓存淘汰算法选择

算法类型	实现类	适用场景	配置示例
LRU	LruCache	热点数据集中访问	eviction=”LRU”
FIFO	FifoCache	数据均匀访问	eviction=”FIFO”
SOFT	SoftCache	内存敏感型应用	eviction=”SOFT”
WEAK	WeakCache	临时缓存场景	eviction=”WEAK”

2.2 批量操作缓存处理

// 批量插入时的缓存处理方案
public void batchInsert(List<User> users) {
    SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
    try {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        for (User user : users) {
            mapper.insert(user);
            // 每1000条清空一次缓存
            if (i % 1000 == 0) {
                sqlSession.clearCache();
            }
        }
        sqlSession.commit();
    } finally {
        sqlSession.close();
    }
}

四、高级特性解析

1. 动态SQL脚本语言

1.1 OGNL表达式进阶

// 在test条件中使用OGNL方法调用
<if test="@com.example.MyUtils@isValid(name)">
  AND name = #{name}
</if>

// 集合判断优化
<if test="ids != null and ids.size > 0">
  AND id IN 
  <foreach item="id" collection="ids" open="(" separator="," close=")">
    #{id}
  </foreach>
</if>

2. 自定义缓存实现

2.1 集成Redis示例

public class RedisCache implements Cache {
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private String id;
    private JedisPool jedisPool;

    public RedisCache(String id) {
        this.id = id;
        this.jedisPool = new JedisPool("127.0.0.1", 6379);
    }

    @Override
    public Object getObject(Object key) {
        try (Jedis jedis = jedisPool.getResource()) {
            byte[] bytes = jedis.get(serializeKey(key));
            return bytes != null ? deserializeValue(bytes) : null;
        }
    }

    // 实现其他接口方法...
}

2.2 注册自定义缓存

<cache type="com.example.RedisCache">
  <property name="host" value="redis.example.com"/>
  <property name="port" value="6379"/>
</cache>

五、生产环境问题解决方案

1. 缓存一致性难题

1.1 多系统协同方案

graph LR
    A[业务系统A] -->|发布消息| B[消息队列]
    C[业务系统B] -->|订阅消息| B
    D[MyBatis二级缓存] -->|监听| B
    B -->|缓存失效通知| D

1.2 注解驱动清除

@CacheEvict(value="userCache", key="#user.id")
public void updateUser(User user) {
    userMapper.update(user);
}

2. 动态SQL调试技巧

2.1 日志输出完整SQL

# log4j配置
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

2.2 使用拦截器捕获SQL

@Intercepts({
    @Signature(type= Executor.class, method="query",
        args={MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})
public class SqlInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement ms = (MappedStatement) invocation.getArgs()[0];
        Object parameter = invocation.getArgs()[1];
        BoundSql boundSql = ms.getBoundSql(parameter);
        System.out.println("Executing SQL: " + boundSql.getSql());
        return invocation.proceed();
    }
}

六、性能对比测试数据

1. 动态SQL生成效率

场景	平均耗时(ms)	内存消耗(MB)
纯静态SQL	12.3	45
简单动态SQL(3个if)	15.7(+28%)	48
复杂动态SQL(嵌套10+)	34.2(+178%)	52

2. 缓存命中率对比

缓存策略	查询平均耗时	缓存命中率	适用场景
无缓存	120ms	0%	实时性要求极高
一级缓存	45ms	65%	单会话重复查询
二级缓存(LRU)	28ms	85%	多会话共享数据
分布式缓存	52ms	92%	集群环境