Mybatis框架（四）终结Mybatis之Mybatis动态SQL与一对多多对一

最新推荐文章于 2023-03-20 19:24:28 发布

是JF啊

最新推荐文章于 2023-03-20 19:24:28 发布

阅读量800

点赞数 1

分类专栏： Java开发后端系列框架文章标签： mybatis

本文链接：https://blog.csdn.net/weixin_44894962/article/details/128860787

版权

Java开发后端系列框架专栏收录该内容

4 篇文章 1 订阅

订阅专栏

本文是本人专栏【Java开发后端系列框架】里的文章，文章根据各框架官网与网上资料加上本人工作经验，进行修改总结发布在这个专栏，主要目的是用于自我提升，不用于获取利益。如果系列文章能到帮到您本人将感到荣幸，如果有侵权请联系我删除修，祝各位都能在编程这条路越走越远，早日暴富。

文章目录

一、动态SQL

1、什么是动态SQL？

首先了解什么是静态SQL，通俗点讲，在程序执行之前，我们就能够看出它能查出来什么样内容的语句，称为静态SQL，例如直接一个SELECT语句

<select id="selectAll" resultType="user">
    select * from user
</select>

而动态SQL，只能在程序执行之后我们才能确定，例如

<select id="selectAll" parameterType="user">
        select * from user 
        <if test="id != null">
            where id = #{id}
        </if>
</select>

此时，我们无法确定ID是否为空，所以只能等程序执行完才能知道结果，这就是动态SQL。

2、动态SQL的9大标签

2.1、if

一般内嵌于 select / delete / update / insert 中，直接看代码

<select id="findUser">
    select * from User where 1=1
    <if test=" username!= null ">
        and username = #{username}
    </if>
    <if test=" password != null ">
        and password = #{password }
    </if>
</select>

这里在where后面加上了1=1，作用是防止出现如下情况：
如果没有1=1，就会出现

select * from User where and username = #{username}

where 后面连着 and ，出现语法错误，那么我们是否有更优雅的写法？使用where标签

2.2、where | set | trim

把这三个标签放一起，是因为他们之间互有相似
where

<select id="findUser">
   select * from User 
    <where>
    <if test=" username!= null ">
        and username = #{username}
    </if>
    <if test=" password != null ">
        and password = #{password}
    </if>
    </where>
</select>

如上代码，使用where标签既可以省略1=1，而且where标签还有个功能，就是可以隐藏第一个满足的条件前的and或者or，如上述代码，假设username和password均不为空，则执行的是

select * from User  where username = #{username} and password = #{password}

set
用法与where相似，用于update标签中

<update id="updateUser">
    update user 
        <set>
           <if test="username !=null">
                  username = #{username},
           </if> 
           <if test="password !=null">
                  password = #{password},
           </if>
        </set>    
     where id =#{id}
</update>

set标签与if标签搭配联用，原则上要求必须至少满足一个if，否则会出现如下语法错误

update user where id =#{id};

set 标签会智能拼接更新字段，以上例子如果传入 username = ‘张三’ 和 password = ‘123’，则有两个字段满足更新条件，set 标签会智能拼接后如下

update user set  username = '张三',password = '123'

智能省略最后一个句子的逗号

trim 标签
where 标签和 set 标签都只是 trim 标签的某种实现方案，trim 标签底层是通过 TrimSqlNode 类来实现的，它有几个关键属性：

prefix ：前缀，当 trim 元素内存在内容时，会给内容插入指定前缀
suffix ：后缀，当 trim 元素内存在内容时，会给内容插入指定后缀
prefixesToOverride ：前缀去除，支持多个，当 trim 元素内存在内容时，会把内容中匹配的前缀字符串去除。
suffixesToOverride ：后缀去除，支持多个，当 trim 元素内存在内容时，会把内容中匹配的后缀字符串去除。

所以where和set可以改下成如下

<!--
  注意在使用 trim 标签实现 where 标签能力时
  必须在 AND 和 OR 之后添加空格
  避免匹配到 android、order 等单词 
-->
<trim prefix="WHERE" prefixOverrides="AND | OR" >
    ...
</trim>

<trim prefix="SET" prefixOverrides="," >
    ...
</trim>

或者

<trim prefix="SET" suffixesToOverride="," >
    ...
</trim>

2.2、choose 标签、when 标签、otherwise 标签

choose 相当于java中的if/else，需要与when、otherwise 搭配使用

<select id="findUser">
    select * from User where 1=1 
    <choose>
        <when test=" age != null ">
            and username> #{username}
        </when>
        <when test=" name != null ">
            and password = #{password }
        </when>
        <otherwise>
            and id = '1'
        </otherwise>
    </choose>
</select>

如上代码中，带when中的条件都不满足时，就会执行otherwise里的条件语句。

2.3、foreach 标签

foreach 标签用于处理这需要遍历集合的场景，如：

 <select id="findAll">
    select  * from user where id in 
    <foreach collection="list"
        item="item" index="index" 
        open="(" separator="," close=")">
            #{item}
    </foreach>
</select>

执行语句

select  * from user where id in (1,2,3...)

以下是集中属性的含义

collection ：必填，Map 或者数组或者列表的属性名
item ：变量名，值为遍历的每一个值（可以是对象或基础类型），如果是对象那么依旧是 OGNL 表达式取值即可，例如 #{item.id} 、#{ user.name } 等
index ：索引的属性名，在遍历列表或数组时为当前索引值，当迭代的对象时 Map 类型时，该值为 Map 的键值（key）
open ：循环内容开头拼接的字符串，可以是空字符串
close ：循环内容结尾拼接的字符串，可以是空字符串
separator ：每次循环的分隔符

当传入的参数为 List 对象时，系统会默认添加一个 key 为 ‘list’ 的值，把列表内容放到这个 key 为 list 的集合当中，在 foreach 标签中可以直接通过 collection=“list” 获取到 List 对象。

当传入的参数为数组时，系统会默认添加一个 key 为 ‘array’ 的值，把列表内容放到这个 key 为 array 的集合当中，在 foreach 标签中可以直接通过 collection=“array” 获取到数组对象。

当传入的参数为 Map 对象时，系统并不会默认添加一个 key 值，需要手工传入，例如传入 key 值为 map2 的集合对象，在 foreach 标签中可以直接通过 collection=“map2” 获取到 Map 对象，并且 item 代表每次迭代的的 value 值，index 代表每次迭代的 key 值。

2.4、bind 标签

通过bind标签可以创建一个变量，并绑定到上下文，供上下文使用，构成模糊查询
官网例子如下

<select id="selecUser">
  <bind name="myName" value="'%' + _parameter.getName() + '%'" />
  SELECT * FROM user WHERE name LIKE #{myName}
</select>

二、多对一

搭建数据库环境

CREATE TABLE `teacher` (
                           `id` INT(10) NOT NULL,
                           `name` VARCHAR(30) DEFAULT NULL,
                           PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO teacher(`id`, `name`) VALUES (1, '老师');
CREATE TABLE `student` (
                           `id` INT(10) NOT NULL,
                           `name` VARCHAR(30) DEFAULT NULL,
                           `tid` INT(10) DEFAULT NULL,
                           PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '张三', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '李四', '2');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '王五', '3');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '老六', '4');

java

package top.jf.pojo;

import lombok.Data;

/**
 * @author : JF
 * @date: 2023/2/6 10:45
 */
@Data
public class Teacher {
    private int id;
    private String name;
}

package top.jf.pojo;

import lombok.Data;

/**
 * @author : JF
 * @date: 2023/2/6 10:45
 */
@Data
public class Student {
    private int id;
    private String name;
    //多个学生可以是同一个老师，即多对一
    private Teacher teacher;
}

package top.jf.mapper;

/**
 * @author : JF
 * @date: 2023/2/6 10:46
 */
public interface StudentMapper {
}

package top.jf.mapper;

/**
 * @author : JF
 * @date: 2023/2/6 10:46
 */
public interface TeacherMapper {
}

xml

<?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="top.jf.mapper.StudentMapper">
</mapper>

<?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="top.jf.mapper.TeacherMapper">
</mapper>

Mybaits配置文件绑定

<mapper class="top.jf.mapper.TeacherMapper" />
<mapper class="top.jf.mapper.StudentMapper" />

配置别名

<typeAliases>
        <typeAlias type="top.jf.pojo.Student" alias="Student"/>
        <typeAlias type="top.jf.pojo.Teacher" alias="Teacher"/>
</typeAliases>

需求：获取所有学生及对应老师的信息

1、按查询嵌套处理

编写接口StudentMapper

//获取所有学生及对应老师的信息
 List<Student> getStudents();

StudentMapper.xml

<select id="getStudents" resultMap="StudentTeacher">
        select * from student
    </select>
    <resultMap id="StudentTeacher" type="Student">
        <!--association关联属性  property属性名 javaType属性类型 column在多的一方的表中的列名-->
        <association property="teacher"  column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>
   
    <select id="getTeacher" resultType="teacher">
        select * from teacher where id = #{id}
    </select>

测试类

@Test
    public void testGetStudents() throws IOException {
        SqlSession session = MybatisUtils.getSession();
        StudentMapper mapper = session.getMapper(StudentMapper.class);
        List<Student> students = mapper.getStudents();
        for (Student student : students){
            System.out.println(
                    "学生名:"+ student.getName()
                            +"   老师:"+student.getTeacher().getName());
        }
    }

2、按结果嵌套处理

mapper

List<Student> getStudents2();

mapper.xml

<!--
按查询结果嵌套处理
思路：
    1. 直接查询出结果，进行结果集的映射
-->
<select id="getStudents2" resultMap="StudentTeacher2" >
    select s.id sid, s.name sname , t.name tname
    from student s,teacher t
    where s.tid = t.id
</select>
<resultMap id="StudentTeacher2" type="Student">
    <id property="id" column="sid"/>
    <result property="name" column="sname"/>
    <!--关联对象property 关联对象在Student实体类中的属性-->
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/>
    </association>
</resultMap>

测试接口

@Test
public void testGetStudents2(){
    SqlSession session = MybatisUtils.getSession();
    StudentMapper mapper = session.getMapper(StudentMapper.class);
    List<Student> students = mapper.getStudents2();
    for (Student student : students){
        System.out.println(
                "学生名:"+ student.getName()
                        +"t老师:"+student.getTeacher().getName());
    }
}

三、一对多

实体类

@Data
public class Student {
    private int id;
    private String name;
    private int tid;
}

@Data 
public class Teacher {
    private int id;
    private String name;
    //一个老师多个学生
    private List<Student> students;
}

1、按结果嵌套处理

TeacherMapper接口

//获取指定老师，及老师下的所有学生
public Teacher getTeacher(int id);

TeacherMapper配置文件


    <!--
    思路:
        1. 从学生表和老师表中查出学生id，学生姓名，老师姓名
        2. 对查询出来的操作做结果集映射
            1. 集合的话，使用collection！
                JavaType和ofType都是用来指定对象类型的
                JavaType是用来指定pojo中属性的类型
                ofType指定的是映射到list集合属性中pojo的类型。
    -->
    <select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid, s.name sname , t.name tname, t.id tid
        from student s,teacher t
        where s.tid = t.id and t.id=#{id}
    </select>
    <resultMap id="TeacherStudent" type="Teacher">
        <result  property="name" column="tname"/>
        <collection property="students" ofType="Student">
            <result property="id" column="sid" />
            <result property="name" column="sname" />
            <result property="tid" column="tid" />
        </collection>
    </resultMap>

测试类

@Test
public void testGetTeacher(){
    SqlSession session = MybatisUtils.getSession();
    TeacherMapper mapper = session.getMapper(TeacherMapper.class);
    Teacher teacher = mapper.getTeacher(1);
    System.out.println(teacher.getName());
    System.out.println(teacher.getStudents());
}

2、按查询嵌套处理

接口

public Teacher getTeacher2(int id);

配置文件，写完记得注册！

<select id="getTeacher2" resultMap="TeacherStudent2">
  select * from teacher where id = #{id}
</select>
<resultMap id="TeacherStudent2" type="Teacher">
    <!--column是一对多的外键 , 写的是一的主键的列名-->
    <collection property="students" javaType="ArrayList" ofType="Student" column="id" select="getStudentByTeacherId"/>
</resultMap>
<select id="getStudentByTeacherId" resultType="Student">
    select * from student where tid = #{id}
</select>

测试

@Test
public void testGetTeacher2(){
    SqlSession session = MybatisUtils.getSession();
    TeacherMapper mapper = session.getMapper(TeacherMapper.class);
    Teacher teacher = mapper.getTeacher2(1);
    System.out.println(teacher.getName());
    System.out.println(teacher.getStudents());
}