Mybatis复杂查询及动态SQL

Mybatis复杂查询及动态SQL
文章目录
本篇中使用的数据表即基础映射类都是基于上一篇博客的，如果有需要可以移步： MyBatis配置及单表操作

 一. 较复杂的查询操作

 1. 参数占位符#{}和${}

#{}：预处理符，生成的执行 sql 中将id=#{6}替换为id=?，最后使用6替换了?作为参数。
${}：替换符，生成的执行 sql 中将id=${6}替换为id=6，直接替换，属于字符串拼接。

🍂两种占位符都可以正常使用的场合：传入的参数类型是数值类型。

使用${}：
```
select * from userinfo where id=${id}
select * from userinfo where id=6
1
2
```
使用#{}：
```
select * from userinfo where id=#{id}
select * from userinfo where id=?
1
2
```
对于这两种参数占位符，都能使用的情况下，更建议使用#{}就使用#{}，因为${}存在 SQL 注入的问题，以及在特殊场景下如果传入的类型是字符串也会出问题。

🍂只能使用#{}而不能使用${}的场合：传入参数类型为 String

使用${}：
```
select * from userinfo where username=${username}
//实际执行的语句 (比如前端通过 URL 传入的参数)
Preparing: select * from userinfo where username=张三
1
2
3
```
但是在 sql 中通过字符串来查询数据，是需要加上引号的，而使用${}生成的sql并没有带引号，因此不适用于字符串参数的sql。

使用#{}：
```
select * from userinfo where username=#{username}
//实际执行语句
select * from userinfo where username=?
1
2
3
```
由于使用#{}是将目标参数替换为占位符，然后利用 JDBC 中的占位符机制实现 sql 语句的填充，最终是会带上引号的，所以使用#{}构造的 sql 是可以正常运行的，并且没有 SQL 注入的问题。

🎯所以，#{}相比于${}，它支持所有类型的参数，包括数值类与字符串类，而${}支持数值类型，不支持字符串类型的参数，但也可以在原来 sql 里面为${}外面加上一对引号来使用。
```
select * from userinfo where username='${username}'
//实际执行语句
select * from userinfo where username='张三'
1
2
3
```
当传递的参数为字符串类型的时候，虽然加上一对引号，使用${}也可以使用，但是${}存在 SQL 注入问题，所以仍然不推荐，有关 SQL 注入后面在下文有介绍。

🍂大部分场合下，使用#{}都可以解决，但还是存在一小部分只能是${}来处理的。

如当我们需要按照升序或者逆序得到数据库查询结果的时候，这种场合就只能使用${}，使用#{}会报错，我们来演示一下。

首先，我们在Mapper接口中声明一个方法：作用就是按照排序获取结果集
```
List<Userinfo> getAllByOrder(@Param("myOrder") String myOrder);
1
```
我们再去xml文件中去写 sql 语句：首先我们使用$进行演示
```
<select id="getAllByOrder" resultType="com.example.demo.model.UserInfo">
    select * from userinfo order by id ${myOrder}
</select>
1
2
3
```
写一个单元测试，代码很简单，就是调用 sql，然后得到结果集：
```
@Test
void getOrderList() {
    List<UserInfo> userMappers = userMapper.getOrderList("desc");
    System.out.println(userMappers);
}
1
2
3
4
5
```
单元测试结果：
可以正常查询，得到的结果与预期也是相同的。

我们再来试一试使用#{}来构造 sql 语句：
```
<select id="getOrderList" resultType="com.example.demo.model.UserInfo">
    select * from userinfo order by createtime #{order};
</select>
1
2
3
```
重新执行单元测试，看下面的结果：

我们发现程序报错了，这是因为使用了desc的字符串（带引号）替换了占位符，而我们所需要的不是一个desc字符串，而是直接一个desc的关键字（不带引号），所以 sql 也抛出了语法错误，这里最终执行的 sql 如下：
```
select * from userinfo order by createtime ‘desc’;
1
```
而期望执行的 sql 为：
```
select * from userinfo order by createtime desc;
1
```
所以在传递 sql 命令（关键字）的时候，不能使用#{}，只能使用${}。

总之，如果不得不使用${}，那么传递的参数一定要能被穷举，此时才能在业务代码中对传递的值进行安全校验，否则是不能使用的。

2. SQL注入

SQL 注入就是使用${}实现一些特殊的语句，来达到非法获取数据的目的，如不通过正确的密码获取某账户的信息，下面我们来演示一下，就以登录的例子来演示，SQL 注入可以在不知道密码的前提下登录成功，并且获取到用户的相关信息。

首先我将数据库只保留一个用户信息，方便演示 SQL 注入问题：

1️⃣第一步，在Mapper接口中定义方法login，返回登录成功的用户对象。
```
public UserInfo login(@Param("username") String username, @Param(("password")) String password);
1
```
2️⃣第二步，在xml文件中编写 sql 语句，我们需要演示 SQL 注入，所以我们使用${}来构造 sql 语句。
```
<select id="login" resultType="com.example.demo.model.UserInfo">
    select * from userinfo where username='${username}' and password='${password}';
</select>
1
2
3
```
3️⃣第三步，编写单元测试，传入有注入问题的 sql 语句' or 1='1，此时不需要密码就能拿到相关的用户信息。
```
@Test
void login() {
    String username = "admin";
    String password = "' or 1='1";

    UserInfo userInfo = userMapper.login(username, password);
    System.out.println(userInfo);
}
1
2
3
4
5
6
7
8
```
结果如下：
我们在不知道用户密码的情况下，就登录成功，并拿到了用户的信息。

最终执行的 sql 语句为：
```
select * from userinfo where username='admin' and password='' or 1='1';
1
```
相当于它在原来条件判断的语句下，后面有加上一个或的逻辑，并且或后面的表达式为true，这样就使得原来的 SQL 语句中的条件判断部分一定为真，所以就在没有正确密码的情况下拿到了用户的基本信息。

所以我们能不使用${}就不使用${}，它存在 SQL 注入问题，如果必须使用${}则需要验证一下传递的参数是否合法，比如上面定义排序的 sql，传递的参数只能是desc或者是asc，如果不是就不能执行这条 SQL，防止 SQL 注入情况的发生。

3. like查询

在 Mybatis 中使用like查询比较特殊，因为直接使用#{}会报错，而使用${}，由于输入的字符串情况很多，无法做到枚举，验证比较困难，无法避免 SQL 注入问题。

首先，我们来演示使用#{}进行like查询。

1️⃣第一步，声明方法。
```
List<UserInfo> getLikeList(@Param("username") String username);
1
```
2️⃣第二步，xml 中实现执行 sql。
```
<select id="getLikeList" resultType="com.example.demo.model.UserInfo">
    select * from userinfo where username like '%#{username}%'
</select>
1
2
3
```
3️⃣第三步，单元测试。
```
@Test
void getLikeList() {
    String username = "a";
    List<UserInfo> list = userMapper.getLikeList(username);
    System.out.println(list);
}
1
2
3
4
5
6
```
结果如下：

报错了，因为#{}会被替换成一个字符串，而在这个%#{username}%语句中#{username}是不能带上引号的，带上就违背 SQL 语法，执行就会出错。

使用#{}会多出一对引号，而使用${}又无法穷举出所有情况进行验证，就可能有 SQL 注入问题，所以这里是不能直接使用#{}的，我们需要搭配 MySQL 内置的字符串拼接语句concat。

我们将 sql 改为使用concat进行字符串拼接：
```
<select id="getLikeList" resultType="com.example.demo.model.UserInfo">
    select * from userinfo where username like concat('%', #{username}, '%')
</select>
1
2
3
```
重新执行单元测试，此时就可以正常执行了。

4. resultType与resultMap

resultType表示数据库返回的数据映射在 java 程序中所对应的类型，只要定义类中的属性与数据库中表的字段名字一致就没有任何问题，但是如果不一致，冲突的属性就无法获取到数据库查询的结果。

比如用户名属性在数据库中的名字是username，而在 java 程序类中的属性名为name，此时通过 mybatis 将数据传递到程序中的对象时，获取到的name属性为null，就不能正确地获取到对应的属性值，为了解决这个数据库字段与类中中字段不匹配的问题，我们需要使用到resultMap。

resultMap 的使用方式就是在xml文件中设置标签，至少需要设置两个属性，一个是id表示你这个 resultMap 标签的名字，还有一个是type属性，它表示映射到程序中类的类型，需包含包名。

这个标签里面需要设置至少两个子标签，一个是id标签，另外一个是result标签，前者表示主键，后者表示数据库表中普通的列，这两种标签也是至少需要设置两个属性，一个是column表示数据库表中的字段名，另外一个是property表示程序类中的对应属性名，如果只是在单表进行查询，只设置不同字段名的映射就可以了，但是如果是多表查询，必须将数据表中所有的字段与类中所有的属性生成映射关系。

就像下面这样，图中类属性与数据表字段是相同的，实际情况可以存在不同的字段名：

所以，当类中的属性和数据库表中的字段名不一致，面对查询结果为null的这种情况，有三种解决方案：
1. 将类中的属性和数据库表的字段名改成一致的。
2. 使用 sql 语句中的 as 进行列名（字段名）重命名，让列名（字段名）等于属性名即可。
3. 就是上面介绍的，定义一个 resultMap，将属性名和字段名进行手动映射。
5. 多表查询

 5.1. 一对一表映射

一对一关系就是对于一个属性只与另外一个属性有关系的映射，这就是一对一的关系，举个例子，对于一篇博客，它只会对应到一个用户，那么博客与用户的关系就是一对一的关系，下面我们尝试在 mybatis 中实现一对一多表联查。

首先我们将数据库中的博客表与 java 程序中的博客类对应起来，就是按照数据库中的博客表建立一个类：
```
@Data
public class Articleinfo {
    private int id;
    private String title;
    private String content;
    private LocalDateTime createtime;
    private LocalDateTime updatetime;
    private int uid;
    private int rcount;
    private int state;
    // 联表字段
    private UserInfo userInfo;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
```
目前文章表中只有一条数据，如下图：

1️⃣第一步，创建Mapper接口和对应的xml文件。

2️⃣第二步，在接口中声明方法和在 xml 中写 sql 标签与语句。
```
// 根据文章 id 获取文章对象, 显示用户信息
public ArticleInfo getArticleById(@Param("id") Integer id);
<select id="getArticleById" resultType="com.example.demo.model.ArticleInfo">
    select * from articleinfo where id=#{id};
</select>
1
2
3
4
5
```
3️⃣第三步，编写单元测试并执行。

结果如下：

由于我们数据表的字段与类的属性名是一致的，那些普通的属性都一一对应上了，都成功被赋值了，但是由于UserInfo类在数据表中没有，所以并没有得到 UserInfo 对象。

🍂如果我们想要拿到这个对象，我们可以使用resultMap，而且 sql 也需要修改，想要实现一对一多表查询，需要设置多表查询 sql 语句，我们使用左外连接进行多表查询：
```
<select id="getArticleById" resultMap="BaseMap">
    select a.*, u.* from articleinfo as a left join userinfo as u on  a.uid=u.id where a.id=#{id};
</select>
1
2
3
```
此外，我们除了设置username与Articleinfo类中每个属性与数据表的映射之外，我们还要在Articleinfo类对应的resultMap中使用association标签。最少需要设置两个属性，一个是property表示在主表Articleinfo中对应副表UserInfo映射对象的变量名，另外一个是副表UserInfo对应的resultMap。

Articleinfo类对应的 resultMap：
```
<resultMap id="BaseMap" type="com.example.demo.model.Articleinfo">
    <id column="id" property="id"></id>
    <result column="title" property="title"></result>
    <result column="content" property="content"></result>
    <result column="createtime" property="createtime"></result>
    <result column="updatetime" property="updatetime"></result>
    <result column="uid" property="uid"></result>
    <result column="rcount" property="rcount"></result>
    <result column="state" property="state"></result>

    <association property="userInfo" resultMap="com.example.demo.dao.UserMapper.BaseMap"></association>
</resultMap>
1
2
3
4
5
6
7
8
9
10
11
12
```
UserInfo类对应的 resultMap：
```
<resultMap id="BaseMap" type="com.example.demo.model.UserInfo">
    <id column="id" property="id"></id>
    <result column="username" property="username"></result>
    <result column="password" property="password"></result>
    <result column="photo" property="photo"></result>
    <result column="createtime" property="createtime"></result>
    <result column="updatetime" property="updatetime"></result>
    <result column="state" property="state"></result>
</resultMap>
1
2
3
4
5
6
7
8
9
```
注意多表查询时要将 resultMap 中的所有字段进行映射，如果UserInfo类的 resultMap 没有将所有的属性都与数据库的表映射，就会造成获取到的userInfo对象中的数据不完整，假设只设置了id与name的映射，那就只能获取到的对象id与name的值，其他字段是获取不到的。

将两张表的 resultMap 映射好后，我们运行同样的单元测试代码，结果如下：

🎯但此时仍然存在一个问题，我们所建的两个表存在名字相同的字段，可能会出现数据覆盖的情况，如两个表的主键都叫id，但是id在两个表的含义是不同的，在用户表它表示用户id，在文章表它表示文章的id，现在我们将获取两表的数据的id改为不相同，再来看一看单元测试运行的结果：

从正常的逻辑上看，由于不存在id为1的用户，所以获取到UserInfo对象应该为null才对，但是运行的结果却存在UserInfo对象，并且与文章表的重名字段都被赋值了文章表中的数据，为了解决这个问题，我们必须在文章表（主表）的resultMap中设置属性columnPrefix，它的值随便设置，作用是识别副表字段时加上一段前缀，如我们给用户表的字段加上前缀u_，此时 sql 中就不能使用*来一次表示所有元素了，需要一个一个单独设置，并将字段全部重命名，带上u_前缀。

association字段设置：
```
<association property="userInfo" columnPrefix="u_" resultMap="com.example.demo.mapper.UserMapper.BaseMap" ></association>
1
```
sql 语句需要将用户表的字段全部重命名：
```
<select id="getArticleById" resultMap="BaseMap">
    select a.*, u.id as u_id,
           u.username as u_username,
           u.password as u_password,
           u.photo as u_photo,
           u.createtime as u_createtime,
           u.updatetime as u_updatetime,
           u.state as u_state
    from articleinfo as a left join userinfo as u on  a.uid=u.id where a.id=#{id};
</select>
1
2
3
4
5
6
7
8
9
10
```
我们将userInfo对应的用户表的id再改回为1。

再次执行单元测试代码：

此时是能够获取到相应的数据的，所以如果两个表字段重名了，进行多表查询时，需要设置columnPrefix属性，这样才能够避免不同表同名字段数据覆盖的问题。

所以，在创建数据库的数据表时，尽量不要让表与表中的字段重名。

🍂除了基于xml实现多表查询，还可以基于注解实现，使用注解就简单了不少，直接设置参数为相应的 sql 即可，比如再声明一个getArticleById2方法，使用注解实现具体的执行 sql。
```
// 根据文章 id 获取文章对象, 显示用户信息 (基于注解)
@Select("select a.*, u.* from articleinfo as a left join userinfo as u on  a.uid=u.id where a.id=#{id};")
ArticleInfo getArticleById2(@Param("id") Integer id);
1
2
3
```
单元测试代码：
```
@Test
void getArticleById2() {
    ArticleInfo articleinfo = articleMapper.getArticleById(1);
    System.out.println(articleinfo);
}
1
2
3
4
5
```
结果如下：

5.2. 一对多表映射

一对多的关系，就是对于一个属性，它对映着多个其他的属性，比如用户与博客之间的关系，一个用户可以对应多篇博客，那么用户与博客之间的关系就是一对多的关系；我们再尝试使用 mybatis 实现多对多的多表联查。

🍂下面我们以用户表为主，文章表为辅，来演示如何进行一对多关系的多表查询。

既然是一对多的关系，那我们可以在UserInfo类中加上一个储存ArticleInfo对象的List，来储存用户发布或所写的文章。
```
@Data
public class UserInfo {
    private Integer id;
    private String username;
    private String password;
    private String photo;
    private String createtime;
    private String updatetime;
    private Integer state;
    // 联表字段
    private List<Articleinfo> aList;
}
1
2
3
4
5
6
7
8
9
10
11
12
```
实现多表查询的大致过程如下：
- 在 Mapper 接口中声明方法，我们声明一个方法，就是通过用户 id 获取用户信息以及对应的文章列表。
```
// 根据 id 查询用户信息, 显示相应文章信息
UserInfo getUserAndArticlesById(@Param("uid") Integer id);
1
2
```
- 在xml文件当中写resultMap映射关系，与一对一多表查询不同的是，我们需要设置collection标签，而不是association标签。
- 在xml文件的resultMap标签中至少设置 resultMap 名字id，对应映射的类type等属性，里面需要设置数据表与类中所有属性的映射，以及设置collection标签，需要设置property属性表示需映射的对象名，设置 resultMap 即副表的resultMap路径，由于你无法保证表与表之间是否存在重名字段，需要设置columnPrefix为副表的字段添加上一个前缀，防止重名数据覆盖。
```
<collection
        property="aList"
        resultMap="com.example.demo.mapper.ArticleMapper.BaseMap"
        columnPrefix="a_">
</collection>
1
2
3
4
5
```
- 在对应的xml文件当中写 sql 标签以及语句。
```
<select id="getUserAndArticlesById" resultMap="BaseMap">
    select u.*, 
           a.id as a_id,
           a.title as a_title,
           a.content as a_content,
           a.createtime as a_createtime,
           a.updatetime as a_updatetime,
           a.uid as a_uid,
           a.rcount as a_rcount,
           a.state as a_state
           from userinfo as u left join articleinfo as a on u.id=a.uid where u.id=#{uid}
</select>
1
2
3
4
5
6
7
8
9
10
11
12
```
- 编写单元测试代码，验证结果。
```
@Test
void getUserAndArticlesById() {
    Integer id = 1;
    UserInfo userInfo = userMapper.getUserAndArticlesById(id);
    System.out.println(userInfo);
}
1
2
3
4
5
6
```
结果如下：

🍂同样也可以使用注解完成，实现起来更简单。
```
// 根据 id 查询用户信息, 显示相应文章信息 (基于注解)
@Select("select u.*, a.* from userinfo as u left join articleinfo as a on u.id=a.uid where u.id=#{uid};")
UserInfo getUserAndArticlesById2(@Param("uid") Integer id);
1
2
3
```
单元测试代码：
```
@Test
void getUserAndArticlesById2() {
    Integer id = 1;
    UserInfo userInfo = userMapper.getUserAndArticlesById(id);
    System.out.println(userInfo);
}
1
2
3
4
5
6
```
结果如下：

🍂上面的方式都是对两张表联合后进行的查询，是一步实现的，其实也可以分步实现，比如这里可以先根据uid查询到用户信息，再由uid查询到相应文章信息，可以使用多线程分别执行这两步效率更高，然后将文章信息整合到用户对象中的aList字段中即可。

定义方法，这里使用注解实现相应执行 sql。
```
// 根据用户 id 查询用户信息。
@Select("select * from userinfo where id=#{id}")
UserInfo getUserById2(@Param("id")Integer id);

// 根据用户 id 查询相应文章信息 
@Select("select * from articleinfo where uid=#{uid}")
List<ArticleInfo> getListByUid(@Param("uid")Integer uid);
1
2
3
4
5
6
7
```
单元测试代码：
```
@Test
void getUserList() {
    int uid = 1;
    // 定义线程池
    ThreadPoolExecutor threadPool =
            new ThreadPoolExecutor(5, 10,
                    100, TimeUnit.SECONDS,
                    new LinkedBlockingQueue<>(100));
    final Object[] resultArray = new Object[2];
    threadPool.submit(new Runnable() {
        @Override
        public void run() {
            // 1. 根据 uid 查询 userinfo
            resultArray[0] = userMapper.getUserById2(uid);
        }
    });
    threadPool.submit(new Runnable() {
        @Override
        public void run() {
            // 2. 根据 uid 查询查询文章列表
            resultArray[1] = articleMapper.getListByUid(uid);
        }
    });
    // 组装数据 (等线程池执行完成之后)
    while (threadPool.getTaskCount() !=
            threadPool.getCompletedTaskCount()) {
    }
    UserInfo userinfo = (UserInfo) resultArray[0];
    userinfo.setAList((List<ArticleInfo>) resultArray[1]);
    System.out.println(userinfo);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
```
执行测试方法，结果如下：

二. 动态SQL

动态 SQL 是 MyBatis 的强大特性之一了，如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号；利用动态 SQL，可以彻底摆脱这种痛苦；使用动态 SQL 并非一件易事，但借助可用于任何 SQL 映射语句中的强大的动态 SQL 语言，MyBatis 显著地提升了这一特性的易用性。

之前介绍的 mybatis 增删查改，所传的参数都是一定会传入的，但是在实际情况中，很多参数都是非必传参数，使用动态 SQL 就可以解决传入的参数是非必传参数的情况。

动态 SQL 可以解决多余符号的问题，如,等。

1. if标签

if标签的作用就是判断一个参数是否有值，如果没有值就将对应的参数隐藏。

语法：
```
<if test="表达式">
	sql
</if>
// 例如
<if test="参数!=null">
	sql部分语句
</if>
1
2
3
4
5
6
7
```
当表达式为真，则插入if标签中的sql，否则不插入。

我们以在用户表中插入一条记录为例，其中插入的字段中头像photo不是必传的参数：

方法声明：
```
// 使用动态sql插入数据
int addUser(UserInfo userInfo);
1
2
```
动态SQL语句：
其中的photo是非必传参数，我们使用if标签来判断它是否有值，没有值就不插入目标的 sql 语句。
```
<insert id="addUser">
    insert into userinfo(username, password
    <if test="photo!=null">
        , photo
    </if>
    ) values(#{username}, #{password}
    <if test="photo!=null">
        , #{photo}
    </if>
    )
</insert>
1
2
3
4
5
6
7
8
9
10
11
```
单元测试代码：
```
@Test
void addUser() {
    UserInfo userinfo = new UserInfo();
    userinfo.setUsername("zhangsan");
    userinfo.setPassword("123");
    int result = userMapper.addUser(userinfo);
    System.out.println("受影响行数: " + result);
}
1
2
3
4
5
6
7
8
```
在单元测试代码中，没有给 photo 赋值，if 标签会判断它为空，不会生成插入 photo 字段的 sql。

结果如下：

数据库查询结果：

再来试一试给 photo 传值的情况，此时生成的 sql 有三个参数：
```
@Test
void addUser() {
    UserInfo userinfo = new UserInfo();
    userinfo.setUsername("lisi");
    userinfo.setPassword("123");
    userinfo.setPhoto("default.png");
    int result = userMapper.addUser(userinfo);
    System.out.println("受影响行数: " + result);
}
1
2
3
4
5
6
7
8
9
```
结果如下：
最终生成的语句多了一个photo参数。

数据库结果：

2. trim标签

if标签可以实现非必传参数 sql 的构造，在极端情况下，有很多个非必传参数，此时如果只使用if标签构造出的 sql 语句很有可能会多出一个,，因为有很多非必传参数，如果只传来一个参数，由于不确定后面是否还会有参数，因此会预留一个,，此时如果没有其他参数，就会多出一个,。

而trim标签可以去除 sql 语句前后多余的指定字符，它需要搭配if标签使用。

标签中有如下属性：
- prefix：表示整个语句块，以 prefix 的值作为前缀
- suffix：表示整个语句块，以 suffix 的值作为后缀
- prefixOverrides：表示整个语句块要去除掉的前缀
- suffixOverrides：表示整个语句块要去除掉的后缀
语法：
```
<trim prefix="前缀符", suffix="后缀符", prefixOverrides="去除多余的前缀字符", suffixOverrides="去除多余的后缀字符">
	<if test="表达式">
		...
	</if>
	...
	...
</trim>
1
2
3
4
5
6
7
```
假设username，password，photo都是非必传参数，但是至少传递一个，我们来写插入语句的动态 SQL。
```
<insert id="addUser2">
    insert into userinfo
    <trim prefix="(" suffix=")" prefixOverrides="," suffixOverrides=",">
        <if test="username!=null">
            username,
        </if>
        <if test="password!=null">
            password,
        </if>
        <if test="photo!=null">
            photo
        </if>
    </trim>
    values
    <trim prefix="(" suffix=")" prefixOverrides="," suffixOverrides=",">
        <if test="username!=null">
            #{username},
        </if>
        <if test="password!=null">
            #{password},
        </if>
        <if test="photo!=null">
            #{photo}
        </if>
    </trim>
</insert>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
```
单元测试代码：
```
@Test
void addUser2() {
    UserInfo userInfo = new UserInfo();
    userInfo.setUsername("wangwu");
    userInfo.setPassword("12345622");
    int result = userMapper.addUser(userInfo);
    System.out.println("受影响行数: " + result);
}
1
2
3
4
5
6
7
8
```
运行结果与生成的 sql 语句：

我们发现多余的逗号被自动去除了。

3. where标签

where标签主要是替换where关键字使用，可以动态的生成条件，如果 sql 中没有使用到where（没有查询条件），就不会生成where，存在查询条件，就会生成含有 where 的查询 sql 语句，并且可以自动去除前面多余的and。

此时我们 userinfo 表中的数据如下：

假设我们可以根据id，username，passward中的一个或者几个获取用户信息。
```
<select id="getUserListByWhere" resultType="com.example.demo.model.UserInfo">
    select * from userinfo
    <where>
        <if test="id>0">
            id=#{id}
        </if>
        <if test="username!=null">
            and username=#{username}
        </if>
        <if test="password!=null">
            and  password=#{password}
        </if>
    </where>
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
单元测试代码：

这里只传入一个username看是否可以自动删除前面多余的and。
```
@Test
void getListByWhere() {
    UserInfo userinfo = new UserInfo();
    userinfo.setUsername("wangwu");
    List<UserInfo> list = userMapper.getUserListByWhere(userinfo);
    System.out.println(list);
}
1
2
3
4
5
6
7
```
结果如下：
发现自动生成了where语句并删除了多余的and。

如果我们不设置任何参数，查询一个null值，就不会生成where语句。

以上标签也可以使用替换，和以下写法效果是一样的。
```
<select id="getUserListByWhere" resultType="com.example.demo.model.UserInfo">
    select * from userinfo
    <trim prefix="where" prefixOverrides="and">
        <if test="id>0">
            id=#{id}
        </if>
        <if test="username!=null">
            and username=#{username}
        </if>
        <if test="password!=null">
           and password=#{password}
        </if>
    </trim>
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
4. set标签

set标签与where标签很相似，where用来替换查询SQL，而set是用于修改 sql 中，用来自动生成set部分的SQL语句。

set标签可以自动去除最后面的一个,。

比如我们写一个能够修改账户名username，密码password，头像photo的动态 SQL，根据id进行修改。

方法声明：
```
// 使用动态SQL实现修改用户信息，包括账户名，密码，头像
int updateUser(UserInfo userInfo);
1
2
```
动态 SQL：
```
<update id="updateUser">
    update userinfo
    <set>
        <if test="username!=null">
            username=#{username},
        </if>
        <if test="password!=null">
            password=#{password},
        </if>
        <if test="photo!=null">
            photo=#{photo}
        </if>
    </set>
    where id=#{id}
</update>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
```
单元测试代码：
```
@Test
void updateUser() {
    UserInfo userinfo = new UserInfo();
    userinfo.setId(3);
    // 修改密码为 456
    userinfo.setPassword("456");
    int result = userMapper.updateUser(userinfo);
    System.out.println("受影响行数 : " + result);
}
1
2
3
4
5
6
7
8
9
```
结果如下：
修改成功并且可以根据传入参数个数自动生成相应的修改 sql，以及可以自动去除最后的,。

数据库验证：

以上标签也可以使用替换，和以下写法效果是一样的。
```
<update id="updateUser">
    update userinfo
    <trim prefix="set" suffixOverrides=",">
        <if test="username!=null">
            username=#{username},
        </if>
        <if test="password!=null">
            password=#{password},
        </if>
        <if test="photo!=null">
            photo=#{photo}
        </if>
    </trim>
    where id=#{id}
</update>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
```
5. foreach标签

对集合进行遍历可以使用foreach标签，常用的场景有批量删除功能。
- collection：绑定方法参数中的集合，如 List，Set，Map或数组对象
- item：遍历时的每一个对象
- open：语句块开头的字符串
- close：语句块结束的字符串
- separator：每次遍历之间间隔的字符串
为了方便演示批量删除，我们随便插入几条数据到数据库：

方法声明：
```
// 使用动态 sql 批量删除元素
public int deleteIds(List<Integer> ids);
1
2
```
动态 SQL 语句：
```
<delete id="delByIds">
    delete from userinfo where id in
    <foreach collection="ids" open="(" close=")" item="id" separator=",">
        #{id}
    </foreach>
</delete>
1
2
3
4
5
6
```
单元测试代码：
删除数据库中id为 8 9 10 11 的用户。
```
@Test
void delByIds() {
    List<Integer> list = new ArrayList<Integer>() {{
        add(8);
        add(9);
        add(10);
        add(11);
    }};
    int result = userMapper.delByIds(list);
    System.out.println("受影响行数" + result);
}
1
2
3
4
5
6
7
8
9
10
11
```
结果如下：

验证数据库，成功生成了批量删除的 sql，这就是foreach标签的作用，它能够遍历集合。
相关阅读:
小红书达人投放比例是多少合适？品牌方必看
 图像数据增强2_标注框同时修改（VOC、YOLO）
redis主从
 【软件测试】作为测试人，因工作与开发吵了一架碰撞，该咋办......
element-plus组件问题汇总
 带临床数据的热图 -- 给样品添加TNM分期、年龄、性别、riskscore等信息
 机器学习案例（三）：未来销售预测
 python获取文件路径
 RabbitMQ 常用运维命令
 Bat笔记
原文地址：https://blog.csdn.net/Trong_/article/details/132725321

文章目录

一. 较复杂的查询操作

1. 参数占位符#{}和${}

2. SQL注入

3. like查询

4. resultType与resultMap

5. 多表查询

5.1. 一对一表映射

5.2. 一对多表映射

二. 动态SQL

1. if标签

2. trim标签

3. where标签

4. set标签

5. foreach标签