MyBatis 入门（一）：基本用法

@Test
public void selectByUsername() {
    System.out.println(customerMapper.selectByUsername("jack"));
}

==>  Preparing: select id, username name, job, phone from t_customer where username = ?
==> Parameters: jack(String)
<==    Columns: id, name, job, phone
<==        Row: 2, jack, teacher, 22222222222
<==      Total: 1
Customer(id=2, username=jack, job=teacher, phone=22222222222)

int insert(Customer customer);

    insert into t_customer values (#{id}, #{username}, #{job}, #{phone})

@After
public void end() throws IOException {
    // 在进行增删改操作时，一定要使用 commit() 方法提交事务，要不然数据库不会更新记录
    // 提交事务
    sqlSession.commit();
    // 释放 SqlSession
    sqlSession.close();
}

@Test
public void insert() {
    Customer customer = new Customer(4, "mark", "student", "44444444444");
    // 返回的是执行的 SQL 影响的行数
    int result = customerMapper.insert(customer);
    // 影响的行数为 1
    Assert.assertEquals(1, result);
}

==>  Preparing: insert into t_customer values (?, ?, ?, ?)
==> Parameters: 4(Integer), mark(String), student(String), 44444444444(String)
<==    Updates: 1

int insert2(Customer customer);

    insert into t_customer(username, job, phone) values (#{username}, #{job}, #{phone})

• useGeneratedKeys：默认值为 false。此属性会使 MyBatis 使用 JDBC 的 getGeneratedKeys() 方法来获取由数据库内部生产的主键值，如 MySQL 自增的主键值。
• keyProperty：此属性的作用是将插入或更新操作时的返回值赋值给 pojo 的某个属性，通常会设置为主键对应的属性。如果需要设置联合主键，可以在多个值之间用逗号隔开。
• keyColumn：此属性用于设置第几列是主键，当主键列不是表中的第一列时需要设置。在需要主键联合时，值可以用逗号隔开。

上述语句中，设置useGeneratedKeys="true"使得 MyBatis 使用数据库自增的主键；设置keyPropert="id"使得插入操作时自增的主键值回写到传入参数 customer 对象的 id 属性中。

? 对 insert2() 方法进行测试：

@Test
public void insert2() {
    Customer customer = new Customer(null, "Alice", "student", "55555555555");
    // 返回的是执行的 SQL 影响的行数
    int result = customerMapper.insert2(customer);
    // 影响的行数为 1
    Assert.assertEquals(1, result);
    // 自增主键回写进 customer 的 id 属性
    Assert.assertEquals(5, (long)customer.getId());
    System.out.println(customer);
}

==>  Preparing: insert into t_customer(username, job, phone) values (?, ?, ?)
==> Parameters: Alice(String), student(String), 55555555555(String)
<==    Updates: 1
Customer(id=5, username=Alice, job=student, phone=55555555555)

Update 用法

?? 在 CustomerMapper 接口中定义接口方法：

int updateById(Customer customer);

?? 在 CustomerMapper.xml 中添加相应的 SQL 语句：

    update t_customer
    set username=#{username}, job=#{job}, phone=#{phone}
    where id=#{id}

?? 对 updateById() 进行测试：

@Test
public void updateById() {
    Customer customer = new Customer(5, "Alice", "teacher", "55555555555");
    // 返回的是执行的 SQL 影响的行数
    int result = customerMapper.updateById(customer);
    // 影响的行数为 1
    Assert.assertEquals(1, result);
}

=>  Preparing: update t_customer set username=?, job=?, phone=? where id=?
==> Parameters: Alice(String), teacher(String), 55555555555(String), 5(Integer)
<==    Updates: 1

Delete 用法

?? 在 CustomerMapper 接口中定义接口方法：

int deleteById(Integer id);

?? 在 CustomerMapper.xml 中添加相应的 sql 语句：

    delete from t_customer where id=#{id}

?? 对 deleteById() 方法进行测试：

@Test
public void deleteById() {
    // 返回的是执行的 SQL 影响的行数
    int result = customerMapper.deleteById(4);
    // 影响的行数为 1
    Assert.assertEquals(1, result);
}

==>  Preparing: delete from t_customer where id=?
==> Parameters: 4(Integer)
<==    Updates: 1

SQL 语句的传参

前面已经介绍了 MyBatis 的 CURD 的简易实现，现在具体介绍下 SQL 语句的传参。SQL 语句传入参数可以是基本类型，引用类型（例如：String 类型），还可以是实体类类型（pojo 类），并且传入参数的个数可以不止一个，下面将进行讨论。

参数绑定规则

?? 当传入单个参数，且参数类型为简单数据类型（基本类型和字符串类型）时，在映射文件中，#{}里可以写任意值，MyBatis 不关心这个参数叫什么，会直接把这个唯一的参数拿来使用。

Customer selectById(Integer id);

    select id, username, job, phone
    from t_customer 
    where id = #{AAAA}

@Test
public void selectById() {
    System.out.println(customerMapper.selectById(1));
}

==>  Preparing: select id, username, job, phone from t_customer where id = ?
==> Parameters: 1(Integer)
<==    Columns: id, username, job, phone
<==        Row: 1, joy, doctor, 11111111111
<==      Total: 1
Customer(id=1, username=joy, job=doctor, phone=11111111111)

?? 当传入单个参数，且参数类型为 pojo 类时，直接使用#{属性名}取出 pojo 对象的属性值，使用#{pojo对象名.属性名}反而会抛出异常。需要注意，#{属性名}取值是使用 OGNL 表达式，所以相关属性要有 get 方法。

List selectByUsernameLikeAndJob(Customer customer);

    select id, username, job, phone
    from t_customer
    where username like concat('%', #{username}, '%') and job = #{job}

@Test
public void selectByUsernameLikeAndJob() {
    Customer customer = new Customer();
    customer.setUsername("j");
    customer.setJob("doctor");
    
    List customers = customerMapper.selectByUsernameLikeAndJob(customer);
    customers.forEach(System.out::println);
}

==>  Preparing: select id, username, job, phone from t_customer where username like concat('%', ?, '%') and job = ?
==> Parameters: j(String), doctor(String)
<==    Columns: id, username, job, phone
<==        Row: 1, joy, doctor, 11111111111
<==      Total: 1
Customer(id=1, username=joy, job=doctor, phone=11111111111)

?? 当传入单个参数，且参数类型为集合或者数组时，传入的参数会被封装进一个 Map 中，如果参数类型为集合，则 key 为 collection；如果参数类型为 List，还会添加一个 list 的 key；如果参数类型为数组，则 key 为 array。在映射文件中，使用#{list}和#{array}从 Map 中获取 List 集合和数组，使用#{list[0]}和#{array[0]}这种索引的方式分别获取 List 和数组的第一个元素。

List selectByUsernameLikeAndJob(List customerList);

    select id, username, job, phone
    from t_customer
    where username like concat('%', #{list[0].username}, '%') and job = #{list[0].job}

@Test
public void selectByUsernameLikeAndJob() {
    Customer customer = new Customer();
    customer.setUsername("j");
    customer.setJob("doctor");

    List customers = customerMapper.selectByUsernameLikeAndJob(Arrays.asList(customer));
    customers.forEach(System.out::println);
}

==>  Preparing: select id, username, job, phone from t_customer where username like concat('%', ?, '%') and job = ?
==> Parameters: j(String), doctor(String)
<==    Columns: id, username, job, phone
<==        Row: 1, joy, doctor, 11111111111
<==      Total: 1
Customer(id=1, username=joy, job=doctor, phone=11111111111)

?? 当传入多个参数时，所有参数会被封装进一个 Map，param1...paramN作为 key，对应索引位置的参数值作为 value。在映射文件中，使用#{param1}从 Map 中获取指定 key 的 value。

List selectByUsernameLikeAndJob(String username, String job);

    select id, username, job, phone
    from t_customer
    where username like concat('%', #{param1}, '%') and job = #{param2}

@Test
public void selectByUsernameLikeAndJob() {
    List customers = customerMapper.selectByUsernameLikeAndJob("j", "doctor");
    customers.forEach(System.out::println);
}

==>  Preparing: select id, username, job, phone from t_customer where username like concat('%', ?, '%') and job = ?
==> Parameters: j(String), doctor(String)
<==    Columns: id, username, job, phone
<==        Row: 1, joy, doctor, 11111111111
<==      Total: 1
Customer(id=1, username=joy, job=doctor, phone=11111111111)

?? 当传入的参数被 @Param 注解指定名字时，无论参数有多少个，都会被封装进一个 Map。此时，@Param 注解指定的名字作为 key，对应参数值作为 value。

List selectByUsernameLikeAndJob(@Param("c") Customer customer);

    select id, username, job, phone
    from t_customer
    where username like concat('%', #{c.username}, '%') and job = #{c.job}

此处需要注意，如果单纯传入单个 pojo 对象，可以直接使用#{属性名}取出对象的属性值；但是如果该 pojo 对象被 @Param 注解指定名字，那么只能使用#{指定名字.属性名}的方式取出对象的属性值。这是因为 pojo 对象被 @Param 修饰后，被封装进一个 Map，所以要先从 Map 中取出该 pojo 对象。

@Test
public void selectByUsernameLikeAndJob() {
    Customer customer = new Customer();
    customer.setUsername("j");
    customer.setJob("doctor");

    List customers = customerMapper.selectByUsernameLikeAndJob(customer);
    customers.forEach(System.out::println);
}

==>  Preparing: select id, username, job, phone from t_customer where username like concat('%', ?, '%') and job = ?
==> Parameters: j(String), doctor(String)
<==    Columns: id, username, job, phone
<==        Row: 1, joy, doctor, 11111111111
<==      Total: 1
Customer(id=1, username=joy, job=doctor, phone=11111111111)

多个参数的用法

当需要传入多个参数时，可以将多个参数封装为一个 pojo 对象，但并不适合全部的情况，因为不能只为了两三个参数去创建新的 pojo 类，因此对于参数比较少的情况，还有两种方式可以采用：使用 Map 类型作为参数和使用 @Param 注解。

? 使用 Map 类型作为参数

List selectByJobAndPhone(Map map);

    select id, username, job, phone
    from t_customer
    where job=#{job} and phone=#{phone}

这里#{job}和#{phone}参数名是传入 Map 的 key。下面对 selectByJobAndPhone() 进行测试：

@Test
public void selectByJobAndPhone() {
    Map map = new HashMap<>();
    map.put("job", "teacher");
    map.put("phone", "55555555555");

    List customers = customerMapper.selectByJobAndPhone(map);
    customers.forEach(System.out::println);
}

==>  Preparing: select id, username, job, phone from t_customer where job=? and phone=?
==> Parameters: teacher(String), 55555555555(String)
<==    Columns: id, username, job, phone
<==        Row: 5, Alice, teacher, 55555555555
<==      Total: 1
Customer(id=5, username=Alice, job=teacher, phone=55555555555)

? 使用 @Param 注解

List selectByJobAndPhone2(@Param("job") String job, @Param("phone") String phone);

    select id, username, job, phone
    from t_customer
    where job=#{job} and phone=#{phone}

这里#{job}和#{phone}参数名是 @Param 注解指定的名字。下面对 selectByJobAndPhone2() 进行测试：

@Test
public void selectByJobAndPhone2() {
    List customers = customerMapper.selectByJobAndPhone2("teacher", "55555555555");
    customers.forEach(System.out::println);
}

==>  Preparing: select id, username, job, phone from t_customer where job=? and phone=?
==> Parameters: teacher(String), 55555555555(String)
<==    Columns: id, username, job, phone
<==        Row: 5, Alice, teacher, 55555555555
<==      Total: 1
Customer(id=5, username=Alice, job=teacher, phone=55555555555)

需要注意：如果在动态 SQL 中使用了简单数据类型的参数作为判断条件，该参数需要使用 @Param 注解指定名字，即便只有一个参数。

动态 SQL

前面我们使用的 SQL 语句都是比较简单的，有些时候业务逻辑复杂时，我们的 SQL 是动态变化的，此处就需要使用动态 SQL。

if 用法

元素是最常用的判断语句，可类比于 Java 的 if 语句，用于实现某些简单的条件选择。

? where 条件中使用

下面定义一个高级查询功能。该查询能支持以下三种情况：当只输入客户名时，根据客户名进行模糊查询；当只输入职业时，根据职业进行完全匹配；当同时输入客户名和职业时，用这两个条件去查询匹配的客户。

List selectByCustomer(Customer customer);

    select id, username, job, phone
    from t_customer
    where 1 = 1
    
    
        and username like concat('%', #{username}, '%')
    
    
        and job = #{job}
    

test 是标签中的必填属性，属性值是一个符合 OGNL 要求的判断表达式，表达式的结果为 true 或 false。为了避免 SQL 语法错误导致的异常，我们在 where 关键字后加了1 = 1条件，这种写法不美观，可以使用标签代替，后续会介绍。下面对 selectByCustomer() 方法进行测试：

@Test
public void selectByCustomer() {
    Customer customer = new Customer();
    customer.setUsername("j");
    customer.setJob("teacher");

    List customers = customerMapper.selectByCustomer(customer);
    customers.forEach(System.out::println);
}

==>  Preparing: select id, username, job, phone from t_customer where 1 = 1 and username like concat('%', ?, '%') and job = ?
==> Parameters: j(String), teacher(String)
<==    Columns: id, username, job, phone
<==        Row: 2, jack, teacher, 22222222222
<==      Total: 1
Customer(id=2, username=jack, job=teacher, phone=22222222222)

? 在 update 更新列中使用

下面定义一个选择性更新方法，只更新有变化的字段，不能将原来有值但没有发生变化的字段更新为空或 null。

int updateByIdSelective(Customer customer);

    update t_customer
    set
    
    
        username = #{username},
    
    
        job = #{job},
    
    
        phone = #{phone},
    
    id = #{id}
    where id = #{id}

动态 SQL 也提供了一个标签，后续会介绍。下面对 updateByIdSelective() 方法进行测试：

@Test
public void updateByIdSelective() {
    Customer customer = new Customer();
    customer.setId(2);
    customer.setJob("student");
    
    int result = customerMapper.updateByIdSelective(customer);
    Assert.assertEquals(1, result);
}

==>  Preparing: update t_customer set job = ?, id = ? where id = ?
==> Parameters: student(String), 2(Integer), 2(Integer)
<==    Updates: 1

? 在 insert 动态插入列中使用

下面定义一个动态插入列的方法。在数据库表中插入数据的时候，如果某一列的参数值不为空，就使用传入的值；如果传入参数为空，就不使用传入的空值。

int insertSelective(Customer customer);

    insert into t_customer(
        
        
            job,
        
        
            phone,
        
    	username)
    values(
        
            job = #{job},
        
        
            phone = #{phone},
        
    	#{username})

对 insertSelective() 方法进行测试：

@Test
public void insertSelective() {
    Customer customer = new Customer();
    customer.setUsername("Bob");

    int result = customerMapper.insertSelective(customer);
    Assert.assertEquals(1, result);
}

==>  Preparing: insert into t_customer( username) values( ?)
==> Parameters: Bob(String)
<==    Updates: 1

choose 用法

标签能提供了基本的条件判断，但有时需要从多个选项中选择一个去执行。

下面定义一个查询需求，当参数 id 有值优先使用 id 查询；当 id 没有值时，就去判断客户名是否有值，如果有值就用客户名查询，如果无值，那么 SQL 查询无结果。

Customer selectByIdOrUsername(Customer customer);

    select id, username, job, phone
    from t_customer
    where 1 = 1
    
    
        
            and id = #{id}
        
        
            and username = #{username}
        
        
            and 1 = 2
        
    

choose...when...otherwise标签相当于 Java 的switch...case...default，从多个选项选择一个去执行。一个 choose 中至少有一个 when，有 0 个或者 1 个 otherwise。下面对 selectByIdOrUsername() 方法进行测试：

@Test
public void selectByIdOrUsername() {
    Customer customer = new Customer();
    customer.setUsername("jack");
    
    System.out.println(customerMapper.selectByIdOrUsername(customer));
}

==>  Preparing: select id, username, job, phone from t_customer where 1 = 1 and username = ?
==> Parameters: jack(String)
<==    Columns: id, username, job, phone
<==        Row: 2, jack, student, 22222222222
<==      Total: 1
Customer(id=2, username=jack, job=student, phone=22222222222)

where、set、trim 用法

这 3 个标签解决了类似的问题，并且和都属于的一种特殊用法。

where 用法

使用标签重写 selectByCustomer() 方法对应的 SQL：

    select id, username, job, phone
    from t_customer
        
    
        
            and username like concat('%', #{username}, '%')
        

        
            and job = #{job}
        
    

set 用法

使用标签重写 updateByIdSelective() 方法对应的 SQL：

    update t_customer
    
    
        
            username = #{username},
        
        
            job = #{job},
        
        
            phone = #{phone},
        
        id = #{id},
    
    where id = #{id}

在标签的用法中，SQL 后面的逗号会自动去除，但是如果 set 元素中没有内容，仍会出现 SQL 错误，所以为了避免错误产生，类似id=#{id}这样条件还需保留。

trim 用法

和标签的功能都可以用 trim 标签来实现。

?? 标签对应实现如下：

    ...

注意：这里的 and 和 or 后面的空格不能省略，为了避免匹配到 andes、orders 等单词。

?? 标签对应实现如下：

    ...

?? 标签属性

• prefix：当标签内包含内容时，会给内容增加 prefix 指定的前缀。
• prefixOverrides：当标签内包含内容时，会把内容中匹配的前缀字符串去掉。
• suffix：当标签内包含内容时，会给内容增加 suffix 指定的后缀。
• suffixOverrides：当标签内包含内容时，会把内容中匹配的后缀字符串去掉。

foreach 用法

基本使用

元素通常在构建 in 条件语句时使用，用于数组和集合循环遍历。

下面定义一个根据传入的客户 id 集合查询出所有符合条件的客户方法：

List findCustomerByIds(List ids);

    select id, username, job, phone
    from t_customer where id in
    
        #{id}
    

标签属性如下：

• collection：必填，值为要选代循环的属性名。这个属性值的情况有很多。
• item：变量名，值为从迭代对象中取出的每一个值。
• index：索引的属性名，在集合数组情况下值为当前索引值， 当选代循环的对象是 Map 类型时，这个值为 Map 的 key （键值）。
• open/close：整个循环内容开头/结尾的字符串。
• separator：每次循环的分隔符。

在使用时，collection 属性必须设置。在不同情况下，该属性值不一样的：

?? 传入的单个参数类型为集合或数组

前面也提到，当传入的单个参数类型是集合或数组时，会被封装进一个 Map：

• 如果参数类型是集合，会添加一个 key 为 collection 的值；如果参数类型是 List 集合，还会继续添加一个 key 为 list 的值；因此，当需要遍历传入的 List 集合时，设置collection = "list"。
• 如果参数类型是数组，会添加一个 key 为 array 的值。因此，当需要遍历数组时，设置collection = "array"。

上面提到的是数组或集合参数在 Map 中的默认名字，推荐使用 @Param 来指定名字，这时 collection 就可以设置为 @Param 注解指定的名字。

?? 传入多个参数

当有多个参数的时候，一般需要使用 @Param 注解给每个参数指定一个名字，否则在 SQL 中使用参数就会不方便，因此将 collection 设置为 @Param 注解指定的名字即可。

?? 传入的参数是 Map

使用 Map 和使用 @Param 注解方式类似，如果想循环的是 Map 中的某个 value，将 collection 指定为对应的 key 即可。如果要循环的是所传入的 Map，推荐使用 @Param 注解指定名字，此时可将 collection 设置为指定的名字；如果不想指定名字，就使用默认值_parameter，_parameter是 MyBatis 的内置参数，代表整个传入参数。

?? 传入参数是 pojo 对象

这种情况下指定为对象的属性名即可。当使用对象内多层嵌套的对象时，使用属性.属性（集合和数组可以使用下标取值）的方式可以指定深层的属性值。

对 findCustomerByIds() 方法进行测试：

@Test
public void findCustomerByIds() {
    List ids = new ArrayList<>();
    ids.add(1);
    ids.add(2);

    List customers = customerMapper.findCustomerByIds(ids);
    customers.forEach(System.out::println);
}

==>  Preparing: select id, username, job, phone from t_customer where id in ( ? , ? )
==> Parameters: 1(Integer), 2(Integer)
<==    Columns: id, username, job, phone
<==        Row: 1, joy, doctor, 11111111111
<==        Row: 2, jack, student, 22222222222
<==      Total: 2
Customer(id=1, username=joy, job=doctor, phone=11111111111)
Customer(id=2, username=jack, job=student, phone=22222222222)

实现批量插入

int insertList(List customerList);

    insert into t_customer(username, job, phone) values
    
        (#{c.username}, #{c.job}, #{c.phone})
    

对 insertList() 进行测试：

@Test
public void insertListTest() {
    List customerList = new ArrayList<>();
    customerList.add(new Customer(null, "A", "Student", null));
    customerList.add(new Customer(null, "B", "Student", null));
    customerList.add(new Customer(null, "C", "Student", null));
    int result = customerMapper.insertList(customerList);
    Assert.assertEquals(3, result);
}

==>  Preparing: insert into t_customer(username, job, phone) values (?, ?, ?) , (?, ?, ?) , (?, ?, ?)
==> Parameters: A(String), Student(String), null, B(String), Student(String), null, C(String), Student(String), null
<==    Updates: 3

实现动态更新

int updateByMap(@Param("map") Map map);

    update t_customer
    set
    
        ${key} = #{val}
    
    where id = #{map.id}

对 updateByMap() 方法进行测试：

@Test
public void updateByMap() {
    Map map = new HashMap<>();
    map.put("id", 1);
    map.put("phone", "1234566777");

    int result = customerMapper.updateByMap(map);
    Assert.assertEquals(1, result);
}

==>  Preparing: update t_customer set phone = ? , id = ? where id = ?
==> Parameters: 1234566777(String), 1(Integer), 1(Integer)
<==    Updates: 1

bind 用法

元素可以通过 OGNL 表达式来创建一个上下文变量。

List selectByNameLike(Customer customer);

    
    select id, username, job, phone
    from t_customer
    where username like #{pattern_username}

对 selectByNameLike() 方法进行测试：

@Test
public void testSelectByNameLike() {
    Customer c = new Customer();
    c.setUsername("j");

    List customers = customerMapper.selectByNameLike(c);
    customers.forEach(System.out::println);
}

==>  Preparing: select id, username, job, phone from t_customer where username like ?
==> Parameters: %j%(String)
<==    Columns: id, username, job, phone
<==        Row: 1, joy, doctor, 1234566777
<==        Row: 2, jack, student, 22222222222
<==      Total: 2
Customer(id=1, username=joy, job=doctor, phone=1234566777)
Customer(id=2, username=jack, job=student, phone=22222222222)

内置参数_paramter

MyBatis 里存在一个内置参数_paramter，该内置参数表示整个传入参数。

• 当传入单个参数时，_parameter就是这个参数；
• 当传入多个参数时，参数会被封装为一个 map，_parameter就是代表这个map。

下面对 selectByCustomer() 方法对应的 SQL 进行重写：

List selectByCustomer(Customer customer);

    select id, username, job, phone
    from t_customer
    
        
            and username like concat('%', #{_parameter.username}, '%')
        

        
            and job = #{_parameter.job}
        
    

上述语句中，_parameter代表着传入的参数 customer，可以使用_parameter.属性名获取其属性值。

参考

1. 《MyBatis从入门到精通》
2. 《Java EE企业级应用开发教程(Spring+Spring MVC+MyBatis)》