Mybatis复杂查询及动态SQL
文章目录
- 一. 较复杂的查询操作
-
- 1. 参数占位符#{}和${}
- 2. SQL注入
- 3. like查询
- 4. resultType与resultMap
- 5. 多表查询
-
- 5.1. 一对一表映射
- 5.2. 一对多表映射
- 二. 动态SQL
-
- 1. if标签
- 2. trim标签
- 3. where标签
- 4. set标签
- 5. foreach标签
本篇中使用的数据表即基础映射类都是基于上一篇博客的，如果有需要可以移步： MyBatis配置及单表操作
一. 较复杂的查询操作
1. 参数占位符#{}和${}
#{}：预处理符，生成的执行 sql 中将id=#{6}替换为id=?，最后使用6替换了?作为参数。
${}：替换符，生成的执行 sql 中将id=${6}替换为id=6，直接替换，属于字符串拼接。
两种占位符都可以正常使用的场合：传入的参数类型是数值类型。
使用${}：
select * from userinfo where id=${id}
select * from userinfo where id=6
使用#{}：
select * from userinfo where id=#{id}
select * from userinfo where id=?
对于这两种参数占位符，都能使用的情况下，更建议使用#{}就使用#{}，因为${}存在 SQL 注入的问题，以及在特殊场景下如果传入的类型是字符串也会出问题。
只能使用#{}而不能使用${}的场合：传入参数类型为 String
使用${}：
select * from userinfo where username=${username}
//实际执行的语句 (比如前端通过 URL 传入的参数)
Preparing: select * from userinfo where username=张三
但是在 sql 中通过字符串来查询数据，是需要加上引号的，而使用${}生成的sql并没有带引号，因此不适用于字符串参数的sql。
使用#{}：
select * from userinfo where username=#{username}
//实际执行语句
select * from userinfo where username=?
由于使用#{}是将目标参数替换为占位符，然后利用 JDBC 中的占位符机制实现 sql 语句的填充，最终是会带上引号的，所以使用#{}构造的 sql 是可以正常运行的，并且没有 SQL 注入的问题。
所以，#{}相比于${}，它支持所有类型的参数，包括数值类与字符串类，而${}支持数值类型，不支持字符串类型的参数，但也可以在原来 sql 里面为${}外面加上一对引号来使用。
select * from userinfo where username='${username}'
//实际执行语句
select * from userinfo where username='张三'
当传递的参数为字符串类型的时候，虽然加上一对引号，使用${}也可以使用，但是${}存在 SQL 注入问题，所以仍然不推荐，有关 SQL 注入后面在下文有介绍。
大部分场合下，使用#{}都可以解决，但还是存在一小部分只能是${}来处理的。
如当我们需要按照升序或者逆序得到数据库查询结果的时候，这种场合就只能使用${}，使用#{}会报错，我们来演示一下。
首先，我们在Mapper接口中声明一个方法：作用就是按照排序获取结果集
List<Userinfo> getAllByOrder(@Param("myOrder") String myOrder);
我们再去xml文件中去写 sql 语句：首先我们使用$进行演示
<select id="getAllByOrder" resultType="com.example.demo.model.UserInfo">
select * from userinfo order by id ${myOrder}
</select>
写一个单元测试，代码很简单，就是调用 sql，然后得到结果集：
@Test
void getOrderList() {
List<UserInfo> userMappers = userMapper.getOrderList("desc");
System.out.println(userMappers);
}
单元测试结果：
可以正常查询，得到的结果与预期也是相同的。
我们再来试一试使用#{}来构造 sql 语句：
<select id="getOrderList" resultType="com.example.demo.model.UserInfo">
select * from userinfo order by createtime #{order};
</select>
重新执行单元测试，看下面的结果：
我们发现程序报错了，这是因为使用了desc的字符串（带引号）替换了占位符，而我们所需要的不是一个desc字符串，而是直接一个desc的关键字（不带引号），所以 sql 也抛出了语法错误，这里最终执行的 sql 如下：
select * from userinfo order by createtime ‘desc’;
而期望执行的 sql 为：
select * from userinfo order by createtime desc;
所以在传递 sql 命令（关键字）的时候，不能使用#{}，只能使用${}。
总之，如果不得不使用${}，那么传递的参数一定要能被穷举，此时才能在业务代码中对传递的值进行安全校验，否则是不能使用的。
2. SQL注入
SQL 注入就是使用${}实现一些特殊的语句，来达到非法获取数据的目的，如不通过正确的密码获取某账户的信息，下面我们来演示一下，就以登录的例子来演示，SQL 注入可以在不知道密码的前提下登录成功，并且获取到用户的相关信息。
首先我将数据库只保留一个用户信息，方便演示 SQL 注入问题：
1️⃣第一步，在Mapper接口中定义方法login，返回登录成功的用户对象。
public UserInfo login(@Param("username") String username, @Param(("password")) String password);
2️⃣第二步，在xml文件中编写 sql 语句，我们需要演示 SQL 注入，所以我们使用${}来构造 sql 语句。
<select id="login" resultType="com.example.demo.model.UserInfo">
select * from userinfo where username='${username}' and password='${password}';
</select>
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);
}
结果如下：
我们在不知道用户密码的情况下，就登录成功，并拿到了用户的信息。
最终执行的 sql 语句为：
select * from userinfo where username='admin' and password='' or 1='1';
相当于它在原来条件判断的语句下，后面有加上一个或的逻辑，并且或后面的表达式为true，这样就使得原来的 SQL 语句中的条件判断部分一定为真，所以就在没有正确密码的情况下拿到了用户的基本信息。
所以我们能不使用${}就不使用${}，它存在 SQL 注入问题，如果必须使用${}则需要验证一下传递的参数是否合法，比如上面定义排序的 sql，传递的参数只能是desc或者是asc，如果不是就不能执行这条 SQL，防止 SQL 注入情况的发生。
3. like查询
在 Mybatis 中使用like查询比较特殊，因为直接使用#{}会报错，而使用${}，由于输入的字符串情况很多，无法做到枚举，验证比较困难，无法避免 SQL 注入问题。
首先，我们来演示使用#{}进行like查询。
1️⃣第一步，声明方法。
List<UserInfo> getLikeList(@Param("username") String username);
2️⃣第二步，xml 中实现 执行 sql。
<select id="getLikeList" resultType="com.example.demo.model.UserInfo">
select * from userinfo where username like '%#{username}%'
</select>
3️⃣第三步，单元测试。
@Test
void getLikeList() {
String username = "a";
List<UserInfo> list = userMapper.getLikeList(username);
System.out.println(list);
}
结果如下：
报错了，因为#{}会被替换成一个字符串，而在这个%#{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>
重新执行单元测试，此时就可以正常执行了。
4. resultType与resultMap
resultType表示数据库返回的数据映射在 java 程序中所对应的类型，只要定义类中的属性与数据库中表的字段名字一致就没有任何问题，但是如果不一致，冲突的属性就无法获取到数据库查询的结果。
比如用户名属性在数据库中的名字是username，而在 java 程序类中的属性名为name，此时通过 mybatis 将数据传递到程序中的对象时，获取到的name属性为null，就不能正确地获取到对应的属性值，为了解决这个数据库字段与类中中字段不匹配的问题，我们需要使用到resultMap。
resultMap 的使用方式就是在xml文件中设置id表示你这个 resultMap 标签的名字，还有一个是type属性，它表示映射到程序中类的类型，需包含包名。
这个标签里面需要设置至少两个子标签，一个是id标签，另外一个是result标签，前者表示主键，后者表示数据库表中普通的列，这两种标签也是至少需要设置两个属性，一个是column表示数据库表中的字段名，另外一个是property表示程序类中的对应属性名，如果只是在单表进行查询，只设置不同字段名的映射就可以了，但是如果是多表查询，必须将数据表中所有的字段与类中所有的属性生成映射关系。
就像下面这样，图中类属性与数据表字段是相同的，实际情况可以存在不同的字段名：
所以，当类中的属性和数据库表中的字段名不一致，面对查询结果为null的这种情况，有三种解决方案：
- 将类中的属性和数据库表的字段名改成一致的。
- 使用 sql 语句中的 as 进行列名（字段名）重命名，让列名（字段名）等于属性名即可。
- 就是上面介绍的，定义一个 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️⃣第一步，创建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>
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>
此外，我们除了设置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>
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>
注意多表查询时要将 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>
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>
我们将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);
单元测试代码：
@Test
void getArticleById2() {
ArticleInfo articleinfo = articleMapper.getArticleById(1);
System.out.println(articleinfo);
}
结果如下：
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;
}
实现多表查询的大致过程如下：
- 在 Mapper 接口中声明方法，我们声明一个方法，就是通过用户 id 获取用户信息以及对应的文章列表。
// 根据 id 查询用户信息, 显示相应文章信息
UserInfo getUserAndArticlesById(@Param("uid") Integer id);
- 在
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>
- 在对应的
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>
- 编写单元测试代码，验证结果。
@Test
void getUserAndArticlesById() {
Integer id = 1;
UserInfo userInfo = userMapper.getUserAndArticlesById(id);
System.out.println(userInfo);
}
结果如下：
同样也可以使用注解完成，实现起来更简单。
// 根据 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);
单元测试代码：
@Test
void getUserAndArticlesById2() {
Integer id = 1;
UserInfo userInfo = userMapper.getUserAndArticlesById(id);
System.out.println(userInfo);
}
结果如下：
上面的方式都是对两张表联合后进行的查询，是一步实现的，其实也可以分步实现，比如这里可以先根据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);
单元测试代码：
@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);
}
执行测试方法，结果如下：
二. 动态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>
当表达式为真，则插入if标签中的sql，否则不插入。
我们以在用户表中插入一条记录为例，其中插入的字段中头像photo不是必传的参数：
方法声明：
// 使用动态sql插入数据
int addUser(UserInfo userInfo);
动态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>
单元测试代码：
@Test
void addUser() {
UserInfo userinfo = new UserInfo();
userinfo.setUsername("zhangsan");
userinfo.setPassword("123");
int result = userMapper.addUser(userinfo);
System.out.println("受影响行数: " + result);
}
在单元测试代码中，没有给 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);
}
结果如下：
最终生成的语句多了一个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>
假设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>
单元测试代码：
@Test
void addUser2() {
UserInfo userInfo = new UserInfo();
userInfo.setUsername("wangwu");
userInfo.setPassword("12345622");
int result = userMapper.addUser(userInfo);
System.out.println("受影响行数: " + result);
}
运行结果与生成的 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>
单元测试代码：
这里只传入一个username看是否可以自动删除前面多余的and。
@Test
void getListByWhere() {
UserInfo userinfo = new UserInfo();
userinfo.setUsername("wangwu");
List<UserInfo> list = userMapper.getUserListByWhere(userinfo);
System.out.println(list);
}
结果如下：
发现自动生成了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>
4. set标签
set标签与where标签很相似，where用来替换查询SQL，而set是用于修改 sql 中，用来自动生成set部分的SQL语句。
set标签可以自动去除最后面的一个,。
比如我们写一个能够修改账户名username，密码password，头像photo的动态 SQL，根据id进行修改。
方法声明：
// 使用动态SQL实现修改用户信息，包括账户名，密码，头像
int updateUser(UserInfo userInfo);
动态 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>
单元测试代码：
@Test
void updateUser() {
UserInfo userinfo = new UserInfo();
userinfo.setId(3);
// 修改密码为 456
userinfo.setPassword("456");
int result = userMapper.updateUser(userinfo);
System.out.println("受影响行数 : " + result);
}
结果如下：
修改成功并且可以根据传入参数个数自动生成相应的修改 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>
5. foreach标签
对集合进行遍历可以使用foreach标签，常用的场景有批量删除功能。
- collection：绑定方法参数中的集合，如 List，Set，Map或数组对象
- item：遍历时的每一个对象
- open：语句块开头的字符串
- close：语句块结束的字符串
- separator：每次遍历之间间隔的字符串
为了方便演示批量删除，我们随便插入几条数据到数据库：
方法声明：
// 使用动态 sql 批量删除元素
public int deleteIds(List<Integer> ids);
动态 SQL 语句：
<delete id="delByIds">
delete from userinfo where id in
<foreach collection="ids" open="(" close=")" item="id" separator=",">
#{id}
</foreach>
</delete>
单元测试代码：
删除数据库中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);
}
结果如下：
验证数据库，成功生成了批量删除的 sql，这就是foreach标签的作用，它能够遍历集合。
