动态SQL

这是官方给出的解释，我们要仔细品味官方的话。

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，
你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，
还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。

if
choose (when, otherwise)
trim (where, set)
foreach
我们主要学习这三个标签。
在学习之前同样我们先建表。

create table blog
(
    id          varchar(50)  not null comment '博客id',
    title       varchar(100) not null comment '博客标题',
    author      varchar(30)  not null comment '博客作者',
    create_time datetime     not null comment '创建时间',
    views       int(30)      not null comment '浏览量'
)
    charset = utf8;

根据自己的情况添加数据。
创建实体类，我们这里的属性名和字段名又不同的，所以我们需要在seeting中添加<setting name="mapUnderscoreToCamelCase" value="true"/>这是将字段中的驼峰命名换成大小字母组合。

@Data
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;
    private int views;


}

if

首先是我们看到的这个if和我们逻辑代码的效果的意思都是一样的，进行判断的意思。
接口

List<Blog> queryBlogIf(Map map);

在这里使用if是在为where后面使用，而且是使用的标签 他又一个属性test在test中写相对应的判断，如果判断成功将执行标签里面的内容。否则将执行下面的代码。

 <select id="queryBlogIf"  parameterType="map" resultType="aw.pojo.Blog">
       select * from blog where 1=1
       <if test="title!=null">
       AND title=#{title}
       </if>
       <if test="author!=null">
           AND author=#{author}
       </if>
   </select>

sql代码块，他使用与单表查询。如果是多表这样写显得复杂。

    <sql id="query" >
        <if test="title!=null">
            AND title=#{title}
        </if>
        <if test="author!=null">
            AND author=#{author}
        </if>
    </sql>

    <select id="queryBlogIf"  parameterType="map" resultType="aw.pojo.Blog">
        select * from blog where 1=1
        <include refid="query"></include>

    </select>

测试代码，格式根据自己添加的数据进行查询的

  @Test
    public void test1(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap<Object, Object> objectObjectHashMap = new HashMap<>();
        objectObjectHashMap.put("title","Mybatis");
        objectObjectHashMap.put("author","狂神说");
        List<Blog> list =mapper.queryBlogIf(objectObjectHashMap);
        for (Blog blog : list) {
            System.out.println(blog);
        }
        sqlSession.close();
    }

choos

有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。因为我们之前道学过switch，所以学习choose很快。
首先是choose标签，里面嵌套了when，otherwise。

 <select id="queryBlogIf"  parameterType="map" resultType="aw.pojo.Blog">
        select * from blog where 1=1
        <choose>
            <when test="title!=null"> AND title=#{title}</when>
            <when test="author!=null">AND author=#{author}</when>
            <otherwise>AND id=1</otherwise>
        </choose>
    </select>

测试类

 public void test1(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap<Object, Object> objectObjectHashMap = new HashMap<>();
        //如果传递的参数符合两个when标签的判断，他只会第一个when的标签的内容
        objectObjectHashMap.put("title","Java");
//        objectObjectHashMap.put("author","狂神说");
        //参数为空的情况和下他会我们执行otherwise标签的内容
        List<Blog> list =mapper.queryBlogIf(objectObjectHashMap);
        for (Blog blog : list) {
            System.out.println(blog);
        }
        sqlSession.close();
    }

trim

where标签
官方这句话是重点。

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

我们就不用单独去写where，这个标签会帮我们进行判断，如果都没有符合结果的他就会自动省略掉，同时会把开头语句的AND或OR省略。

 <select id="queryBlogIf"  parameterType="map" resultType="aw.pojo.Blog">
     select * from blog
     <where>
         <choose>
             <when test="title!=null"> AND title=#{title}</when>
             <when test="author!=null">AND author=#{author}</when>
             <otherwise>AND id=1</otherwise>
         </choose>
     </where>

 </select>

测试代码块

 public void test1(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap<Object, Object> objectObjectHashMap = new HashMap<>();
        //如果传递的参数符合两个when标签的判断，他只会第一个when的标签的内容
        objectObjectHashMap.put("title","Java");
//        objectObjectHashMap.put("author","狂神说");
        //参数为空的情况和下他会我们执行otherwise标签的内容
        List<Blog> list =mapper.queryBlogIf(objectObjectHashMap);
        for (Blog blog : list) {
            System.out.println(blog);
        }
        sqlSession.close();
    }

set
接口

   int updateBlog(Map<String,String> map);

set标签的使用，我们又在set标签中嵌套了众多的if标签。

<update id="updateBlog" parameterType="map" >
        update blog
        <set>
            <if test="title!=null">
                 title=#{title},
            </if>
            <if test="author!=null">
                 author=#{author},
            </if>

            <if test="createTime!=null">
                 createTime=#{createTime},
            </if>
            <if test="views!=null">
             views=#{views}
        </if>
        </set>
        where id=#{id}
    </update>

测试代码
现在我们在修改数据信息的时候，就可以修改同一个id的一个多个字段的信心，不用去修改sql代码了。

  @Test
    public void test2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap<String, String> objectObjectHashMap = new HashMap<>();
        objectObjectHashMap.put("id","1");
        objectObjectHashMap.put("author","阿威");
        int i = mapper.updateBlog(objectObjectHashMap);
        if (i>0){
            System.out.println("执行成功");

        }        sqlSession.close();
    }

trim标签
trim标签是where set的总结版

prefix	给sql语句拼接的前缀
suffix	给sql语句拼接的后缀
prefixOverrides	去除sql语句前面的关键字或者字符，该关键字或者字符由prefixOverrides属性指定，假设该属性指定为"AND"，当sql语句的开头为"AND"，trim标签将会去除该"AND"
suffixOverrides	去除sql语句后面的关键字或者字符，该关键字或者字符由suffixOverrides属性指定

我们可以根据上面的属性的去进行添加。

<update id="updateBlog" parameterType="map" >
        update blog
        <trim prefix="set" suffix=",">
            <if test="title!=null">
                title=#{title}
            </if>
            <if test="author!=null">
                author=#{author}
            </if>

            <if test="createTime!=null">
                createTime=#{createTime}
            </if>
            <if test="views!=null">
                views=#{views}
            </if>
        </trim>
        where id=#{id}
    </update>

foreach

动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候。

<select id="selectPostIn" resultType="domain.blog.Post">
  SELECT *
  FROM POST P
  WHERE ID in
  <foreach item="item" index="index" collection="list"
      open="(" separator="," close=")">
        #{item}
  </foreach>
</select>

foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符，看它多智能！

提示 你可以将任何可迭代对象（如 List、Set 等）、Map 对象或者数组对象作为集合参数传递给 foreach。当使用可迭代对象或者数组时，index 是当前迭代的序号，item 的值是本次迭代获取到的元素。当使用 Map 对象（或者 Map.Entry 对象的集合）时，index 是键，item 是值。

item：集合中元素迭代时的别名，该参数为必选。
index：在list和数组中,index是元素的序号，在map中，index是元素的key，该参数可选
open：foreach代码的开始符号，一般是(和close=")"合用。常用在in(),values()时。该参数可选
separator：元素之间的分隔符，例如在in()的时候，separator=","会自动在元素中间用“,“隔开，避免手动输入逗号导致sql错误，如in(1,2,)这样。该参数可选。
close: foreach代码的关闭符号，一般是)和open="("合用。常用在in(),values()时。该参数可选。
collection: 要做foreach的对象，作为入参时，List对象默认用"list"代替作为键，数组对象有"array"代替作为键，Map对象没有默认的键。
当然在作为入参时可以使用@Param("keyName")来设置键，设置keyName后，list,array将会失效。 除了入参这种情况外，还有一种作为参数对象的某个字段的时候。

以上都是官方给出的解释已经很详细了。

接口

List<Blog> queryForeach(Map map);

平时我们写查询多个数据是这样写sql
select * from blog where ( id=1 or id=2 or id=3 or id=4 )
现在我们使用foreach

<select id="queryForeach" parameterType="map" resultType="aw.pojo.Blog">
        select * from blog
            <where>
                <foreach collection="ids" item="id" open="(" close=")" separator="or">
                    id=#{id}
                </foreach>
            </where>

    </select>

测试类，我们先是创建一个list然后将list传递给map

 public void test3(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap<Object, Object> objectObjectHashMap = new HashMap<>();

        ArrayList<Object> objects = new ArrayList<>();
        objects.add(1);
        objects.add(2);
        objects.add(3);
        objects.add(4);

        objectObjectHashMap.put("ids",objects);

        List<Blog> list = mapper.queryForeach(objectObjectHashMap);
        for (Blog blog : list) {
            System.out.println(blog);
        }
        sqlSession.close();
    }