Mybatis：解决调用带有集合类型形参的mapper方法时，集合参数为空或null的问题

此文章有问题，待修改！

使用Mybatis时，有时需要批量增删改查，这时就要向mapper方法中传入集合类型（List或Set）参数，下面是一个示例。

// 该文件不完整，只展现关键部分
@Mapper
public class UserMapper {
    List<User> selectByBatchIds(List<Long> ids);
}

<!-- 省略不重要代码，只保留与selectByBatchIds()方法对应的部分 -->
  <select id="selectByBatchIds" parameterType="long" resultMap="user">
    select * from `user` 
      where id in <foreach item="id" collection="ids" open="(" separator="," close=")">#{id}</foreach>;
  </select>

但是如果传入的集合类型参数为null或空集合会怎样呢？如果集合类型参数为null，程序调用方法时抛出NullPointerException；如果集合类型参数为空集合，渲染出来的sql语句将会是"select * from `user` where id in ;"，执行sql时也会报错。

这类问题经典的解决办法有两种。第一种方法，在调用mapper方法前，检查方法实参是否为null或空集合；第二种方法：在XXMapper.xml的CRUD元素中使用<if>标签或<choose>标签进行判断，下面是一个改进的XXMapper.xml的示例。

<!-- 省略不重要代码，只保留与selectByBatchIds()方法相关的片段 -->
  <select id="selectByBatchIds" parameterType="long" resultMap="user">
    <choose>
      <when test="ids != null and ids.size() != 0">
        select * from `user` 
          where id in <foreach item="id" collection="ids" open="(" separator="," close=")">#{id}</foreach>
      </when>
      <otherwise>select * from `user` where false</otherwise>
    </choose>;
  </select>

上面的两种方法都需要在许多地方增加检查代码，显得不够优雅，有没有比较优雅的方法呢？有，使用Mybatis拦截器。拦截器可以拦截mapper方法的执行，根据条件决定mapper方法如何执行，如果传入的参数为空集合，则返回默认值（空集合、0或null）。下面是一个示例。

package demo.persistence.mybatis.interceptor;

import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentSkipListSet;

import static org.springframework.util.StringUtils.quote;
import static demo.consts.IntegerType.isIntegerType;
import static demo.consts.RegularExpression.CLASS_METHOD_DELIMITER;

/**
 * 此Mybatis拦截器处理mapper方法中集合类型参数为null或为空的情况。如果集合参数为null或为空，则mapper方法的返回值
 * 为空集合、0或null，具体返回值视方法本身的返回值而定。<br />
 * 注意：① 有的mapper方法将其所需参数放入Map中，此拦截器不处理此类情况；
 * ② 有时，向mapper方法传递null参数被视为错误，但此拦截器将其当做正常情况处理
 */
// Interceptors注解中写要拦截的的方法签名，但是此处要拦截的方法不是mapper类中的方法，而是Executor类中的方法。
// 可能Mybatis在执行mapper方法时是通过Executor类中的方法来执行的吧。
@Intercepts({
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class,
                RowBounds.class, ResultHandler.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class,
                RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class,Object.class})})
public class EmptyCollectionArgsInterceptor implements Interceptor {

    // 缓存具有集合参数的mapper方法名字以及集合参数的名字，执行这些方法时需要检查它的方法参数是否为null或为空
    private final static Map<String, Set<String>> REQUIRE_CHECK = new ConcurrentHashMap<>();
    // 缓存没有集合参数的mapper方法名字，执行这些方法时不需要检查它的方法参数
    private final static Set<String> NOT_CHECK = new ConcurrentSkipListSet<>();

    @Override
    public Object intercept(@NotNull Invocation invocation) throws Throwable {
        // 获得Executor方法的实参数组，第一个参数是MappedStatement对象，第二个参数是mapper方法的参数
        final Object[] executorMethodArgs = invocation.getArgs();
        MappedStatement mappedStatement = (MappedStatement) executorMethodArgs[0];
        // 关于mapperMethodArgs变量的说明：
        // (1) 如果mapper方法只有一个参数
        // ① 如果该参数实际为null，则mapperMethodArgs值为null；
        // ② 如果该参数为Map类型且不为null，则mapperMethodArgs的值就是该Map参数的值
        // ③ 如果该参数为List类型且不为null，则mapperMethodArgs的类型为MapperMethod.ParamMap（继承于HashMap），
        //    Map中有三对键值，它们的值都是该List类型实参，键则分别为"collection"、"list"和List形参的名字
        // ④ 如果该参数为Set类型且不为null，则mapperMethodArgs的类型为MapperMethod.ParamMap（继承于HashMap），
        //    Map中有两对键值对，它们的值都是该List类型实参，键则分别为"collection"和Set形参的名字
        // (2) 如果mapper方法有多个参数，无论实参是否为null，mapperMethodArgs的类型始终为MapperMethod.ParamMap，
        //     Map中的键值对就是mapper方法的形参名字与实参值的对，此时集合类型参数没有别名
        Object mapperMethodArgs = executorMethodArgs[1];
        // mapper方法id，就是在XXMapper.xml的CRUD元素中写的id，而且在该id前加上了对应mapper接口的全限定类名
        final String mapperMethodId = mappedStatement.getId();

        // 通过mapperMethodId判断该mapper方法是否有集合参数。如果mapperMethodId尚未缓存，requireCheck()方法会将其缓存。
        if (requireCheck(mapperMethodId)) {
            // 如果该mapper方法有集合参数
            // 而mapperMethodArgs为null，显然传入该mapper方法的实参为null，这时应该返回默认值
            if (mapperMethodArgs == null) {
                return getDefaultReturnValue(invocation);
            }
            // 如果mapperMethodArgs不为null，那么它一定是Map类型的参数
            Map<String, ?> argMap = (Map<String, ?>) mapperMethodArgs;
            final Set<String> requiredNotEmptyArgs = REQUIRE_CHECK.get(mapperMethodId);
            for (String requiredNotEmptyArg : requiredNotEmptyArgs) {
                // 从argMap取出所有集合类型的实参，检查它是否为null或是否为空。如果是，则返回默认值
                final Object arg = argMap.get(requiredNotEmptyArg);
                if (arg == null || ((Collection<?>) arg).isEmpty()) {
                    return getDefaultReturnValue(invocation);
                }
            }
        }

        // 如果上述检查没有问题，则让mapper方法正常执行
        return invocation.proceed();
    }

    /**
     * 当mapper方法出错时返回的默认值。
     * @return 如果Executor方法返回List类型对象，则此方法返回空List；如果Executor方法返回数字，则此方法返回0；其余情况返回null。
     */
    private @Nullable Object getDefaultReturnValue(@NotNull Invocation invocation) {
        Class<?> returnType = invocation.getMethod().getReturnType();
        if (returnType.equals(List.class)) {
            return Collections.emptyList();
            // isIntegerType()方法判断Class对象是不是整数Class，自己写
        } else if (isIntegerType(returnType)) {
            return 0;
        }
        return null;
    }

    /**
     * 检查mapper方法是否有集合类型参数。<br />
     * 注意：此方法有副作用。
     * @param mapperMethodId mapper方法。由mapper类的全限定名和方法名字组成。可由MappedStatement.getId()方法获取。
     * @throws ClassNotFoundException 如果未能找到指定的mapper方法的类
     * @throws NoSuchMethodException 如果未能找到指定的mapper方法
     */
    private static boolean requireCheck(String mapperMethodId) throws ClassNotFoundException, NoSuchMethodException {
        // 如果该方法名字存在于无需检查方法集合中，说明该方法无需检查，返回false
        if (NOT_CHECK.contains(mapperMethodId)) {
            return false;
        }
        // 如果该方法名字存在于需要检查方法Map中，说明该方法需要检查，返回true
        if (REQUIRE_CHECK.containsKey(mapperMethodId)) {
            return true;
        }

        // 如果方法名字不在缓存中，则进行以下操作：
        // 从完整方法名中分割出全限定类名和方法名
        // CLASS_METHOD_DELIMITER是类和方法分隔符，自己写吧
        final String[] fullClassAndMethod = mapperMethodId.split(CLASS_METHOD_DELIMITER, 2);
        final String fullQualifiedName = fullClassAndMethod[0];
        final String methodName = fullClassAndMethod[1];
        Method targetMethod = null;
        int paramCount = -1;
        // 遍历指定对应类的全部方法，以找到目标方法
        for (Method method : Class.forName(fullQualifiedName).getMethods()) {
            // 个人习惯是在mapper接口中定义几个重载的默认方法，这些默认方法的参数数量比同名的非默认方法的参数数量少，
            // 所以参数数量最多的方法就是要拦截并检查的方法
            if (method.getName().equals(methodName) && method.getParameterCount() > paramCount) {
                targetMethod = method;
                paramCount = method.getParameterCount();
            }
        }

        if (targetMethod == null) {
            throw new NoSuchMethodException("Can't find method " + quote(mapperMethodId));
        }
        // 检查目标方法是否有集合参数。如果有，则将该集合参数的名字放入collectionArgNames中。
        Set<String> collectionArgNames = new HashSet<>();
        for (Parameter parameter : targetMethod.getParameters()) {
            if (Collection.class.isAssignableFrom(parameter.getType())) {
                collectionArgNames.add(parameter.getName());
            }
        }
        if (collectionArgNames.isEmpty()) {
            // 如果collectionArgNames为空，说明该方法没有集合参数，不需要检查，返回false
            // 同时将该方法名字存入无需检查方法集合中
            NOT_CHECK.add(mapperMethodId);
            return false;
        } else {
            // 如果该collectionArgNames不为空，说明该方法有集合参数，需要检查，返回true
            // 同时将该方法名字存入需要检查方法Map中
            REQUIRE_CHECK.put(mapperMethodId, collectionArgNames);
            return true;
        }
    }

}

要使该拦截器生效，需要在mybatis-config.xml中配置该拦截器，在mybatis-config.xml中添加如下内容即可：

    <plugins>
        <plugin interceptor="demo.persistence.mybatis.interceptor.EmptyCollectionArgsInterceptor" />
    </plugins>