MyBatis从入门到入土——动态SQL

时间 2021-02-26

标签 java sql 数据库编程数组 mybatis app ide 测试栏目 MyBatis 繁體版

原文原文链接

这是mybatis系列第10篇，没看前文的建议先去【Java冢狐】公众号中查看前文，方便理解和掌握。在上一篇中重点介绍了延迟加载、鉴别器以及继承的相关知识。java

在这篇文章中咱们介绍mybatis一个比较强大的功能。这个功能就是动态sql，尤为是在处理sql的拼接这块简直是咱们的福音，基本上sql拼接的全部的痛点，mybatis都帮咱们解决了。sql

那么下面咱们来学一下mybatis中各类动态sql的用法。数据库

建立数据库

首先就是建立咱们演示用的数据库，以下所示：编程

DROP DATABASE IF EXISTS `mybatisdemo`;
CREATE DATABASE `mybatisdemo`;
USE `mybatisdemo`;
DROP TABLE IF EXISTS user;
CREATE TABLE user(
  id int AUTO_INCREMENT PRIMARY KEY COMMENT '用户id',
  name VARCHAR(32) NOT NULL DEFAULT '' COMMENT '用户名',
  age SMALLINT NOT NULL DEFAULT 1 COMMENT '年龄'
) COMMENT '用户表';
INSERT INTO t_user VALUES (1,'Java冢狐',18),(2,'java',100),(3,'冢狐',23);

if元素

首先介绍的就是动态sql的if元素，这个if元素至关于java中的if判断。数组

其使用语法：mybatis

<if test="判断条件">
须要追加的sql
</if>

test的值为一个判断表达式，写法上采用OGNL表达式的方式，当test成立的时候，if体内部的sql会被拼接上。app

如：ide

<select id="getList1" resultType="com.zhonghu.chat10.demo8.model.UserModel" parameterType="map">
    SELECT id,name,age FROM user
    WHERE 1 = 1
    <if test="id!=null">
        AND id = #{id}
    </if>
    <if test="name!=null and name.toString()!=''">
        AND name = #{name}
    </if>
    <if test="age!=null">
        AND age = #{age}
    </if>
</select>

上面查询用户列表，参数为一个map，当map中id不为空的时候，将其做为条件查询，若是name不为空，将name也做为条件，若是age不为空，将age也做为条件进行查询测试

当只传入id的时候，sql以下：ui

SELECT id,name,age FROM user WHERE 1 = 1 AND id = ?

当3个参数都传了，sql以下：

SELECT id,name,age FROM user WHERE 1 = 1 AND id = ? AND name = ? AND age = ?

上面这种写法相对于java代码看起来是否是清爽了不少，也更方便维护，你们注意一下sql中有个WHERE 1=1，若是没有这个，上面单经过if元素就很差实现了，mybatis也有解决方案，稍后会说明。

choose/when/otherwise元素

介绍了完相似于java的if，那确定有相应的if-else语句，那就是choose、when和otherwise，其具体语法：

<choose>
    <when test="条件1">
        知足条件1追加的sql
    </when>
    <when test="条件2">
        知足条件2追加的sql
    </when>
    <when test="条件n">
        知足条件n追加的sql
    </when>
    <otherwise>
        都不知足追加的sql
    </otherwise>
</choose>

choose内部的条件知足一个，choose内部的sql拼接就会结束。

otherwise属于可选的，当全部条件都不知足的时候，otherwise将起效。

如：

传入id、name、age做为条件，按顺序进行判断，若是id不为空，将id做为条件，忽略其余条件，若是id为空，会判断name是否为空，name不为空将name做为条件，若是name为空，再看看age是否为空，若是age不为空，将age做为条件。

<select id="getList2" resultType="com.zhonghu.chat10.demo8.model.UserModel" parameterType="map">
    SELECT id,name,age FROM user
    WHERE 1 = 1
    <choose>
        <when test="id!=null">
            AND id = #{id}
        </when>
        <when test="name!=null and name.toString()!=''">
            AND name = #{name}
        </when>
        <when test="age!=null">
            AND age = #{age}
        </when>
    </choose>
</select>

若是id、name、age都传了，sql以下：

SELECT id,name,age FROM t_user WHERE 1 = 1 AND id = ?

若是值传递了name、age，sql以下：

SELECT id,name,age FROM t_user WHERE 1 = 1 AND name = ?

name判断在age前面，因此name条件先匹配上了。

where元素

上面2个案例的sql中都有where 1=1这部分代码，虽然能够解决问题，可是看起来不美观，若是将where 1=1中1=1这部分干掉，上面的两个案例都会出问题，where后面会多一个AND符号，mybatis中已经考虑到这种问题了，属于通用性的问题，mybatis中经过where 元素来解决，当使用where元素的时候，mybatis会将where内部拼接的sql进行处理，会将这部分sql前面的AND 或者 OR给去掉，并在前面追加一个where，咱们使用where元素来对上面的案例1进行改造，以下：

<select id="getList1" resultType="com.zhonghu.chat10.demo8.model.UserModel" parameterType="map">
    SELECT id,name,age FROM user
    <where>
        <if test="id!=null">
            AND id = #{id}
        </if>
        <if test="name!=null and name.toString()!=''">
            AND name = #{name}
        </if>
        <if test="age!=null">
            AND age = #{age}
        </if>
    </where>
</select>

where 1=1被替换成了where 元素。

当传入id、name的时候，where内部的sql会变成这样：

AND id = ? AND name = ?

mybatis会对上面这个sql进行处理，将前面的AND给去掉，并在前面追加一个where，变成了下面这样

where id = ? AND name = ?

案例2也用where改造一下，变成了下面这样：

<select id="getList2" resultType="com.zhonghu.chat10.demo8.model.UserModel" parameterType="map">
    SELECT id,name,age FROM user
    <where>
        <choose>
            <when test="id!=null">
                AND id = #{id}
            </when>
            <when test="name!=null and name.toString()!=''">
                AND name = #{name}
            </when>
            <when test="age!=null">
                AND age = #{age}
            </when>
        </choose>
    </where>
</select>

这下看起来是否是舒服不少了。

set元素

如今咱们想经过用户id更新用户信息，参数为UserModel对象，对象中的属性若是不为空，就进行更新，咱们能够这么写：

<update id="update1" parameterType="com.zhonghu.chat10.demo8.model.UserModel">
    UPDATE user SET
    <if test="name!=null">
        name = #{name},
    </if>
    <if test="age!=null">
        age = #{age},
    </if>
    <where>
        <if test="id!=null">
            AND id = #{id}
        </if>
    </where>
</update>

咱们来看一下，当全部属性都传值了，sql变成了下面这样：

UPDATE user SET name = ?, age = ?, where id = ?

上面这个sql是有问题的，where前面多了一个逗号，得想办法将这个逗号去掉，这个逗号属于最后一个须要更新的字段后面的逗号，属于多余的，mybatis中提供了set元素来解决这个问题，将上面的代码改为下面这样：

<update id="update1" parameterType="com.zhonghu.chat10.demo8.model.UserModel">
    UPDATE user
    <set>
        <if test="name!=null">
            name = #{name},
        </if>
        <if test="age!=null">
            age = #{age},
        </if>
    </set>
    <where>
        <if test="id!=null">
            AND id = #{id}
        </if>
    </where>
</update>

咱们将sql中的set去掉了，加了个set元素，set元素会对其内部拼接的sql进行处理，会将这部分sql先后的逗号给去掉并在前面加上set。

当传入id和age的时候，生成的sql：

UPDATE user SET age = ? where id = ?

trim元素

这个元素的功能比较强大，先看一下他的语法：

<trim prefix="" prefixOverrides="" suffix="" suffixOverrides="">
</trim>

trim元素内部能够包含各类动态sql，如where、chose、sql等各类元素，使用trim包含的元素，mybatis处理过程：

先对trim内部的sql进行拼接，好比这部分sql叫作sql1
将sql1字符串前面的部分中包含trim的prefixOverrides指定的部分给去掉，获得sql2
将sql2字符串后面的部分中包含trim的suffixOverrides指定的部分给去掉，获得sql3
在sql3前面追加trim中prefix指定的值，获得sql4
在sql4后面追加trim中suffix指定的值，获得最终须要拼接的sql5

了解了这个过程以后，说明能够经过trim来代替where和set，咱们使用trim来改造一下案例1，以下：

<select id="getList1" resultType="com.zhonghu.chat10.demo8.model.UserModel" parameterType="map">
    SELECT id,name,age FROM user
    <trim prefix="where" prefixOverrides="and|or">
        <if test="id!=null">
            AND id = #{id}
        </if>
        <if test="name!=null and name.toString()!=''">
            AND name = #{name}
        </if>
        <if test="age!=null">
            AND age = #{age}
        </if>
    </trim>
</select>

注意上面的prefixOverrides的值的写法，若是有多个须要覆盖的之间用|进行分割，suffixOverrides写法和prefixOverrides的写法相似。

咱们在用trim来改造一下上面的update中的，以下：

<update id="update1" parameterType="com.zhonghu.chat10.demo8.model.UserModel">
    UPDATE user
    <trim prefix="SET" prefixOverrides="," suffixOverrides=",">
        <if test="name!=null">
            name = #{name},
        </if>
        <if test="age!=null">
            age = #{age},
        </if>
    </trim>
    <where>
        <if test="id!=null">
            AND id = #{id}
        </if>
    </where>
</update>

上面的prefixOverrides和suffixOverrides都设置的是逗号，表示trim内部的sql先后的逗号会被去掉，最后会在前面拼接一个prefix指定的set。

实际上where和set的实现是继承了TrimSqlNode，where对应的java代码：

public class WhereSqlNode extends TrimSqlNode {
  private static List<String> prefixList = Arrays.asList("AND ","OR ","AND\n", "OR\n", "AND\r", "OR\r", "AND\t", "OR\t");
  public WhereSqlNode(Configuration configuration, SqlNode contents) {
    super(configuration, contents, "WHERE", prefixList, null, null);
  }
}

set对应的 java代码：

public class SetSqlNode extends TrimSqlNode {
  private static final List<String> COMMA = Collections.singletonList(",");
  public SetSqlNode(Configuration configuration,SqlNode contents) {
    super(configuration, contents, "SET", COMMA, null, COMMA);
  }
}

最后都是依靠TrimSqlNode来实现的。

foreach元素

至关于java中的循环，能够用来遍历数组、集合、map等。

语法

<foreach collection="须要遍历的集合" item="集合中当前元素" index="" open="" separator="每次遍历的分隔符" close="">
动态sql部分
</foreach>

collection：能够是一个List、Set、Map或者数组
item：集合中的当前元素的引用
index：用来访问当前元素在集合中的位置
separator：各个元素之间的分隔符
open和close用来配置最后用什么前缀和后缀将foreach内部全部拼接的sql给包装起来。

案例：in多值查询

咱们对案例1作个改造，map中支持放入用户的id列表（ArrayList），对应的key为idList，而后支持多个用户id查询，此时咱们须要用in来查询，实现以下：

<select id="getList1" resultType="com.zhonghu.chat10.demo8.model.UserModel" parameterType="map">
    SELECT id,name,age FROM user
    <where>
        <if test="id!=null">
            AND id = #{id}
        </if>
        <if test="name!=null and name.toString()!=''">
            AND name = #{name}
        </if>
        <if test="age!=null">
            AND age = #{age}
        </if>
        <if test="idList!=null and idList.size()>=1">
            <foreach collection="idList" item="id" open="AND id in (" separator="," close=")">
                #{id}
            </foreach>
        </if>
    </where>
</select>

你们看一下上面idList那部分判断，判断这个参数不为空，而且size()大于1，表示这个集合不为空，而后会走if元素内部的foreach元素。

好比咱们传递的idList对应的是[1,2]，最后产生的sql以下：

SELECT id,name,age FROM t_user WHERE id in ( ? , ? )

案例：批量插入

传入UserModel List集合，使用foreach实现批量插入，以下：

<insert id="insertBatch" parameterType="list">
    INSERT INTO user (id,name,age) VALUES
    <foreach collection="collection" separator="," item="item">
        (#{item.id}, #{item.name}, #{item.age})
    </foreach>
</insert>

测试用例

com.zhonghu.chat10.demo8.Demo8Test#insertBatch
@Test
public void insertBatch() throws IOException {
    try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<UserModel> userModelList = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            userModelList.add(UserModel.builder().id(10 + i).name("mybatis-" + i).age(20 + i).build());
        }
        int count = mapper.insertBatch(userModelList);
        log.info("{}", count);
    }
}

传入了3个用户信息，运行输出

39:52.241 [main] DEBUG c.j.c.d.m.UserMapper.insertBatch - ==>  Preparing: INSERT INTO user (id,name,age) VALUES (?, ?, ?) , (?, ?, ?) , (?, ?, ?) 
39:52.317 [main] DEBUG c.j.c.d.m.UserMapper.insertBatch - ==> Parameters: 10(Integer), mybatis-0(String), 20(Integer), 11(Integer), mybatis-1(String), 21(Integer), 12(Integer), mybatis-2(String), 22(Integer)
39:52.327 [main] DEBUG c.j.c.d.m.UserMapper.insertBatch - <==    Updates: 3
39:52.327 [main] INFO  c.j.chat05.demo8.Demo8Test - 3

sql/include元素

这两2个元素通常进行配合使用，能够实现代码重用的效果。

sql元素能够用来定义一段动态sql，语法以下：

<sql id="sql片断id">
各类动态sql
</sql>

其余地方须要使用的时候须要经过include关键字进行引入：

<include refid="须要引入的sql片断的id"/>

refid值的写法，refid的值为mapper xml的namespace的值.sql的id，若是在同一个mapper中，namespace能够省略，直接写对应的sql的id就能够了，如：

<include refid="findSql"/>
<include refid="com.javacode2018.chat05.demo8.mapper.UserMapper.findSql"/>

例如：

下面定义2个查询，他们的查询条件同样，最后将条件抽出来用sql元素定义了一个片断，而后进行共用。

<sql id="findSql">
    <where>
        <if test="id!=null">
            AND id = #{id}
        </if>
        <if test="name!=null and name.toString()!=''">
            AND name = #{name}
        </if>
        <if test="age!=null">
            AND age = #{age}
        </if>
        <if test="idList!=null and idList.size()>=1">
            <foreach collection="idList" item="id" open="AND id in (" separator="," close=")">
                #{id}
            </foreach>
        </if>
    </where>
</sql>
<select id="getList1" resultType="com.zhonghu.chat10.demo8.model.UserModel" parameterType="map">
    SELECT id,name,age FROM user
    <include refid="com.zhonghu.chat10.demo8.mapper.UserMapper.findSql" />
</select>
<select id="getList1Count" resultType="com.zhonghu.chat10.demo8.model.UserModel" parameterType="map">
    SELECT count(*) FROM user
    <include refid="findSql" />
</select>

bind元素

bind元素容许咱们经过ognl表达式在上下文中自定义一个变量，最后在动态sql中可使用这个变量。

语法

<bind name="变量名称" value="ognl表达式">

案例

对sql、include中的案例进行扩展，添加一个按照用户名模糊查询，用户名在map中对应的key为likeName，主要修改上面sql片断部分，在sql中加入下面部分：

<if test="likeName!=null and likeName.trim()!=''">
  <bind name="nameLike" value="'%'+likeName.trim()+'%'" />
  AND name like #{nameLike}
</if>

先判断传入的参数likeName是否不为空字符串，而后使用bind元素建立了一个变量nameLike，值为'%'+likeName.trim()+'%'。

测试：

com.zhonghu.chat10.demo8.Demo8Test#getModelList
@Test
public void getModelList() throws IOException {
    try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("likeName","java");
        List<UserModel> userModelList = mapper.getList1(paramMap);
        log.info("{}", userModelList);
    }
}

运行输出：

06:25.633 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM user WHERE name like ? 
06:25.671 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: %java%(String)
06:25.690 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 1
06:25.691 [main] INFO  c.j.chat05.demo8.Demo8Test - [UserModel(id=1, name=Java冢狐, age=18)]

注意输出中的第二部分，参数的值为%java%。

#和$

#和$通常都是结合变量来使用，如：#{}、${}这种来进行使用。

#{}:为参数占位符？，即sql预编译，至关于使用jdbc中的PreparedStatement中的sql占位符，能够防止sql注入

${}:为字符串替换，即字符串拼接，不能访问sql注入。

#{}的用法上面已经有不少案例了，此处咱们来一个${}的案例。

下面经过orderSql变量传入任意的排序sql，以下：

<select id="getList1" resultType="com.zhonghu.chat10.demo8.model.UserModel" parameterType="map">
    SELECT id,name,age FROM t_user
    <if test="orderSql">
        ${orderSql}
    </if>
</select>

传入值：

orderSql = "order by id asc,age desc"

最后运行产生的sql以下：

20:32.138 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM user order by id asc,age desc 
20:32.173 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
20:32.196 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 6
20:32.197 [main] INFO  c.j.chat05.demo8.Demo8Test - [UserModel(id=1, name=java冢狐, age=18), UserModel(id=2, name=java, age=100), UserModel(id=3, name=冢狐, age=23), UserModel(id=10, name=mybatis-0, age=20), UserModel(id=11, name=mybatis-1, age=21), UserModel(id=12, name=mybatis-2, age=22)]

mybatis会对$包含部分进行sql替换。

总结

本篇文章重点介绍了MyBatis的动态SQL是如何使用的，重点是依赖MyBatis的元素，诸如：if、choose、where、set、trim、foreach、bind等元素。针对每一个元素都详细的举了例子和代码进行演示。

最后

若是以为看完有收获，但愿能关注一下，顺便给我点个赞，这将会是我更新的最大动力，感谢各位的支持
欢迎各位关注个人公众号【java冢狐】，专一于java和计算机基础知识，保证让你看完有所收获，不信你打我
求一键三连：点赞、转发、在看。
若是看完有不一样的意见或者建议，欢迎多多评论一块儿交流。感谢各位的支持以及厚爱。

——我是冢狐，和你同样热爱编程。

欢迎关注公众号“Java冢狐”获取最新消息

1. （一）MyBatis从入门到入土——简介
2. LinkedList从入门到入土
3. maven从入土到入门
4. react 从入门到入土
5. ArrayList从入门到入土
6. symfony3.4 -从入门到入土
7. Git从入门到入土
8. MyBatis入门（四）---动态SQL
9. mybatis入门-2 动态sql
10. mybatis入门-动态sql
更多相关文章...
• Memcached入门教程 - NoSQL教程
• Neo4j数据库入门教程 - NoSQL教程
• YAML 入门教程
• Java Agent入门实战（一）-Instrumentation介绍与使用