MyBatis IN查询优化：告别foreach模板

1. 为什么我们需要告别MyBatis的foreach模板？

在MyBatis的日常开发中，处理IN查询是最常见的场景之一。传统的做法是在Mapper XML中使用foreach标签动态生成IN语句，比如这样：

xml复制<select id="findUsersByIds" resultType="User">
  SELECT * FROM user 
  WHERE id IN
  <foreach collection="ids" item="id" open="(" separator="," close=")">
    #{id}
  </foreach>
</select>

这种写法虽然能完成任务，但存在几个明显的痛点：

1. 可读性差：当IN列表参数较多时，XML会变得冗长且难以维护
2. 性能隐患：大列表IN查询可能导致SQL语句过长，影响数据库解析效率
3. 复用困难：相似的IN查询需要在多个Mapper中重复编写foreach模板
4. 类型安全：集合参数的类型检查不够直观，容易在运行时出错

我在实际项目中遇到过这样一个案例：一个用户权限查询接口，需要根据角色ID列表查询对应的权限。随着业务发展，这个IN查询的参数列表从最初的几个ID增长到上百个，导致生成的SQL语句长度超过10KB，不仅难以调试，还造成了数据库性能问题。

2. 自定义TypeHandler的解决方案设计

2.1 核心思路解析

我们可以通过自定义TypeHandler来简化IN查询的编写。基本思路是：

1. 将Java中的集合类型(List/Set/Array)自动转换为SQL中的IN语句片段
2. 在Mapper接口中直接使用简洁的参数声明
3. 保持类型安全性和编译时检查

这样改造后，上面的查询可以简化为：

java复制@Mapper
public interface UserMapper {
    List<User> findUsersByIds(@Param("ids") List<Long> ids);
}

对应的XML只需要这样写：

xml复制<select id="findUsersByIds" resultType="User">
  SELECT * FROM user 
  WHERE id IN #{ids}
</select>

2.2 具体实现步骤

首先创建基础的CollectionTypeHandler：

java复制public abstract class CollectionTypeHandler<T> extends BaseTypeHandler<Collection<T>> {
    
    private final String separator;
    private final String open;
    private final String close;
    
    protected CollectionTypeHandler(String separator, String open, String close) {
        this.separator = separator;
        this.open = open;
        this.close = close;
    }
    
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, 
            Collection<T> parameter, JdbcType jdbcType) throws SQLException {
        String value = parameter.stream()
            .map(this::formatElement)
            .collect(Collectors.joining(separator, open, close));
        ps.setString(i, value);
    }
    
    protected abstract String formatElement(T element);
    
    // 其他方法实现...
}

然后针对具体类型实现子类，比如LongListTypeHandler：

java复制public class LongListTypeHandler extends CollectionTypeHandler<Long> {
    
    public LongListTypeHandler() {
        super(",", "(", ")");
    }
    
    @Override
    protected String formatElement(Long element) {
        return element.toString();
    }
}

2.3 注册TypeHandler

在MyBatis配置中注册我们的TypeHandler：

java复制@Configuration
public class MyBatisConfig {
    
    @Bean
    public ConfigurationCustomizer mybatisConfigurationCustomizer() {
        return configuration -> {
            TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
            typeHandlerRegistry.register(List.class, Long.class, new LongListTypeHandler());
            // 注册其他类型的处理器...
        };
    }
}

3. 高级用法与性能优化

3.1 支持多种集合类型

我们可以扩展实现来支持更多集合类型：

java复制public class StringSetTypeHandler extends CollectionTypeHandler<String> {
    
    public StringSetTypeHandler() {
        super(",", "(", ")");
    }
    
    @Override
    protected String formatElement(String element) {
        return "'" + element.replace("'", "''") + "'";
    }
}

然后在配置中注册：

java复制typeHandlerRegistry.register(Set.class, String.class, new StringSetTypeHandler());

3.2 大列表分块处理

对于可能包含大量元素的IN查询，我们可以实现分块处理：

java复制public class ChunkedListTypeHandler<T> extends CollectionTypeHandler<List<T>> {
    
    private final int chunkSize;
    
    public ChunkedListTypeHandler(int chunkSize) {
        super(" OR ", "", "");
        this.chunkSize = chunkSize;
    }
    
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i,
            List<T> parameter, JdbcType jdbcType) throws SQLException {
        List<List<T>> chunks = Lists.partition(parameter, chunkSize);
        String value = chunks.stream()
            .map(chunk -> "IN (" + 
                chunk.stream()
                    .map(this::formatElement)
                    .collect(Collectors.joining(",")) + 
                ")")
            .collect(Collectors.joining(separator, open, close));
        ps.setString(i, value);
    }
}

这样当列表超过指定大小时，会自动拆分为多个IN条件用OR连接。

3.3 动态SQL集成

我们还可以将这种方案与MyBatis的动态SQL结合：

xml复制<select id="findUsersByCondition" resultType="User">
  SELECT * FROM user
  <where>
    <if test="ids != null and !ids.isEmpty()">
      AND id IN #{ids}
    </if>
    <if test="name != null">
      AND name LIKE #{name}
    </if>
  </where>
</select>

4. 实际应用中的注意事项

4.1 类型安全与空值处理

在实际使用中，有几个关键点需要注意：

1. 空集合处理：当传入空集合时，应该生成一个永远为假的表达式如IN (NULL)，而不是直接忽略
2. 类型转换：确保集合元素类型与数据库字段类型匹配
3. SQL注入防护：字符串类型的元素必须正确转义

改进后的TypeHandler可以这样处理空值：

java复制@Override
public void setNonNullParameter(PreparedStatement ps, int i,
        Collection<T> parameter, JdbcType jdbcType) throws SQLException {
    if (parameter.isEmpty()) {
        ps.setString(i, "IN (NULL)");
        return;
    }
    // 正常处理逻辑...
}

4.2 性能对比测试

我们对三种实现方式进行了性能对比测试：

1. 传统foreach模板
2. 基础TypeHandler实现
3. 分块TypeHandler实现

测试结果（1000次查询平均耗时）：

可以看到，对于大列表查询，分块处理能带来明显的性能提升。

4.3 与其他MyBatis特性的兼容性

这种方案与MyBatis的其他特性也能良好配合：

1. 二级缓存：生成的SQL片段会被正确缓存
2. 插件系统：可以在插件中拦截和修改生成的SQL
3. 延迟加载：不影响关联对象的延迟加载行为

唯一需要注意的是与某些特殊类型处理器的优先级问题，可以通过调整注册顺序解决。

5. 扩展思路：更通用的SQL模板处理

5.1 支持其他SQL语法

我们可以将这种思路扩展到其他常见的SQL模板场景：

1. BETWEEN语句：自动将两个值的数组转换为BETWEEN条件
2. VALUES子句：简化批量插入的VALUES语法
3. CASE WHEN表达式：用Java数据结构生成复杂的CASE语句

例如，实现一个BetweenTypeHandler：

java复制public class BetweenTypeHandler extends BaseTypeHandler<Object[]> {
    
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i,
            Object[] parameter, JdbcType jdbcType) throws SQLException {
        if (parameter.length != 2) {
            throw new IllegalArgumentException("Between requires exactly 2 parameters");
        }
        ps.setString(i, parameter[0] + " AND " + parameter[1]);
    }
    
    // 其他方法实现...
}

使用方式：

xml复制<select id="findUsersByAgeRange" resultType="User">
  SELECT * FROM user 
  WHERE age BETWEEN #{ageRange}
</select>

5.2 与MyBatis-Plus的集成

如果你的项目使用MyBatis-Plus，可以创建相应的扩展：

java复制public class MybatisPlusCustomizer implements ISqlInjector {
    
    @Override
    public void inspectInject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass) {
        // 注册自定义方法
        builderAssistant.addMappedStatement(
            "selectByIds",
            new SqlSourceBuilder(builderAssistant.getConfiguration())
                .parse("SELECT * FROM ${tableName} WHERE id IN #{ids}", Map.class),
            SqlCommandType.SELECT,
            // 其他参数...
        );
    }
}

这样可以在Mapper接口中直接使用：

java复制public interface UserMapper extends BaseMapper<User> {
    @Select("selectByIds")
    List<User> selectByIds(@Param("ids") List<Long> ids);
}

5.3 动态条件生成器

更进一步，我们可以创建一个动态条件生成器：

java复制public class DynamicConditionBuilder {
    
    public static String in(String column, Collection<?> values) {
        return values.stream()
            .map(Object::toString)
            .collect(Collectors.joining(",", column + " IN (", ")"));
    }
    
    public static String between(String column, Object from, Object to) {
        return column + " BETWEEN " + from + " AND " + to;
    }
    
    // 其他条件方法...
}

在XML中使用：

xml复制<select id="searchUsers" resultType="User">
  SELECT * FROM user
  WHERE ${condition}
</select>

Java调用：

java复制List<User> users = userMapper.searchUsers(
    DynamicConditionBuilder.in("id", ids) + " AND " +
    DynamicConditionBuilder.between("age", 18, 30)
);

这种方案特别适合复杂动态查询场景，可以将条件构建逻辑完全移到Java代码中，利用编译时检查和IDE支持。