mybatis传递多个参数的 4 种方法

Mybatis在使用Mapper接口进行编程时，其实底层是采用了动态代理机制，表面上是调用的Mapper接口，而实际上是通过动态代理调用的SqlSession的对应方法，其最终会获得一个代理了Mapper接口的MapperProxy对象。MapperProxy对象在调用Mapper接口方法时会把传递的参数做一个转换，然后把转换后的参数作为入参调用SqlSession对应的操作方法（如：selectOne、insert等）。

使用myBatis注解形式的SQL，则首先需要在启动类上使用@MapperScan注解扫描到SQL所在的DAO接口或者mapper接口。

传递多个参数的 4 种方法

1.Java Bean 传参法

参数以Bean形式传入，这种方法很直观，但需要建一个实体类（请求体），扩展时需要向类中添加属性

1.1 指定变量名

Controller.java

@GetMapping("/api/user/page/bean")
public R pageWithBean(UserPageRequest request) {
    log.debug("分页『Bean传参法』......");
    UserPageRequestParams params = new UserPageRequestParams();
    BeanUtils.copyProperties(request, params);
    Page page = userMapper.pageWithBean(new Page(request.getCurrent(), request.getSize()), params);
    return R.ok(page);
}

UserMapper.java

/**
  * 指定变量名“params”
  *
  * @param page
  * @param params
  * @return
  */
 Page pageWithBean(Page page, @Param("params") UserPageRequestParams params);

UserMapper.xml

    SELECT * FROM tb_user u
    
        
            AND u.name LIKE CONCAT('%',#{params.name},'%')
        
        
            AND u.email LIKE CONCAT('%',#{params.email},'%')
        
        
            AND u.phone_type = #{params.phoneType}
        
        
            AND u.gender = #{params.gender}
        
    

#{}里面的名称对应的是User类里面的成员属性

1.2 默认变量名

Controller.java

@GetMapping("/api/user/page/bean/default")
public R pageWithBean(UserPageRequest request) {
    log.debug("分页『Bean传参法』......");
    UserPageRequestParams params = new UserPageRequestParams();
    BeanUtils.copyProperties(request, params);
    Page page = userMapper.pageWithBeanDefault(new Page(request.getCurrent(), request.getSize()), params);
    return R.ok(page);
}

UserMapper.java

/**
  * 默认变量“params” --> “param2”
  *
  * @param page
  * @param params
  * @return
  */
 Page pageWithBeanDefault(Page page, UserPageRequestParams params);

UserMapper.xml

    SELECT * FROM tb_user u
    
        
            AND u.name LIKE CONCAT('%',#{param2.name},'%')
        
        
            AND u.email LIKE CONCAT('%',#{param2.email},'%')
        
        
            AND u.phone_type = #{param2.phoneType}
        
        
            AND u.gender = #{param2.gender}
        
    

#{}里面的名称对应的是User类里面的成员属性
#{param2.xxx}：param2为默认变量名

2.Map 传参法

参数以Map形式传入，这种方法对后台来说是一劳永逸（以后如果需要添加参数，Controller可以不用修改，只需要修改SQL文件），但是不直观，对于Map中解析了什么是不清楚的

Controller.java

@GetMapping("/api/user/page/map")
public R pageWithMap(Map paramsMap) {
    log.debug("分页『Map传参法』......");
    Page page = userMapper.pageWithMap(new Page(request.getCurrent(), request.getSize()), paramsMap);
    Page page = userMapper.pageWithMapDefault(new Page(request.getCurrent(), request.getSize()), paramsMap);
    return R.ok(page);
}

@GetMapping("/api/user/page/map/default")
public R pageWithMap(Map paramsMap) {
    log.debug("分页『Map传参法』......");
    Page page = userMapper.pageWithMapDefault(new Page(request.getCurrent(), request.getSize()), paramsMap);
    return R.ok(page);
}

UserMapper.java

/**
  * 指定变量名“paramsMap”
  *
  * @param page
  * @param paramsMap
  * @return
  */
Page pageWithMap(Page page, @Param("paramsMap") Map paramsMap);

/**
  * 默认变量“paramsMap” --> “param2”
  *
  * @param page
  * @param paramsMap
  * @return
  */
Page pageWithMapDefault(Page page, Map paramsMap);

UserMapper.xml

   SELECT * FROM tb_user u
    
        
            AND u.name LIKE CONCAT('%',#{paramsMap.name},'%')
        
        
            AND u.email LIKE CONCAT('%',#{paramsMap.email},'%')
        
        
            AND u.phone_type = #{paramsMap.phoneType}
        
        
            AND u.gender = #{paramsMap.gender}
        
    



    SELECT * FROM tb_user u
    
        
            AND u.name LIKE CONCAT('%',#{param2.name},'%')
        
        
            AND u.email LIKE CONCAT('%',#{param2.email},'%')
        
        
            AND u.phone_type = #{param2.phoneType}
        
        
            AND u.gender = #{param2.gender}
        
    

3.@Param注解传参法

这种方法在参数不多的情况还是比较直观的，若参数多的情况下推荐使用** Java Bean 传参法**

Controller.java

@GetMapping("/api/user/page/param")
public R pageWithParam(UserPageRequest request) {
    log.debug("分页『@Param注解传参法』......");
    Page page = userMapper.pageWithParam(new Page(request.getCurrent(), request.getSize()),
            request.getName(),
            request.getEmail(),
            request.getPhoneType(),
            request.getGender()
    );
    return R.ok(page);
}

UserMapper.java

Page pageWithParam(Page page,
                         @Param("name") String name,
                         @Param("email") String email,
                         @Param("phoneType") String phoneType,
                         @Param("gender") String gender);

UserMapper.xml

    SELECT * FROM tb_user u
    
        
            AND u.name LIKE CONCAT('%',#{name},'%')
        
        
            AND u.email LIKE CONCAT('%',#{email},'%')
        
        
            AND u.phone_type = #{phoneType}
        
        
            AND u.gender = #{gender}
        
    

#{}里面的名称对应的是注解@Param括号里面修饰的名称

4. 索引传参法（也叫顺序传参法）

#{}里面的参数如果使用arg，则从0开始。如果使用param，则从1开始，如：param1，因SQL层表达不直观，且一旦顺序调整容易出错，所以这种方法不建议使用

Controller.java

@GetMapping("/api/user/page/index")
public R pageWithIndex(UserPageRequest request) {
    log.debug("分页『Index传参法』......");
    Page page = userMapper.pageWithIndex(new Page(request.getCurrent(), request.getSize()),
            request.getName(),
            request.getEmail(),
            request.getPhoneType(),
            request.getGender()
    );
    return R.ok(page);
}

UserMapper.java

Page pageWithIndex(Page page,
                         String name,
                         String email,
                         String phoneType,
                         String gender);

UserMapper.xml

    SELECT * FROM tb_user u
    
        
            AND u.name LIKE CONCAT('%',#{param2},'%')
        
        
            AND u.email LIKE CONCAT('%',#{param3},'%')
        
        
            AND u.phone_type = #{param4}
        
        
            AND u.gender = #{param5}
        
    

传入混合参数的获取方式

1. 既有注解参数，又有普通参数

有注解的可以使用注解中使用的名字，没有注解的只能使用该参数对应的 Key（param1或者其它位置）

@Select("SELECT * FROM tb_user WHERE id = #{id} AND `name` = #{param2}")
User getUser(@Param("id") Integer id, String name);

取值：
id → #{id} 或 #{param1}
name → #{param2}

2. 既有普通参数，又有一个参数是一个对象

没有注解的只能使用该参数对应的 Key（param1或者其它位置），另一个对象使用对应位置的 key 获得该对象之后，再获得其相应的属性

@Select("SELECT * FROM tb_user WHERE id = #{param1} AND `name` = #{param2.name}")
User getUser(Integer id, User user);

取值：
id → #{param1}
name → #{param2.name}

3. 既有普通参数，又有一个参数是一个对象，且该对象使用了注解

没有注解的只能使用该参数对应的 Key（param1或者其它位置），另一个对象使用对应位置的 key 获得该对象之后，再获得其相应的属性（又因为该对象又有注解，所以可以使用注解时的名字获得对象后，再获得其属性值）

@Select("SELECT * FROM tb_user WHERE id = #{param1} AND `name` = #{param2.name}")
User getUser(Integer id, @Param("user") User user);

或

@Select("SELECT * FROM tb_user WHERE id = #{param1} AND `name` = #{user.name}")
User getUser(Integer id, @Param("user") User user);

取值：
id → #{param1}
name → #{param2.name} 或 #{user.name}

4. 参数是 Collection（List、Set）类型或者是数组

mybatis会特殊处理，把传入的Collection或者数组封装在map中（其中的key是mybatis封装好了，国定的，不会改变的）

参数类型	KEY
Collection	collection
List	list
Array	array

Collection取出第一个 id 的值

User getUserById(Collection ids);

取值：#{collection[0]}

List取出第一个 id 的值

User getUserById(List ids);

取值：#{collection[0]}

Set取出第一个 id 的值

User getUserById(Set ids);

取值：#{collection[0]}

Array取出第一个 id 的值

User getUserById(Array ids);

取值：#{array[0]}