_Mybatis动态SQL查询

2023-11-21 00:40:27 浏览数 (1)

前言

        由于这是动态SQL，和先前得有些不一样，这里我们新建一个持久层接口UserMapper2和Mybatis映射文件UserMapper2.xml，测试类TestUserMapper2

 持久层接口UserMapper2

代码语言：javascript复制
package com.mybatisstudy.mapper;

import com.mybatisstudy.pojo.User;

public interface UserMapper2 {
    
}

 Mybatis映射文件UserMapper2.xml

代码语言：javascript复制
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mybatisstudy.mapper.UserMapper2">
</mapper>

 测试类TestUserMapper2

代码语言：javascript复制
import com.mybatisstudy.mapper.UserMapper2;
import com.mybatisstudy.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;

public class TestUserMapper2 {
    InputStream is = null;
    SqlSession session = null;
    UserMapper2 userMapper2 = null;

    //前置方法，不必重复代码
    @Before
    public void before() throws Exception {
        System.out.println("前置方法执行·············");
        // （1）读取核心配置文件
        is = Resources.getResourceAsStream("SqlMapConfig.xml");
        // （2）创建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // （3）SqlSessionFactoryBuilder对象获取SqlSessionFactory对象
        SqlSessionFactory factory = builder.build(is);
        // （4）SqlSessionFactory对象获取SqlSession对象
        session = factory.openSession();
        // （5）SqlSession对象获取代理对象
        userMapper2 = session.getMapper(UserMapper2.class);
    }

    //后置方法，释放资源
    @After
    public void after() throws Exception {
        System.out.println("后置方法执行·············");
        session.close();
        is.close();
    }
}

一、动态SQL---if标签

一个查询的方法的Sql语句不一定是固定的。比如电商网站的查询商品，用户使用不同条件查询，Sql语句就会添加不同的查询条件。此时就需要在方法中使用动态Sql语句。         <if> 标签内的Sql片段在满足条件后才会添加，用法为： <if test="条件"> 。例如：根据不同条件查询用户：

1. 持久层添加用户通用查询方法

代码语言：javascript复制
// 用户通用查询
    List<User> findByCondition(User user);

2. 映射文件添加相关标签

代码语言：javascript复制
<!-- 动态_if -->
    <select id="findByCondition" parameterType="com.mybatisstudy.pojo.User" resultType="com.mybatisstudy.pojo.User">
        select * from user where 1 = 1
        <if test="username != null and username.length()!=0">
            and username like #{username}
        </if>
        <if test="sex != null and sex.length() != 0">
            and sex = #{sex}
        </if>
        <if test="address != null and address.length() != 0">
            and address = #{address}
        </if>
    </select>

        这里肯定就会有读者会问 where 后面为什么要加1 = 1，因为单单使用if标签的话，第一个条件是不用 and 关键字的，而后续的条件是需要加 and 关键字的。但是用户添加条件是随机的，没办法判断哪一个是第一个条件，因此在这里先添加1 = 1，就无需考虑后续的条件是否是第一个条件啦，但是后面还有更好的办法解决这个问题，在这里只是可以用这个方法解决目前的问题。

3. 测试类新建测试方法

代码语言：javascript复制
// 测试通用查询方法
    @Test
    public void testFindByCondition(){
        User user = new User();

        System.out.println("----------没有限制条件查询---------");
        List<User> users = userMapper2.findByCondition(user);
        users.forEach(System.out::println);

        System.out.println("----------用户名带有name限制条件查询---------");
        user.setUsername("%name%");
        List<User> users1 = userMapper2.findByCondition(user);
        users1.forEach(System.out::println);

        System.out.println("----------姓名带有name和性别是man限制条件查询---------");
        user.setSex("woman");
        List<User> users3 = userMapper2.findByCondition(user);
        users3.forEach(System.out::println);
    }

4. 运行结果

二、动态SQL---where标签

OK，上述的问题的彩蛋来了，就是这个where标签， <where> 可以代替sql中的where 1=1 和第一个and，更符合程序员的开发习惯，使用 <where> 后的映射文件如下：

1. 映射文件添加相关标签

代码语言：javascript复制
<!-- 动态_if用where -->
    <select id="findByCondition" resultType="User" parameterType="User">
        select * from user
        <where>
            <if test="username != null and username.length()!=0">
                username like #{username}
            </if>
            <if test="sex != null and sex.length() != 0">
                and sex = #{sex}
            </if>
            <if test="address != null and address.length() != 0">
                and address = #{address}
            </if>
        </where>
    </select>

2. 测试类新建测试方法

这里不用新增，直接测试即可

3. 运行结果

因此我们以后就不用添加那个什么1 = 1了 

三、动态SQL---set标签

        <set> 标签用在update语句中。借助 <if> ，可以只对有具体值的字段进行更新。 <set> 会自动添加set关键字，并去掉最后一个if语句中多余的逗号。

1. 持久层添加用户更新方法

代码语言：javascript复制
// 更新用户
    void update(User user);

2. 映射文件添加相关标签

代码语言：javascript复制
<!-- 动态_set 更新用户 -->
    <update id="update" parameterType="User">
        update user
        <set>
            <if test="username != null and username.length()!=0">
                username = #{username}
            </if>
            <if test="sex != null and sex.length() != 0">
                and sex = #{sex}
            </if>
            <if test="address != null and address.length() != 0">
                and address = #{address}
            </if>
        </set>
        <where>
            id = #{id}
        </where>
    </update>

3. 测试类新建测试方法

代码语言：javascript复制
// 测试更新用户方法
    @Test
    public void testUpdate(){
        User user = new User();
        user.setId(4);
        user.setUsername("man4");
        userMapper2.update(user);

        session.commit();
    }

4. 运行结果

添加描述

        这里想整一个效果图，但是没想到帧率不够，最后居然绿屏了，但是不影响我们继续学习哈哈哈，理解到位即可害嗨嗨

四、动态SQL---choose和wen和otherwise标签

        这些标签表示多条件分支，类似JAVA中的 switch...case 。 <choose> 类似switch ， <when> 类似 case ， <otherwise> 类似 default ，用法如下：

1. 持久层添加用户通用查询方法

这里就沿用那个通用查询方法即可

2. 映射文件添加相关标签

代码语言：javascript复制
    <select id="findByCondition" resultType="User" parameterType="user">
        select * from user
        <where>
            <choose>
                <when test="username.length() &lt; 5">
                    username like #{username}
                </when>
                <when test="username.length() &lt; 10">
                    username = #{username}
                </when>
                <otherwise>
                    id = 1
                </otherwise>
            </choose>
        </where>
    </select>

        这段代码的含义就是当用户名的长度小于（不等于）5的时候，使用模糊查询，查询返回的是泛型为USer的List集合对象，list长度不定；当用户名大于等于5，小于10的时候，使用精确查询，查询指定用户名的用户，返回的是泛型为USer的List集合对象，list长度为1或者0；当用户名长度大于等于10的时候，返回的是id为1的用户。

3. 测试类新建测试方法

代码语言：javascript复制
// 测试通用查询方法——用户名
    @Test
    public void testFindByCondition1(){
        User user = new User();
        System.out.println("------------设用户名字长度为2------------");
        user.setUsername("%on%");
        List<User> users = userMapper2.findByCondition(user);
        users.forEach(System.out::println);
        System.out.println("------------设用户名字长度为5------------");
        user.setUsername("%lions%");
        users = userMapper2.findByCondition(user);
        users.forEach(System.out::println);

        System.out.println("------------设用户名字长度为9------------");
        user.setUsername("T_no_name");
        users = userMapper2.findByCondition(user);
        users.forEach(System.out::println);

        System.out.println("------------设用户名字长度为10------------");
        user.setUsername("dddddddddd");
        users = userMapper2.findByCondition(user);
        users.forEach(System.out::println);

        System.out.println("------------设用户名字长度为12------------");
        user.setUsername("programmer_1");
        users = userMapper2.findByCondition(user);
        users.forEach(System.out::println);
    }

4. 运行结果

添加描述

       OK，其实从结果集和运行的SQL语句我们都可以得出，该映射文件的标签确实是验证了咱们刚刚的说法 

五、动态SQL---foreach标签

<foreach> 类似JAVA中的for循环，可以遍历集合或数组。 <foreach> 有如 下属性：

  1. collection：遍历的对象类型
  2. open：开始的sql语句
  3. close：结束的sql语句
  4. separator：遍历每项间的分隔符
  5. item：表示本次遍历获取的元素，遍历List、Set、数组时表示每项元素，遍历map时表示键值对的值。
  6. index：遍历List、数组时表示遍历的索引，遍历map时表示键值对的键。

1. 遍历数组

（1）持久层添加用户批量删除方法

代码语言：javascript复制
// 用户批量删除
    void deleteBatch(int[] ids);

（2）映射文件添加相关标签

代码语言：javascript复制
<!-- 批量删除 遍历数组-->    
    <delete id="deleteBatch" parameterType="int">
        delete from user
        <where>
            <foreach collection="array" item="id" open="id in(" close=")" separator=",">
                #{id}
            </foreach>
        </where>
    </delete>

其实这里对应的SQL语句就是： delete from user in (?,?,?,...) 

（3）测试类新建测试方法

代码语言：javascript复制
// 测试用户批量删除方法
    @Test
    public void testDeleteBatch(){
        int[] ids = {4,8};
        userMapper2.deleteBatch(ids);

        session.commit();
    }

（4）运行结果

运行前和运行后进行对比

运行后，四和八对应的记录确实是被删除了

2. 遍历List

        <foreach> 遍历List和Set的方法是一样的，我们使用 <foreach> 遍历List进行批量添加。

（1）持久层添加用户批量增加方法

代码语言：javascript复制
// 批量增加用户
    void insertBatch(List<User> users);

（2）映射文件添加相关标签

代码语言：javascript复制
<!-- 批量增加用户 -->
    <insert id="insertBatch" parameterType="User">
        insert into user values
        <foreach collection="list" item="user" separator=",">
            (null,#{user.username},#{user.sex},#{user.address})
        </foreach>
    </insert>

        这里对应的SQL语句则是：  insert into user values(null,username,sex,address)*N         N可以为大于或等于1的数         其中肯定会有人问到了，为什么id要为null，其实这里id是主键，我们建库建表的时候就已经设置了这里是自增字段，因此我们无需重复操作，如果设置有和表里面的id重复，说不定还会报错 

（3）测试类新建测试方法

代码语言：javascript复制
// 测试批量增加用户方法
    @Test
    public void testInsertBatch(){
        List<User> list = new ArrayList<>();
        list.add(new User("man1","man","Beijing"));
        list.add(new User("man1","man","Beijing"));
        list.add(new User("man1","man","Beijing"));
        list.add(new User("man1","man","Beijing"));
        list.add(new User("man1","man","Beijing"));
        list.add(new User("man1","man","Beijing"));

        userMapper2.insertBatch(list);
        session.commit();
    }

（4）运行结果

运行前和运行后进行对比

        OK，通过对比，确实是增加了相关记录，这里的id是因为我测试过很多次了，所以比较大，大家不用在意这些哈哈哈，侧面反映我是很认真在写的，期待小伙伴的支持

3. 遍历Map

        下面我们使用 <foreach> 遍历Map进行多条件查询。

（1）持久层添加多条件查询方法

代码语言：javascript复制
/**
     * 多条件查询
     * @param map 查询的键值对 键：属性名 值：属性值
     * @return
     */
    List<User> findUser(@Param("queryMap") Map<String,Object> map);

（2）映射文件添加相关标签

代码语言：javascript复制
<!-- 多条件查询 遍历map-->
    <select id="findUser" parameterType="map" resultType="User">
        select * from user
        <where>
            <foreach collection="queryMap" separator="and" index="key" item="value">
                ${key} = #{value}
            </foreach>
        </where>
    </select>

这里对应的代码段其实就是： select * from user where (? = ?) and (? = ?) 就像我们在淘宝，拼多多和京东上买东西使用筛选一样 

（3）测试类新建测试方法

代码语言：javascript复制
// 测试多条件查询方法
    @Test
    public void testFindUser(){
        Map<String,Object> map = new HashMap<>();
        // 这里筛选性别为man和地址为Beijing的结果集
        map.put("sex","man");
        map.put("address","Beijing");
        List<User> users = userMapper2.findUser(map);
        users.forEach(System.out::println);
        // 再测试一下
        map.clear();
        // 这里筛选地址为Beijing和用户名为man1的结果集
        map.put("address","Beijing");
        map.put("username","man1");
        users = userMapper2.findUser(map);
        users.forEach(System.out::println);
    }

（4）运行结果

先看用户表数据

执行方法，观察结果是否一致 （是的，确实一致），不一致怎么会放出来呢

OK，这里确实保持一致，动态查询就学到这里了，后续会继续更新相关内容滴，敬请关注！ ！！

后言----查错

  如果执行过程中有错误的话，不妨看看有没有导错包和导错类，下面就是上面用到相关的类用到的导包

持久层接口用到的包 

代码语言：javascript复制
package com.mybatisstudy.mapper;

import com.mybatisstudy.pojo.User;
import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

测试类用到的包

代码语言：javascript复制
import com.mybatisstudy.mapper.UserMapper2;
import com.mybatisstudy.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

我正在参与2023腾讯技术创作特训营第三期有奖征文，组队打卡瓜分大奖！

2023腾讯·技术创作特训营第三期

0 人点赞