MyBatis 进阶治理点——缓存、副作用、拦截与批处理的得失分析

<!-- OrderMapper.xml -->
<cache/>
<!-- 引用UserMapper的缓存 -->
<cache-ref namespace="com.example.mapper.UserMapper"/>

<!-- 配置Redis作为二级缓存 -->
<cache type="org.mybatis.caches.redis.RedisCache"
       eviction="LRU"
       flushInterval="300000"
       size="1024"/>

<select id="selectUser" parameterType="int" resultType="User" 
        useCache="true" flushCache="false">
    SELECT * FROM users WHERE id = #{id}
</select>

<insert id="insertUser" parameterType="User" flushCache="true">
    INSERT INTO users(name, email) VALUES(#{name}, #{email})
</insert>

<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>

# application.yml
mybatis:
  configuration:
    local-cache-scope: statement

@Options(flushCache = Options.FlushCachePolicy.TRUE)
@Select("SELECT id FROM orders WHERE status = 'pending' LIMIT 1")
Integer findNextPendingOrder();

public class CacheMutexLock {
    private static final ConcurrentHashMap<String, Lock> LOCKS = new ConcurrentHashMap<>();
    
    public static <T> T executeWithLock(String key, Supplier<T> supplier) {
        Lock lock = LOCKS.computeIfAbsent(key, k -> new ReentrantLock());
        lock.lock();
        try {
            return supplier.get();
        } finally {
            lock.unlock();
            LOCKS.remove(key);
        }
    }
}

<cache eviction="LRU" flushInterval="300000" size="1024" 
       randomExpiration="true" baseExpiration="300000"/>

@Intercepts({
    @Signature(type = ParameterHandler.class, method = "setParameters", 
               args = {PreparedStatement.class}),
    @Signature(type = ResultHandler.class, method = "handleResultSets", 
               args = {Statement.class})
})
@Component
public class DataSecurityInterceptor implements Interceptor {
    
    private final EncryptionService encryptionService;
    
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        if (invocation.getTarget() instanceof ParameterHandler) {
            // 参数加密逻辑
            return encryptParameters(invocation);
        } else {
            // 结果集解密逻辑
            return decryptResultSets(invocation);
        }
    }
}

@Intercepts({
    @Signature(type = StatementHandler.class, method = "prepare", 
               args = {Connection.class, Integer.class})
})
public class DataAuthInterceptor implements Interceptor {
    
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler handler = (StatementHandler) invocation.getTarget();
        String originalSql = getOriginalSql(handler);
        
        if (needDataAuth(originalSql)) {
            String authCondition = buildAuthCondition();
            String newSql = appendCondition(originalSql, authCondition);
            setSql(handler, newSql);
        }
        
        return invocation.proceed();
    }
}

@Override
public Object intercept(Invocation invocation) throws Throwable {
    long startTime = System.currentTimeMillis();
    try {
        return invocation.proceed();
    } finally {
        long duration = System.currentTimeMillis() - startTime;
        if (duration > SLOW_QUERY_THRESHOLD) {
            log.warn("Interceptor slow query: {}ms, method: {}", 
                     duration, invocation.getMethod().getName());
        }
    }
}

private static final ThreadLocal<Boolean> PROCESSING = ThreadLocal.withInitial(() -> false);

@Override
public Object intercept(Invocation invocation) throws Throwable {
    if (PROCESSING.get()) {
        return invocation.proceed(); // 避免递归
    }
    
    PROCESSING.set(true);
    try {
        // 拦截器逻辑
        return processInvocation(invocation);
    } finally {
        PROCESSING.set(false);
    }
}

public void batchInsertUsers(List<User> users) {
    SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
    try {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int batchSize = 1000;
        int count = 0;
        
        for (User user : users) {
            mapper.insertUser(user);
            count++;
            
            if (count % batchSize == 0) {
                sqlSession.commit();
                sqlSession.clearCache(); // 避免缓存堆积
            }
        }
        sqlSession.commit();
    } finally {
        sqlSession.close();
    }
}

@Select("SELECT * FROM large_table WHERE condition = #{condition}")
@Options(resultSetType = ResultSetType.FORWARD_ONLY, fetchSize = 1000)
@ResultType(User.class)
void streamLargeData(@Param("condition") String condition, ResultHandler<User> handler);

public class BatchOperationManager {
    
    public void safeBatchInsert(List<Data> dataList) {
        int retryCount = 0;
        while (retryCount < MAX_RETRY) {
            try {
                doBatchInsert(dataList);
                break; // 成功则退出重试
            } catch (BatchException e) {
                retryCount++;
                if (retryCount >= MAX_RETRY) {
                    log.error("Batch insert failed after {} retries", MAX_RETRY);
                    throw e;
                }
                handlePartialFailure(e, dataList);
            }
        }
    }
    
    private void handlePartialFailure(BatchException e, List<Data> dataList) {
        // 识别失败记录并重试
        List<Data> failedRecords = identifyFailedRecords(e, dataList);
        if (!failedRecords.isEmpty()) {
            doBatchInsert(failedRecords);
        }
    }
}

@Component
public class MyBatisMetricsCollector {
    
    private final MeterRegistry meterRegistry;
    
    public void recordQueryExecution(String statement, long duration, boolean fromCache) {
        meterRegistry.timer("mybatis.query.execution")
                    .tags("statement", statement, "cached", String.valueOf(fromCache))
                    .record(duration, TimeUnit.MILLISECONDS);
    }
    
    public void recordCacheHit(String cacheLevel, boolean hit) {
        meterRegistry.counter("mybatis.cache.access")
                    .tags("level", cacheLevel, "hit", String.valueOf(hit))
                    .increment();
    }
}

<!-- logback-spring.xml -->
<logger name="com.example.mapper" level="DEBUG" additivity="false">
    <appender-ref ref="MYBATIS_JSON_APPENDER"/>
</logger>

<appender name="MYBATIS_JSON_APPENDER" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
        <providers>
            <timestamp/>
            <logLevel/>
            <loggerName/>
            <message/>
            <mdc/>
        </providers>
    </encoder>
</appender>

@Intercepts(@Signature(type = Executor.class, method = "query", 
           args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}))
public class SlowQueryInterceptor implements Interceptor {
    
    private static final long SLOW_QUERY_THRESHOLD = 1000; // 1秒
    
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        long start = System.currentTimeMillis();
        try {
            return invocation.proceed();
        } finally {
            long duration = System.currentTimeMillis() - start;
            if (duration > SLOW_QUERY_THRESHOLD) {
                Object[] args = invocation.getArgs();
                MappedStatement ms = (MappedStatement) args[0];
                log.warn("Slow query detected: {}ms, statement: {}", 
                         duration, ms.getId());
            }
        }
    }
}

# application-dev.yml
mybatis:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    cache-enabled: false

# application-prod.yml  
mybatis:
  configuration:
    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl
    cache-enabled: true
    local-cache-scope: statement