MyBatis处理多参数及原理分析

秒速五厘米 2022-05-30 11:11 197阅读 0赞

### 一、多参数处理方式 ###

#### 1.1使用`@Param`注解 ####

MyBatis 允许在mapper 接口中使用`@Param`注解来处理多个参数。

mapper 接口：

/** @Param 注解中的值可以是任意的 */
        Employee getEmpByIdAndUsername(@Param("id") Integer id, @Param("username") String username);

SQL 映射文件：

<select id="getEmpByIdAndUsername" resultType="employee">
            select * from t_employee where id = #{id} and username = #{username}
        </select>

#### 1.2使用`Map`封装多个参数 ####

MyBatis 允许使用`Map`来封装需要在SQL 中传入的参数。

mapper 接口：

Employee getEmpByMap(Map<String, Object> map);

SQL 映射文件：

<select id="getEmpByMap" resultType="employee">
            select * from t_employee where id = #{id} and username = #{username}
        </select>

测试代码，使用`Map`封装传递的参数：

// 用来封装在SQL 语句中需要传递的参数
        Map<String, Object> map = new HashMap<>();
    
        map.put("id", 1);
        map.put("username", "张三");
    
        Employee employee = employeeMapper.getEmpByMap(map);

#### 1.3使用`#{param1 ... n}`参数 ####

如果我们既不用`@Param`也不使用`map`，那么可以在编写SQL 语句的时候，使用`#{param1 ... n}`来代表需要传递的参数。

mapper 接口：

Employee getEmpByIdAndGender(Integer id, String username);

SQL 映射文件：

<select id="getEmpByIdAndGender" resultType="employee">
            select * from t_employee where id = #{param1} and gender = #{param2}
        </select>

#### 1.4发散思维 ####

比如遇到下面的几种情况时，我们要能够随机应变：

/** 第一个参数加@Param 注解，后面一个参数不加 */
        Employee getEmpByIdAndEmail(@Param("id") Integer id, String email);
    
        /** 编写SQL 参数对应方式 */
        id ==> #{param1}或id， email ==> #{param2}

/** 第二个参数是一个JavaBean 类型 */
        Employee getEmpByIdAndEmail(Integer id,@Param("employee") Employee email);
    
        /** 编写SQL 参数对应方式 */
        id ==> #{param1}， email ==> #{param2.email} 或employee.email

#### 1.5建议与小结 ####

建议：在书写多参数的SQL 语句时，如果需要传递的参数都是某个JavaBean 的属性，那么建议传入单个的JavaBean，通过JavaBean 来封装需要传递的参数。

比如改写`Employee getEmpByIdAndGender(Integer id, String username);`方法。

mapper 接口：

Employee getEmpByIdAndGender(Employee employee);

SQL 映射文件：

<select id="getEmpByIdAndGender" parameterType="employee" resultType="employee">
            select * from t_employee where id = #{id} and gender = #{gender}
        </select>

小结：在传入单个参数中，在编写SQL 语句时`#{ }`中的值可以是任意的，因为MyBatis 会自动对这个参数进行处理。在传递多个参数时，其实MyBatis 也会自动对多参数进行处理，会将这些参数在底层封装成一个`Map`。下面就通过DEBUG 的方式来一探究竟。

### 二、多参数封装成`Map`原理解析 ###

这里我们以`#{param1 ... n}`传递参数为例，也就是上面1.3 所使用的方式，下面是其测试代码(省略了`getSqlSession()`方法)：

@Test
        public void parameterTest() throws IOException {
            SqlSession sqlSession = getSqlSession();
    
            EmployeeMapper employeeMapper = sqlSession.getMapper(EmployeeMapper.class);
            Employee employee = employeeMapper.getEmpByIdAndGender(15, "1");
    
            System.out.println(employee);
        }

1.将断点打在`Employee employee = employeeMapper.getEmpByIdAndGender(15, "1");`上，会跳入到`MapperProxy<T>`类中的`invoke(Object proxy, Method method, Object[] args)`方法。

/** MapperProxy<T>类中的方法 */
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
          if (Object.class.equals(method.getDeclaringClass())) {
            return method.invoke(this, args);
          } else if (isDefaultMethod(method)) {
            return invokeDefaultMethod(proxy, method, args);
          }
        } catch (Throwable t) {
          throw ExceptionUtil.unwrapThrowable(t);
        }
        final MapperMethod mapperMethod = cachedMapperMethod(method);
        return mapperMethod.execute(sqlSession, args);
      }

在执行到最后一行`return mapperMethod.execute(sqlSession, args);`时，下面是其对应的参数信息：  
![这里写图片描述][70]  
2.接着打断点执行会跳到`MapperMethod`类中的`execute(SqlSession sqlSession, Object[] args)`方法，在这个方法中会对SQL 语句的类型进行判断，因为是`SELECT`语句，为了防止多余的代码太多，故删除了一些用不到的信息。

/** MapperMethod 类中的方法 */
    public Object execute(SqlSession sqlSession, Object[] args) {
        Object result;
        switch (command.getType()) {
          case INSERT: {
            Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.insert(command.getName(), param));
            break;
          }
         /** 省略了UPDATE 与DELETE 的情况*/
          case SELECT:
            if (method.returnsVoid() && method.hasResultHandler()) {
              executeWithResultHandler(sqlSession, args);
              result = null;
            } else if (method.returnsMany()) {
              result = executeForMany(sqlSession, args);
            } else if (method.returnsMap()) {
              result = executeForMap(sqlSession, args);
            } else if (method.returnsCursor()) {
              result = executeForCursor(sqlSession, args);
            } else {
              /** * 因为只查询一条信息，所以会进入到这里，method.convertArgsToSqlCommandParam(args) * 方法会对参数进行转换，下面继续跟踪，看看是如何进行参数转换的 */
              Object param = method.convertArgsToSqlCommandParam(args);
              result = sqlSession.selectOne(command.getName(), param);
            }
            break;
          case FLUSH:
            result = sqlSession.flushStatements();
            break;
          default:
            throw new BindingException("Unknown execution method for: " + command.getName());
        }
        if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
          throw new BindingException("Mapper method '" + command.getName() 
              + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
        }
        return result;
      }

3.接着跟踪，会跳到`MapperMethod`类中的`convertArgsToSqlCommandParam(Object[] args)` 方法，其中`args`中任然保存着传入的参数信息。

/** MapperMethod 类中的方法 */
        public Object convertArgsToSqlCommandParam(Object[] args) {
          return paramNameResolver.getNamedParams(args);
        }

4.接着打断点，会跳到`ParamNameResolver`类中的`getNamedParams(Object[] args)`方法，根据类名我们应该知道了，应该就是在这个类中对参数进行转换的。

/** ParamNameResolver 类中的方法 */
      public Object getNamedParams(Object[] args) {
        final int paramCount = names.size();
        if (args == null || paramCount == 0) {
          return null;
        } else if (!hasParamAnnotation && paramCount == 1) {
          return args[names.firstKey()];
        } else {
          final Map<String, Object> param = new ParamMap<Object>();
          int i = 0;
          for (Map.Entry<Integer, String> entry : names.entrySet()) {
            param.put(entry.getValue(), args[entry.getKey()]);
            // add generic param names (param1, param2, ...)
            final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
            // ensure not to overwrite parameter named with @Param
            if (!names.containsValue(genericParamName)) {
              param.put(genericParamName, args[entry.getKey()]);
            }
            i++;
          }
          return param;
        }
      }

在上面这个方法中有一个`names`属性，这个`names`是什么呢？`names` 其实是一个全局变量，并且是一个`Map`，`Map`中的`key`用于保存索引，`value`就是要保存的参数名。`names`通过`ParamNameResolver`类的构造函数来实例化存储信息。接着就进入到重点部分了。下面是`ParamNameResolver`类的构造函数：

/** * 下面是官方说明的names 存储规则： * 如果使用注解，则names 的key 保存索引，value 保存注解中的值 * 不使用下标，names 中key 保存索引，value 保存的也是参数的索引 * 特殊的参数在这里我们就不考虑了 * * <li>aMethod(@Param("M") int a, @Param("N") int b) -> { {0, "M"}, {1, "N"}}</li> * <li>aMethod(int a, int b) -> { {0, "0"}, {1, "1"}}</li> * <li>aMethod(int a, RowBounds rb, int b) -> { {0, "0"}, {2, "1"}}</li> * </ul> */
      private final SortedMap<Integer, String> names;   
    
      /** ParamNameResolver 类的构造函数 */
      public ParamNameResolver(Configuration config, Method method) {
        final Class<?>[] paramTypes = method.getParameterTypes();
        final Annotation[][] paramAnnotations = method.getParameterAnnotations();
        final SortedMap<Integer, String> map = new TreeMap<Integer, String>();
        int paramCount = paramAnnotations.length;
        // get names from @Param annotations
        for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
          if (isSpecialParameter(paramTypes[paramIndex])) {
            // skip special parameters
            continue;
          }
          String name = null;
          for (Annotation annotation : paramAnnotations[paramIndex]) {
            /** * 对当前注解判断，如果是Param 注解，就把Param 注解中的值赋给name， * 因为我们没有使用注解，所以name 为null */
            if (annotation instanceof Param) {
              hasParamAnnotation = true;
              name = ((Param) annotation).value();
              break;
            }
          }
          if (name == null) {
            // 如果没有指定@Param 注解，在这里通过getActualParamName(method, paramIndex) 方法为name 赋值
            if (config.isUseActualParamName()) {
              // 这里就不细节讲述是如何获得name 的值的了，有兴趣的可以自己查看源码进行了解
              name = getActualParamName(method, paramIndex);
            }
            // 到这里name 已经有值了，会直接跳过
            if (name == null) {
              // use the parameter index as the name ("0", "1", ...)
              // gcode issue #71
              name = String.valueOf(map.size());
            }
          // 在map 中存储信息，key 表示索引，value 为获得的name
          map.put(paramIndex, name);
        }
        // 为names 赋值
        names = Collections.unmodifiableSortedMap(map);
      }

下面是执行完构造函数后，`names`中保存的信息：  
![这里写图片描述][70 1]  
其实在给`names`的`value`赋值时，还加了`arg`前缀。PS：这里我们在进行测试的时候并没有使用`@Param`注解，如果使用的是`@Param`注解，那么`names` 的`value`保存的应该就是在`@Param`中设置的值。

分析完`names`中保存的是什么信息后，我们就可以对上面的`getNamedParams(Object[] args)`方法进行解析了。

/** ParamNameResolver 类中的方法 */
      public Object getNamedParams(Object[] args) {
        // 此时paramCount 为2
        final int paramCount = names.size();
        // 如果为空，直接返回
        if (args == null || paramCount == 0) {
          return null;
        } else if (!hasParamAnnotation && paramCount == 1) {
          // 如果没有使用注解并且只有一个参数，直接返回
          return args[names.firstKey()];
        } else {
          final Map<String, Object> param = new ParamMap<Object>();
          int i = 0;
          for (Map.Entry<Integer, String> entry : names.entrySet()) {
           /** * 遍历循环，把names 的value作为param 的key，names 的key 作为param 的value * 存储为{"arg0",0},{"arg1",1} 的格式 */
            param.put(entry.getValue(), args[entry.getKey()]);
            // GENERIC_NAME_PREFIX 的值是"param",继续进行处理，genericParamName 会是param1 ... n 
            final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
            /** * 把genericParamName 作为key，传递进来的SQL参数作为value * 存储为{"param1", "传递进来的参数"} 的格式 * 这样做的好处是即使你使用了@Param注解，你也可以通过使用#{param1 ... n}的方式来进行参数传递 */
            if (!names.containsValue(genericParamName)) {
              param.put(genericParamName, args[entry.getKey()]);
            }
            i++;
          }
          // 最后返回param
          return param;
        }
      }

最终`param`中保存的数据为：  
![这里写图片描述][70 2]  
5.接着一步步返回，返回的时候还进行了很多步骤，最终会执行到  
`result = sqlSession.selectOne(command.getName(), param);`，  
也就是返回到`MapperedMethod`中的`(SqlSession sqlSession, Object[] args)`方法，到这里就可以把信息查询出来了。  
![这里写图片描述][70 3]

### 三、总结 ###

这篇博客主要介绍了MyBatis 处理多参数的方法，以及需要注意的地方。学习不仅要知其然还要知其所以然，所以在博文的后半部分通过DEBUG 的方式对MyBatis 处理多参数封装成`Map`的原理进行了分析。建议大家自己动手去分析源码的底层，去了解更多的有趣的知识，希望这篇博文能够为读者提供帮助。

[70]: /images/20220530/6a7b287bdecf4bb48d0ff4df3e235fb6.png
[70 1]: /images/20220530/c918344a086a4fffb88f81269d68d0e8.png
[70 2]: /images/20220530/b57c43b9d27647ed94b09d06edc42937.png
[70 3]: /images/20220530/afa639dab94b49db9999c93f9e73be46.png