一文讲明Mybatis 的使用 超详细 【爆肝两万字教程】

我 | 在这里
️ 读书 | 长沙 ⭐软件工程 ⭐ 本科
工作 | 广州 ⭐ Java 全栈开发（软件工程师）
爱好 | 研究技术、旅游、阅读、运动、喜欢流行歌曲
️ 标签 | 男 自律狂人 目标明确 责任心强
✈️公众号 | 热爱技术的小郑
邮箱 | [email protected]
✈️ GitHub项目仓库 开源项目 + 实战Demo
 
为何而写？
好记性不如烂笔头，记录学习的相关知识 、项目 BUG 解决
复盘总结，加深记忆，方便自己查看
分享知识，咱就是这么乐于助人、专注填坑20年、哈哈哈哈
 
目标描述
没有伞的孩子、只能用力奔跑。向着架构师的方向努力、做一个有始有终的人。

所有源码公布开源在GitHub 上：Mybatsi 案例源码传送门

1、Mybatis简介

1.1 什么是Mybatis

如何获得Mybatis
● maven仓库：

    
        org.mybatis
        mybatis
        3.5.6
    

● 中文文档：https://mybatis.org/mybatis-3/zh/index.html
● Github:https://github.com/mybatis/mybatis-3

1.2 持久化

数据持久化
● 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
● 内存：断电即失
● 数据库（Jdbc），io文件持久化
● 生活方面例子：冷藏，罐头。
为什么需要持久化？
● 不想丢掉一些对象
● 内存太贵

1.3 持久层

Dao层，Service层，Controller层…
● 完成持久化工作的代码块
● 层界限十分明显

1.4 为什么需要Mybatis？

● 帮助程序猿将数据存入到数据库中
● 方便
● 传统的JDBC代码太复杂，简化–>框架–>自动化

2、第一个Mybatis程序

2.1 搭建环境

整体过程
● 1、新建一个maven项目
● 2、删除src目录
● 3、pom中导入相关依赖（可选）
● 4、新建一个module、目的方便项目扩展
● 5、子项目中也可以导入相关依赖（建议导入子项目，方便区分不同的module）

    <dependencies>
        <!--mysql driver-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.9</version>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>

        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

重点提示 ：需要加上如下代码。否则部分代码无法编译道target 目录下，导致运行时报错

    
           
        
            
                
                src/main/java
                
                    
                    
                    **/*.properties
                    **/*.xml
                
                
                false
            
            
                src/main/resources
            
        
    

2.2 创建模块

● 编写mybatis的核心配置文件 （这里的mappers 以及起别名 可以后期编写实体类、mapper的相关代码后再写）

● 编写mybatis 的相关工具类

package com.zyz.mybatis.entity;

/**
 * @BelongsProject: SpringDemo1
 * @BelongsPackage: com.zyz.SpringDemo2.entity
 * @Author: zhengyuzhu
 * @CreateTime: 2023-11-16  22:33
 * @Description: TODO
 * @Version: 1.0
 */
public class Student {
    private int stuNo;
    private String stuName;
    private int cardID;
    private int classID;
    public Student() {
    }
    public Student(int stuNo, String stuName, int cardID, int classID) {
        this.stuNo = stuNo;
        this.stuName = stuName;
        this.cardID = cardID;
        this.classID = classID;
    }
    public int getStuNo() {
        return stuNo;
    }
    public void setStuNo(int stuNo) {
        this.stuNo = stuNo;
    }
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
    public int getCardID() {
        return cardID;
    }
    public void setCardID(int cardID) {
        this.cardID = cardID;
    }
    public int getClassID() {
        return classID;
    }
    public void setClassID(int classID) {
        this.classID = classID;
    }
    @Override
    public String toString() {
        return "Student{" +
                "stuNo=" + stuNo +
                ", stuName='" + stuName + '\'' +
                ", cardID=" + cardID +
                ", classID=" + classID +
                '}';
    }
}

2.3 编写代码

实体类 Student

package com.zyz.mybatis.entity;

/**
 * @BelongsProject: SpringDemo1
 * @BelongsPackage: com.zyz.SpringDemo2.entity
 * @Author: zhengyuzhu
 * @CreateTime: 2023-11-16  22:33
 * @Description: TODO
 * @Version: 1.0
 */
public class Student {
    private int stuNo;
    private String stuName;
    private int cardID;
    private int classID;
    public Student() {
    }
    public Student(int stuNo, String stuName, int cardID, int classID) {
        this.stuNo = stuNo;
        this.stuName = stuName;
        this.cardID = cardID;
        this.classID = classID;
    }
    public int getStuNo() {
        return stuNo;
    }
    public void setStuNo(int stuNo) {
        this.stuNo = stuNo;
    }
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
    public int getCardID() {
        return cardID;
    }
    public void setCardID(int cardID) {
        this.cardID = cardID;
    }
    public int getClassID() {
        return classID;
    }
    public void setClassID(int classID) {
        this.classID = classID;
    }
    @Override
    public String toString() {
        return "Student{" +
                "stuNo=" + stuNo +
                ", stuName='" + stuName + '\'' +
                ", cardID=" + cardID +
                ", classID=" + classID +
                '}';
    }
}

mapper接口 StudentMapper 及 xml配置文件 StudentMapper.xml

/**
 * @author zyz
 * @version 1.0
 * @data 2023/11/16 22:33
 * @Description:
 */
public interface StudentMapper {
    /**
     * @description: 查询全部
     * @author: zhengyuzhu
     * @date: 2023/11/16 22:34
     * @return: java.util.List
     **/
    List queryAll();

    /**
     * @description: 新增学生
     * @author: zhengyuzhu
     * @date: 2023/11/16 22:34
     * @param: student
     **/
    void addStudent(Student student);
}

StudentMapper.xml

    
    
        select * from student
    

    
    
        insert into student (stuno,stuname,cardid,classid)
        values (#{stuNo},#{stuName},#{cardID},#{classID})
    

2.4 测试单元

/**
 * @description: 基本测试
 * @author: zhengyuzhu
 * @date: 2023/11/20 22:21
 **/
@Test
public void test01(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    //方式一：getMapper
    StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
    List userList = studentMapper.queryAll();

    for (Student student : userList) {
        System.out.println(student);
    }

    //关闭SqlSession
    sqlSession.close();

    /**
     *      输出如下 :
     *
     * Student{stuNo=1, stuName='张三', cardID=1115, classID=1}
     * Student{stuNo=2, stuName='李四', cardID=1116, classID=2}
     * Student{stuNo=3, stuName='王五', cardID=1117, classID=3}
     *
     **/

}

3、测试增删改查（CURD）

提示：我们的实体类，或者数据库中的表，字段或者参数过多，我们应当考虑使用Map！具体案例参考 3.3 修改。修改用户信息的时候，使用了两种方式，一种是通过对象。另外一种是通过map 。有关参数的赋值以及sql语句的字段 获取。都有说明

3.1 添加

mapper 和 xml 配置文件

    /**
     * @description: 新增学生
     * @author: zhengyuzhu
     * @date: 2023/11/16 22:34
     * @param: student
     *
     * @return*/
    Integer addStudent(Student student);


    
    
        insert into student (stuno, stuname, cardid, classid)
        values (#{stuNo}, #{stuName}, #{cardID}, #{classID})
    


    

测试单元

    /**
     * @description: 添加对象
     * @author: zhengyuzhu
     * @date: 2023/11/21 21:06
     **/
    @Test
    public void test04(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //方式一：getMapper
        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
        Student student = new Student();
        student.setStuNo(9);
        student.setStuName("武松");
        student.setClassID(8);
        student.setCardID(8);
        studentMapper.addStudent(student);
        sqlSession.commit();//将数据保存到数据库
        Student studentRs = studentMapper.queryStudentById(9);
        System.out.println(studentRs);


        //关闭SqlSession
        sqlSession.close();

        /**
         *      输出如下 :
         *      Student{stuNo=9, stuName='武松', cardID=8, classID=8}
         *
         **/

    }

3.2 删除

mapper 和 xml 配置文件

    /**
     * @description:删除学生 通过 学号
     * @author: zhengyuzhu
     * @date: 2023/11/20 22:45
     * @param: stuNo
     * @return: java.lang.Integer
     **/
    Integer deleteStudentById(Integer stuNo);


    
        delete
        from student
        where stuNo = #{stuNo}
    

测试单元

    /**
     * @description: 删除对象
     * @author: zhengyuzhu
     * @date: 2023/11/21 21:07
     **/
    @Test
    public void test05(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
        studentMapper.deleteStudentById(9);
        sqlSession.commit();//将数据保存到数据库
        Student studentRs = studentMapper.queryStudentById(9);
        System.out.println(studentRs);

        //关闭SqlSession
        sqlSession.close();

        /**
         *      输出如下 :
         *      null
         *
         **/

    }

3.3 修改

mapper 和 xml 配置文件

一个是通过对象的方式修改，一个是通过 map

    /** 
     * @description: 修改学生信息
     * @author: zhengyuzhu
     * @date: 2023/11/20 22:45
     * @param: student
     * @return: java.lang.Integer
     **/
    Integer updateStudent(Student student);

    /**
     * @description: 通过Map 修改学生信息
     * @author: zhengyuzhu
     * @date: 2023/11/21 21:08
     * @param: studentMap
     * @return: java.lang.Integer
     **/
    Integer updateStudentMap(HashMap studentMap);



    
        update student
        set stuNo   = #{stuNo},
            stuName = #{stuName},
            cardid  = #{cardID},
            classid = #{classID}
        where stuNo = #{stuNo}
    

    
        update student
        set stuNo   = #{stuNo},
            stuName = #{stuName},
            cardid  = #{cardid},
            classid = #{classid}
        where stuNo = #{stuNo}
    

测试单元

    /**
     * @description: 修改对象信息 通过Map
     * @author: zhengyuzhu
     * @date: 2023/11/20 23:02
     **/
    @Test
    public void test02(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //方式一：getMapper
        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
        HashMap stuMap = new HashMap<>();
        stuMap.put("stuNo",1);
        stuMap.put("stuName","李白");
        stuMap.put("cardid",6);
        stuMap.put("classid",6);
        Integer rs = studentMapper.updateStudentMap(stuMap);
        Student student = studentMapper.queryStudentById(1);
        System.out.println(student);


        //关闭SqlSession
        sqlSession.close();

        /**
         *      输出如下 :
         *
         * Student{stuNo=1, stuName='张三', cardID=1115, classID=1}
         * Student{stuNo=2, stuName='李四', cardID=1116, classID=2}
         * Student{stuNo=3, stuName='王五', cardID=1117, classID=3}
         *
         **/

    }

    /**
     * @description: 修改对象信息 通过 Student 对象
     * @author: zhengyuzhu
     * @date: 2023/11/20 23:02
     **/
    @Test
    public void test03(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //方式一：getMapper
        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);

        Student studentBefore = studentMapper.queryStudentById(0);
        System.out.println("修改前的学生信息 : " + studentBefore);

        Student student = new Student();
        student.setStuNo(0);
        student.setStuName("麻子嘞");
        student.setClassID(6);
        student.setCardID(6);
        studentMapper.updateStudent(student);
        sqlSession.commit();//将数据保存到数据库

        Student studentAfter = studentMapper.queryStudentById(0);
        System.out.println("修改后的学生信息 : " + studentAfter);

        //关闭SqlSession
        sqlSession.close();

        /**
         *      输出如下 :
         *
         *  修改前的学生信息 : Student{stuNo=0, stuName='李四', cardID=8, classID=8}
         *  修改后的学生信息 : Student{stuNo=0, stuName='麻子嘞', cardID=6, classID=6}
         *
         **/

    }

3.4 查询

mapper 和 xml 配置文件

    /**
     * @description: 查询全部
     * @author: zhengyuzhu
     * @date: 2023/11/16 22:34
     * @return: java.util.List
     **/
    List queryAll();

    /**
     * @description:删除学生 通过 学号
     * @author: zhengyuzhu
     * @date: 2023/11/20 22:45
     * @param: stuNo
     * @return: java.lang.Integer
     **/
    Integer deleteStudentById(Integer stuNo);



    
    
        select *
        from student
    

    
        select *
        from student
        where stuNo = #{stuNo}
    

测试单元

    /**
     * @description: 基本测试
     * @author: zhengyuzhu
     * @date: 2023/11/20 22:21
     **/
    @Test
    public void test01(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //方式一：getMapper
        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
        List userList = studentMapper.queryAll();

        for (Student student : userList) {
            System.out.println(student);
        }

        //关闭SqlSession
        sqlSession.close();

        /**
         *      输出如下 :
         *
         * Student{stuNo=1, stuName='张三', cardID=1115, classID=1}
         * Student{stuNo=2, stuName='李四', cardID=1116, classID=2}
         * Student{stuNo=3, stuName='王五', cardID=1117, classID=3}
         *
         **/

    }

3.5 模糊查询

● 1、java代码执行的时候，传递通配符% %

/**
 * @description: 模糊查询
 * @author: zhengyuzhu
 * @date: 2023/11/21 21:39
 * @param: like
 * @return: java.util.List
 **/
List getStudentLike(String value);

● 2、在sql拼接中使用通配符！

    select * from student where stuname like "%"#{value}"%"

测试单元

/**
 * @description: 模糊查询
 * @author: zhengyuzhu
 * @date: 2023/11/21 21:41
 **/
@Test
public void test06(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    //方式一：getMapper
    StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
    List userList = studentMapper.getStudentLike("%李%");

    for (Student student : userList) {
        System.out.println(student);
    }

    //关闭SqlSession
    sqlSession.close();

    /**
     *      输出如下 :
     *
     * Student{stuNo=2, stuName='李四', cardID=1116, classID=2}
     * Student{stuNo=8, stuName='李老头', cardID=8, classID=8}
     *
     **/

}

4、配置解析

可以参考官网的更加详细的说明，这里对常用的属性进行说明
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下：
● configuration（配置）
○ properties（属性）
○ settings（设置）
○ typeAliases（类型别名）
○ typeHandlers（类型处理器）
○ objectFactory（对象工厂）
○ plugins（插件）
○ environments（环境配置）
■ environment（环境变量）
● transactionManager（事务管理器）
● dataSource（数据源）
○ databaseIdProvider（数据库厂商标识）
○ mappers（映射器）

4.1 属性

我们可以通过properties属性来实现引用配置文件
这些属性都是可外部配置且可动态替换的，既可以在典型的Java属性文件中配置，亦可通过properties元素的子元素来传递。【db.properties】
编写一个配置文件

db.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_test?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8&useSSL=false
jdbc.username=root
jdbc.password=root

在核心配置文件中映入

4.2 设置

设置 参考官网介绍 这里掠过
settings（设置）

4.3 类型别名

● 类型别名是为Java类型设置一个短的名字。
● 存在的意义仅在于用来减少类完全限定名的冗余。

第一种：实体类较少的情况。单独起别名

第二种：当实体类很多的时候，可以使用package的形式，会自动的将该包下的所有类定义了别名，别名就是其自身且不区分大小

第一种可以DIY别名，第二种则不行，如果非要改，需要在实体上增加注解

@Alias("author")
public class Author {
    ...
}

4.4类型处理器（typeHandlers）

MyBatis 在设置预处理语句（PreparedStatement）中的参数或从结果集中取出一个值时， 都会用类型处理器将获取到的值以合适的方式转换成 Java 类型。下表描述了一些默认的类型处理器。
类型处理器 参考官网介绍 这里掠过
typeHandlers（类型处理器）

4.5 对象工厂

每次 MyBatis 创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成实例化工作。 默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认无参构造方法，要么通过存在的参数映射来调用带有参数的构造方法。 如果想覆盖对象工厂的默认行为，可以通过创建自己的对象工厂来实现
对象工厂 参考官网介绍 这里掠过
objectFactory（对象工厂）

4.6 插件（plugins）

具体使用参考官网，略
plugins（插件）

4.7 环境配置

○ environments（环境配置）
■ environment（环境变量）
● transactionManager（事务管理器）
● dataSource（数据源）

MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。
不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
environments 元素定义了如何配置环境。

注意一些关键点:
● 默认使用的环境 ID（比如：default=“development”）。
● 每个 environment 元素定义的环境 ID（比如：id=“development”）。
● 事务管理器的配置（比如：type=“JDBC”）。
● 数据源的配置（比如：type=“POOLED”）。
默认环境和环境 ID 顾名思义。 环境可以随意命名，但务必保证默认的环境 ID 要匹配其中一个环境 ID。

4.7.1 environment (环境变量)

注意一些关键点:
● 默认使用的环境 ID（比如：default=“development”）。
● 每个 environment 元素定义的环境 ID（比如：id=“development”）。
● 事务管理器的配置（比如：type=“JDBC”）。
● 数据源的配置（比如：type=“POOLED”）。
默认环境和环境 ID 顾名思义。 环境可以随意命名，但务必保证默认的环境 ID 要匹配其中一个环境 ID。

4.7.2 transactionManager（事务管理器）

如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。
这两种事务管理器类型都不需要设置任何属性。它们其实是类型别名，换句话说，你可以用 TransactionFactory 接口实现类的全限定名或类型别名代替它们。
在 MyBatis 中有两种类型的事务管理器（也就是 type=“[JDBC|MANAGED]”）：
● 1、JDBC – 这个配置直接使用了 JDBC 的提交和回滚功能，它依赖从数据源获得的连接来管理事务作用域。默认情况下，为了与某些驱动程序兼容，它在关闭连接时启用自动提交。然而，对于某些驱动程序来说，启用自动提交不仅是不必要的，而且是一个代价高昂的操作。因此，从 3.5.10 版本开始，你可以通过将 “skipSetAutoCommitOnClose” 属性设置为 “true” 来跳过这个步骤：例如

● MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为

4.7.3 dataSource（数据源）

dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。
大多数 MyBatis 应用程序会按示例中的例子来配置数据源。虽然数据源配置是可选的，但如果要启用延迟加载特性，就必须配置数据源。
有三种内建的数据源类型（也就是 type=“[UNPOOLED|POOLED|JNDI]”）：
● 1、UNPOOLED– 这个数据源的实现会每次请求时打开和关闭连接。虽然有点慢，但对那些数据库连接可用性要求不高的简单应用程序来说，是一个很好的选择。 性能表现则依赖于使用的数据库，对某些数据库来说，使用连接池并不重要，这个配置就很适合这种情形。
● 2、POOLED– 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。 这种处理方式很流行，能使并发 Web 应用快速响应请求。
● 3、JNDI – 这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用

4.8 数据库厂商标识

具体参考官网，这里掠过
databaseIdProvider（数据库厂商标识）

4.9 映射器

既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要来定义 SQL 映射语句了。 但首先，我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面，Java 并没有提供一个很好的解决方案，所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。
注意点：
● 接口和它的Mapper配置文件必须同名！
● 接口和它的Mapper配置文件必须在同一个包下!

四种方式
● 1、第一种：使用相对于类路径的资源引用

● 2、第二种：使用完全限定资源定位符（URL）

● 3、第三种：使用映射器接口实现类的完全限定类名

● 4、第四种：将包内的映射器接口全部注册为映射器 【使用的最多】

4.10 完整的配置文件（实战）

4.10.1 db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_test?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8&useSSL=false
jdbc.username=root
jdbc.password=root

4.10.2 mybatis-config.xml

4.10.3 项目结构

5、解决属性名和字段名不一致的问题

数据库 和 实体类对应关系如下：

5.1 通过字段别名解决

2、通过给字段起别名解决

       select id,name as goods_Name,amount as goods_Amount,price as goods_Price
       from goods
       where id = #{id}

5.2 通过结果集映射(resultMap)

3、通过结果集映射

       select *
       from goods
       where id = #{id}




    
    
    
    
    

测试单元

  /**
     * @description: 测试查询商品信息 数据库字段 和 实体类字段不一致问题
     * @author: zhengyuzhu
     * @date: 2023/11/22 9:19
     **/
    @Test
    public void testDemo1(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //方式一：getMapper
        GoodsMapper goodsMapper = sqlSession.getMapper(GoodsMapper.class);
        Goods goods = goodsMapper.queryGoodsById(1001);
        System.out.println(goods);

        //关闭SqlSession
        sqlSession.close();

        /**
         *  输出如下 :
         *          实体类字段           数据库字段
         *             id                 id
         *         goods_Name            name
         *         goods_Amount         amount
         *         goods_Price           price
         *
         *  Goods{id=1001, goods_Name='null', goods_Amount=null, goods_Price=null}
         *
         *
         *
         *  第一种方式：字段起别名：
         *            select id,name as goods_Name,amount as goods_Amount,price as goods_Price
         *
         *  Goods{id=1001, goods_Name='茶杯', goods_Amount=10, goods_Price=13.6}
         *
         *
         *  第二种方式：结果集映射：
         *              具体实现查看 GoodsMapper.xml 文件注释描述
         *
         *  Goods{id=1001, goods_Name='茶杯', goods_Amount=10, goods_Price=13.6}
         *
         **/
    }

6、日志

Mybatis 通过使用内置的日志工厂提供日志功能。内置日志工厂将会把日志工作委托给下面的实现之一：
● SLF4J
● Apache Commons Logging
● Log4j 2
● Log4j（3.5.9起废弃）
● JDK logging
MyBatis 内置日志工厂基于运行时自省机制选择合适的日志工具。

6.1 Log4j 的使用

什么是Log4j？

● Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
● 我们也可以控制每一条日志的输出格式；
● 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
● 可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

具体使用过程如下：
1、先在pom.xml文件中导入log4j的依赖包

    log4j
    log4j
    1.2.17

2、在resources文件夹下建立log4j.properties文件进行配置
这里将 文件输出的位置 放在根目录 ./log/zyz.log

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger = DEBUG,console ,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold = DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern =  [%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File = ./log/zyz.log
log4j.appender.file.MaxFileSize = 10mb
log4j.appender.file.Threshold = DEBUG
log4j.appender.file.layout = org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern = [%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

3、在mybatis-config.xml核心配置文件中，配置log4j为日志的实现！

4、Log4j的使用，直接测试运行
在被测试的类中添加 这段信息

static Logger logger = Logger.getLogger(TestGoods.class);
import com.zyz.mybatis.entity.Goods;
import com.zyz.mybatis.mapper.GoodsMapper;
import com.zyz.mybatis.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.Test;


/**
 * @BelongsProject: Mybatis
 * @BelongsPackage: PACKAGE_NAME
 * @Author: zhengyuzhu
 * @CreateTime: 2023-11-22  09:19
 * @Description: TODO
 * @Version: 1.0
 */
public class TestGoods {
    static Logger logger = Logger.getLogger(TestGoods.class);
    
    /**
     * @description: 测试日志打印
     * @author: zhengyuzhu
     * @date: 2023/11/22 10:03
     **/
    @Test
    public void testDemo2(){
        logger.info("INFO   日志测试");
        logger.debug("DEBUG 日志测试");
        logger.error("ERROR 日志测试");
    }
}

输出结果入下：

7、分页

思考：为什么要分页！
● 减少数据的处理量

7.1 使用Limit分页

语法：SELECT * from user limit startIndex,pageSize
SELECT * from user limit 3 #[0,n]

1、接口

/**
 * @description: 使用 limit 分页查询数据
 * @author: zhengyuzhu
 * @date: 2023/11/22 10:56
 * @param: map
 * @return: java.util.List
 **/
List queryGoodsLimit(Map map);

2、GoodsMapper.xml 文件

    select *
    from goods limit #{startIndex},#{pageSize}




    
    
    
    
    

3、测试单元

/**
 * @description: limit 分页查询数据
 * @author: zhengyuzhu
 * @date: 2023/11/22 10:59
 **/
@Test
public void testDemo3(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    //方式一：getMapper
    GoodsMapper goodsMapper = sqlSession.getMapper(GoodsMapper.class);
    HashMap goodsMap = new HashMap();
    goodsMap.put("startIndex",0);
    goodsMap.put("pageSize",3);
    List goodsList = goodsMapper.queryGoodsLimit(goodsMap);
    for(Goods goods : goodsList){
        logger.info(goods);
    }
    //关闭SqlSession
    sqlSession.close();

    /**
     *  输出如下 :
     *
     * [com.zyz.mybatis.mapper.GoodsMapper.queryGoodsLimit]-==>  Preparing: select * from goods limit ?,?
     * [com.zyz.mybatis.mapper.GoodsMapper.queryGoodsLimit]-==> Parameters: 0(Integer), 3(Integer)
     * [com.zyz.mybatis.mapper.GoodsMapper.queryGoodsLimit]-<==      Total: 3
     * [TestGoods]-Goods{id=1001, goods_Name='茶杯', goods_Amount=10, goods_Price=13.6}
     * [TestGoods]-Goods{id=1002, goods_Name='茶壶', goods_Amount=10, goods_Price=15.9}
     * [TestGoods]-Goods{id=1003, goods_Name='保温杯', goods_Amount=10, goods_Price=23.6}
     *
     **/
}

7.2 RowBounds分页

1.接口

/**
 * @description: 使用 RowBounds 分页
 * @author: zhengyuzhu
 * @date: 2023/11/22 11:12
 * @return: java.util.List
 **/
List queryGoodsByRowBounds();

2 .GoodsMapper.xml 文件

    select * from goods




    
    
    
    
    

3.测试单元

/**
 * @description: 2、使用 RowBounds 分页
 * @author: zhengyuzhu
 * @date: 2023/11/22 11:14
 **/
@Test
public void testDemo4(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    // RowBounds 实现
    RowBounds rowBounds = new RowBounds(0, 2);

    List goodsList = sqlSession.selectList("com.zyz.mybatis.mapper.GoodsMapper.queryGoodsByRowBounds",null,rowBounds);
    for(Goods goods : goodsList){
        logger.info(goods);
    }
    //关闭SqlSession
    sqlSession.close();

    /**
     *  输出如下 :
     *
     * [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@77a57272]
     * [com.zyz.mybatis.mapper.GoodsMapper.queryGoodsByRowBounds]-==>  Preparing: select * from goods
     * [com.zyz.mybatis.mapper.GoodsMapper.queryGoodsByRowBounds]-==> Parameters:
     * [TestGoods]-Goods{id=1001, goods_Name='茶杯', goods_Amount=10, goods_Price=13.6}
     * [TestGoods]-Goods{id=1002, goods_Name='茶壶', goods_Amount=10, goods_Price=15.9}
     *
     **/
}

7.3 分页插件

官网介绍：链接https://pagehelper.github.io/

使用分页插件的流程：
● 1、在maven中引入PageHelper和jsqlparser
● 2、mybatis-config.xml中增加plugin配置
● 3、代码中使用PageHelper.startPage() 自动分页

1、首先，在maven中引入PageHelper和jsqlparser

    com.github.pagehelper
    pagehelper
    5.1.4


    com.github.jsqlparser
    jsqlparser
    1.4

说明：
（1）jsqlparser的版本需要是2.0及以上的版本；因为5.1.10之前的PageHelper并没有对jsqlparser版本作要求；但是5.1.10及以后的PageHelper采用了新的API，所以jsqlparser的版本需要是2.0及以上的版本才可以；【我这里退回 1.4 可以正常使用】
（2）PageHelper执行原理：PageHelper在原有的要执行的SQL基础上，进行分析，自动生成分页以及【select count(*) from…】这样的语句；因为，涉及到原始SQL的分析与解析，所以需要引入jsqlparser这个SQL解析器组件啦；

2、mybatis-config.xml中增加plugin配置
参数详解：Mybatis-PageHelper
官网：官网文档
plugins插件是mybatis的一个特色，通过插件可以扩展mybatis的能力；
（2）interceptor属性：代表拦截器，需要配置PageHelper的核心类；
（3）helperDialect配置项和reasonable配置项（在PageHelper的官网文档中有详细说明）

3、测试单元

  /**
     * @description: 3、使用分页插件
     * @author: zhengyuzhu
     * @date: 2023/11/22 13:43
     **/
    @Test
    public void testDemo5(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        // PageHelper.startPage()对即将到来的下一次查询进行分页处理；
        // 比如下面就是第1页，每页2条数据；
        PageHelper.startPage(1, 2);
        GoodsMapper goodsMapper = sqlSession.getMapper(GoodsMapper.class);
        List goodsList = goodsMapper.queryGoodByPlugin();
       //用PageInfo对结果进行包装
        PageInfo page = new PageInfo(goodsList);
        System.out.println("总页数："+page.getPages());
        System.out.println("总记录数："+page.getTotal());
        System.out.println("开始行号："+page.getStartRow());
        System.out.println("结束行号："+page.getEndRow());
        System.out.println("当前页码："+page.getPageNum());

        List goodsListRs = page.getList();

        for(Goods goods : goodsListRs){
            logger.info(goods);
        }
        //关闭SqlSession
        sqlSession.close();

        /**
         *  输出如下 :
         *
         [com.zyz.mybatis.mapper.GoodsMapper.queryGoodByPlugin_COUNT]-==>  Preparing: SELECT count(0) FROM goods
         [com.zyz.mybatis.mapper.GoodsMapper.queryGoodByPlugin_COUNT]-==> Parameters: 
         [com.zyz.mybatis.mapper.GoodsMapper.queryGoodByPlugin_COUNT]-<==      Total: 1
         [com.zyz.mybatis.mapper.GoodsMapper.queryGoodByPlugin]-==>  Preparing: select * from goods LIMIT ?
         [com.zyz.mybatis.mapper.GoodsMapper.queryGoodByPlugin]-==> Parameters: 2(Integer)
         [com.zyz.mybatis.mapper.GoodsMapper.queryGoodByPlugin]-<==      Total: 2
         总页数：2
         总记录数：4
         开始行号：1
         结束行号：2
         当前页码：1
         [TestGoods]-Goods{id=1001, goods_Name='茶杯', goods_Amount=10, goods_Price=13.6}
         [TestGoods]-Goods{id=1002, goods_Name='茶壶', goods_Amount=10, goods_Price=15.9}
         **/
    }

8、使用注解开发

8.1 面向接口编程

● 之前学过面向对象编程，也学习过接口，但在真正的开发中，很多时候会选择面向接口编程。
● 根本原因：解耦，可拓展，提高复用，分层开发中，上层不用管具体的实现，大家都遵守共同的标准，使得开发变得容易，规范性更好
● 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的，对系统设计人员来讲就不那么重要了；
● 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

8.2 注解开发

8.2.1 基本测试

1. 注解在StudentMapper接口上实现，不需要 StudentMapper.xml文件

   /**
     * @description: 查询用户
     * @author: zhengyuzhu
     * @date: 2023/11/22 14:40
     * @return: java.util.List
     **/
    @Select("select * from user")
    List getUsers();

2. 需要在mybatis-config.xml核心配置文件中绑定接口

3. 单元测试

/**
     * @description: 注解开发 查询
     * @author: zhengyuzhu
     * @date: 2023/11/22 14:41
     **/
    @Test
    public void testDemo1(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List users = mapper.getUsers();

        for (User user : users) {
            System.out.println(user);
        }

        sqlSession.close();

        /**
         * 输出如下：
         *
         * [com.zyz.mybatis.mapper.UserMapper.getUsers]-==>  Preparing: select * from user
         * [com.zyz.mybatis.mapper.UserMapper.getUsers]-==> Parameters:
         * [com.zyz.mybatis.mapper.UserMapper.getUsers]-<==      Total: 6
         * User{id=1, name='张三', password='null'}
         * User{id=2, name='李四', password='null'}
         * User{id=3, name='王五', password='null'}
         * User{id=4, name='麻子', password='null'}
         * User{id=5, name='李白', password='null'}
         * User{id=6, name='小明', password='null'}
         *
         *
         **/
    }

8.2.2 测试增删改查

当数据表字段名和POJO字段名不一致时，需要进行映射：

/**
 * @description: 查询用户
 * @author: zhengyuzhu
 * @date: 2023/11/22 14:40
 * @return: java.util.List
 **/
@Select("select * from user")
@Results(value = {
        @Result(id=true,column = "id",property = "id"),
        @Result(column = "name",property = "name"),
        @Result(column = "pwd",property = "password")
})
List getUsers();

测试单元

  /**
     * @description: 注解开发 查询
     * @author: zhengyuzhu
     * @date: 2023/11/22 14:41
     **/
    @Test
    public void testDemo1(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List users = mapper.getUsers();

        for (User user : users) {
            System.out.println(user);
        }

        sqlSession.close();

        /**
         * 输出如下：
         *
         * [com.zyz.mybatis.mapper.UserMapper.getUsers]-==>  Preparing: select * from user
         * [com.zyz.mybatis.mapper.UserMapper.getUsers]-==> Parameters:
         * [com.zyz.mybatis.mapper.UserMapper.getUsers]-<==      Total: 6
         * User{id=1, name='张三', password='null'}
         * User{id=2, name='李四', password='null'}
         * User{id=3, name='王五', password='null'}
         * User{id=4, name='麻子', password='null'}
         * User{id=5, name='李白', password='null'}
         * User{id=6, name='小明', password='null'}
         * 
         * 
         * 采用结果集映射后
         * 
         * [com.zyz.mybatis.mapper.UserMapper.getUsers]-==>  Preparing: select * from user
         * [com.zyz.mybatis.mapper.UserMapper.getUsers]-==> Parameters: 
         * [com.zyz.mybatis.mapper.UserMapper.getUsers]-<==      Total: 7
         * User{id=1, name='张三', password='123'}
         * User{id=2, name='李四', password='456'}
         * User{id=3, name='王五', password='789'}
         * User{id=4, name='麻子', password='321'}
         * User{id=5, name='李白', password='654'}
         * User{id=6, name='小明', password='987'}
         * User{id=7, name='小红', password='666'}
         *
         *
         **/
    }

其他接口，如何重复使用上面的那个映射呢？如下：

测试单元

  /**
     * @description: 查询 通过ID
     * @author: zhengyuzhu
     * @date: 2023/11/22 15:15
     **/
    @Test
    public void testDemo2(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);

        System.out.println(user);
        sqlSession.close();

        /**
         * 输出如下：
         *
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==>  Preparing: select * from user where id=?
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==> Parameters: 1(Integer)
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-<==      Total: 1
         * User{id=1, name='张三', password='null'}
         * 
         * 复用结果集映射
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==>  Preparing: select * from user where id=?
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==> Parameters: 1(Integer)
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-<==      Total: 1
         * User{id=1, name='张三', password='123'}
         *
         **/
    }

8.2.2 查询

如果实体类字段 和 数据库字段不一致 需要进行接口 结果集映射

  @Results(id = "UserMap",value = {
            @Result(id=true,column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(column = "pwd",property = "password")
    })

这里添加一个 id 可以达到复用的效果。
其它接口使用结果集的时候，可以直接用： @ResultMap(value = (“UserMap”))
接口

  /**
     * @description: 查询用户
     * @author: zhengyuzhu
     * @date: 2023/11/22 14:40
     * @return: java.util.List
     **/
    @Select("select * from user")
    @Results(id = "UserMap",value = {
            @Result(id=true,column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(column = "pwd",property = "password")
    })
    List getUsers();

    /**
     * @description: 查询用户 通过 用户ID 方法存在多个参数，所有参数前面必须加上@Param("id")注解
     * @author: zhengyuzhu
     * @date: 2023/11/22 15:12
     * @param: id
     * @return: com.zyz.mybatis.entity.User
     **/
    @Select("select * from user where id=#{id}")
    @ResultMap(value = ("UserMap"))
    User getUserById(@Param("id") int id);

测试单元

/**
 * @description: 注解开发 查询
 * @author: zhengyuzhu
 * @date: 2023/11/22 14:41
 **/
@Test
public void testDemo1(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List users = mapper.getUsers();

    for (User user : users) {
        System.out.println(user);
    }

    sqlSession.close();

    /**
     * 输出如下：
     *
     * [com.zyz.mybatis.mapper.UserMapper.getUsers]-==>  Preparing: select * from user
     * [com.zyz.mybatis.mapper.UserMapper.getUsers]-==> Parameters:
     * [com.zyz.mybatis.mapper.UserMapper.getUsers]-<==      Total: 6
     * User{id=1, name='张三', password='null'}
     * User{id=2, name='李四', password='null'}
     * User{id=3, name='王五', password='null'}
     * User{id=4, name='麻子', password='null'}
     * User{id=5, name='李白', password='null'}
     * User{id=6, name='小明', password='null'}
     *
     *
     * 采用结果集映射后
     *
     * [com.zyz.mybatis.mapper.UserMapper.getUsers]-==>  Preparing: select * from user
     * [com.zyz.mybatis.mapper.UserMapper.getUsers]-==> Parameters:
     * [com.zyz.mybatis.mapper.UserMapper.getUsers]-<==      Total: 7
     * User{id=1, name='张三', password='123'}
     * User{id=2, name='李四', password='456'}
     * User{id=3, name='王五', password='789'}
     * User{id=4, name='麻子', password='321'}
     * User{id=5, name='李白', password='654'}
     * User{id=6, name='小明', password='987'}
     * User{id=7, name='小红', password='666'}
     *
     *
     **/
}

/**
 * @description: 查询 通过ID
 * @author: zhengyuzhu
 * @date: 2023/11/22 15:15
 **/
@Test
public void testDemo2(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.getUserById(1);//查询

    System.out.println(user);
    sqlSession.close();

    /**
     * 输出如下：
     *
     * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==>  Preparing: select * from user where id=?
     * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==> Parameters: 1(Integer)
     * [com.zyz.mybatis.mapper.UserMapper.getUserById]-<==      Total: 1
     * User{id=1, name='张三', password='null'}
     *
     * 复用结果集映射
     * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==>  Preparing: select * from user where id=?
     * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==> Parameters: 1(Integer)
     * [com.zyz.mybatis.mapper.UserMapper.getUserById]-<==      Total: 1
     * User{id=1, name='张三', password='123'}
     *
     **/
}

8.2.3 添加

接口

/**
 * @description: 添加用户
 * @author: zhengyuzhu
 * @date: 2023/11/22 15:11
 * @param: user
 * @return: int
 **/
@Insert("insert into user (id,name,pwd) values(#{id},#{name},#{password})")
int addUser(User user);

测试单元

  /**
     * @description: 添加用户
     * @author: zhengyuzhu
     * @date: 2023/11/22 15:15
     **/
    @Test
    public void testDemo3(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setId(8);
        user.setName("小青");
        user.setPassword("888");
        mapper.addUser(user);//添加
        User userRs = mapper.getUserById(8);
        System.out.println("新添加用户 : " + userRs);
        sqlSession.close();

        /**
         * 输出如下：
         *
         * [com.zyz.mybatis.mapper.UserMapper.addUser]-==>  Preparing: insert into user (id,name,pwd) values(?,?,?)
         * [com.zyz.mybatis.mapper.UserMapper.addUser]-==> Parameters: 8(Integer), 小青(String), 888(String)
         * [com.zyz.mybatis.mapper.UserMapper.addUser]-<==    Updates: 1
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==>  Preparing: select * from user where id=?
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==> Parameters: 8(Integer)
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-<==      Total: 1
         * 新添加用户 : User{id=8, name='小青', password='888'}
         *
         **/
    }

8.2.4 修改

接口

/**
 * @description: 修改用户
 * @author: zhengyuzhu
 * @date: 2023/11/22 15:11
 * @param: user
 * @return: int
 **/
@Update("update user set name=#{name},pwd=#{password} where id=#{id}")
int updateUser(User user);

测试单元

  /**
     * @description: 修改用户
     * @author: zhengyuzhu
     * @date: 2023/11/22 15:15
     **/
    @Test
    public void testDemo4(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User userRs = mapper.getUserById(8);
        System.out.println("未修改前用户信息 : " + userRs);

        User user = new User();
        user.setId(8);
        user.setName("小紫");
        user.setPassword("999");
        mapper.updateUser(user);//修改

        User userRss = mapper.getUserById(8);
        System.out.println("修改后用户信息 : " + userRss);

        sqlSession.close();

        /**
         * 输出如下：
         *
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==>  Preparing: select * from user where id=?
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==> Parameters: 8(Integer)
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-<==      Total: 1
         * 未修改前用户信息 : User{id=8, name='小青', password='888'}
         * [com.zyz.mybatis.mapper.UserMapper.updateUser]-==>  Preparing: update user set name=?,pwd=? where id=?
         * [com.zyz.mybatis.mapper.UserMapper.updateUser]-==> Parameters: 小紫(String), 999(String), 8(Integer)
         * [com.zyz.mybatis.mapper.UserMapper.updateUser]-<==    Updates: 1
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==>  Preparing: select * from user where id=?
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==> Parameters: 8(Integer)
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-<==      Total: 1
         * 修改后用户信息 : User{id=8, name='小紫', password='999'}
         *
         **/
    }

8.2.5 删除

接口

/**
 * @description:删除用户  可以通过@Param("") 给传递的参数 修改别名
 * @author: zhengyuzhu
 * @date: 2023/11/22 15:11
 * @param: id
 * @return: int
 **/
@Delete("delete from user where id = #{uid}")
int deleteUser(@Param("uid") int id);

测试单元

   /**
     * @description: 删除用户
     * @author: zhengyuzhu
     * @date: 2023/11/22 15:15
     **/
    @Test
    public void testDemo5(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User userRs = mapper.getUserById(8);
        System.out.println("删除前用户信息 : " + userRs);

        mapper.deleteUser(8);//删除

        User userRss = mapper.getUserById(8);
        System.out.println("删除后用户信息 : " + userRss);

        sqlSession.close();

        /**
         * 输出如下：
         *
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==>  Preparing: select * from user where id=?
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==> Parameters: 8(Integer)
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-<==      Total: 1
         * 删除前用户信息 : User{id=8, name='小紫', password='999'}
         * [com.zyz.mybatis.mapper.UserMapper.deleteUser]-==>  Preparing: delete from user where id = ?
         * [com.zyz.mybatis.mapper.UserMapper.deleteUser]-==> Parameters: 8(Integer)
         * [com.zyz.mybatis.mapper.UserMapper.deleteUser]-<==    Updates: 1
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==>  Preparing: select * from user where id=?
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-==> Parameters: 8(Integer)
         * [com.zyz.mybatis.mapper.UserMapper.getUserById]-<==      Total: 0
         * 删除后用户信息 : null
         *
         **/
    }

9、Lombok（偷懒的话可以使用）

使用步骤：

1. 在IDEA中安装Lombok插件！
2. 在项目pom.xml文件中导入Lombok的jar包

   
    
        org.projectlombok
        lombok
        1.18.10
    

3. 在实体类上加注解即可！

@Data
@AllArgsConstructor
@NoArgsConstructor

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows

说明：

@Data:无参构造、get、set、toString、hashCode、equals
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode
@ToString
@Getter and @Setter

10、多对一处理

多对一：
● 多个学生，对应一个老师
● 对于学生而言，关联–多个学生，关联一个老师【多对一】
● 对于老师而言，集合–一个老师，有很多个学生【一对多】

SQL 语句

CREATE TABLE `tb_teacher` (
	`id` INT(10) NOT NULL,
	`name` VARCHAR(30) DEFAULT NULL,
	PRIMARY KEY (`id`)
)ENGINE = INNODB DEFAULT CHARSET=utf8

INSERT INTO tb_teacher(`id`,`name`) VALUES (1,'玉小刚');

CREATE TABLE `tb_student` (
	`id` INT(10) NOT NULL,
	`name` VARCHAR(30) DEFAULT NULL,
	`tid` INT(10) DEFAULT NULL,
	PRIMARY KEY (`id`),
	KEY `fktid`(`tid`),
	CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
)ENGINE = INNODB DEFAULT CHARSET=utf8

INSERT INTO `tb_student`(`id`,`name`,`tid`) VALUES ('1','唐三','1');
INSERT INTO `tb_student`(`id`,`name`,`tid`) VALUES ('2','小舞','1');
INSERT INTO `tb_student`(`id`,`name`,`tid`) VALUES ('3','戴沐白','1');
INSERT INTO `tb_student`(`id`,`name`,`tid`) VALUES ('4','朱朱清','1');
INSERT INTO `tb_student`(`id`,`name`,`tid`) VALUES ('5','奥斯卡','1');
INSERT INTO `tb_student`(`id`,`name`,`tid`) VALUES ('6','宁荣荣','1');
INSERT INTO `tb_student`(`id`,`name`,`tid`) VALUES ('7','马红俊','1');
INSERT INTO `tb_student`(`id`,`name`,`tid`) VALUES ('8','白尘香','1');

测试环境搭建

1. 导入Lombok
2. 新建实体类Teacher，Student
3. mybatis核心配置文件修改
4. 建立Mapper接口
5. 建立Mapper.XML文件
6. 在核心配置文件中绑定注册我们的Mapper接口或者文件！【方式很多,随心选】
7. 测试查询是否能够成功！

1、导入Lombok

 
        org.projectlombok
        lombok
        1.18.10
    

2、实体类Teacher，Student

@Data                              //get，set
@NoArgsConstructor                 //无参构造
@AllArgsConstructor                //有参构造
public class Student {
    
    private Integer id;
    private String name;
    private Teacher teacher;
    
}

@Data                              //get，set
@NoArgsConstructor                 //无参构造
@AllArgsConstructor                //有参构造
public class Teacher {
    private Integer id;
    private String name;

}

3、mybatis 配置文件

4、mapper 接口

public interface StudentMapper {
    /**
     * @description: 查询学生
     * @author: zhengyuzhu
     * @date: 2023/11/22 22:27
     * @return: java.util.List
     **/
    List getStudent();


    /**
     * @description: 查询学生
     * @author: zhengyuzhu
     * @date: 2023/11/22 22:27
     * @return: java.util.List
     **/
    List getStudent2();

}

5、mapper.xml

    
    
        
        
        
        
        
            
            
        
    

    
    
        select s.id sid,s.name sname,t.name tname,s.tid tid
        from tb_student s
        join tb_teacher t
        on s.tid = t.id
    


    

    
        select *  from tb_student;
    

    
        select * from tb_teacher where id = #{tid};
    

    
    
        
        
        
    

6、测试单元

/**
 * @description: 1、按照结果集嵌套处理  多对一
 * @author: zhengyuzhu
 * @date: 2023/11/22 23:07
 **/
@Test
public void testDemo1(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
    List studentList = studentMapper.getStudent();

    for(Student student : studentList){
        System.out.println(student);
    }

    sqlSession.close();

    /**
     * 输出如下：
     *
     * [com.zyz.mybatis.mapper.StudentMapper.getStudent]-==>  Preparing: select s.id sid,s.name sname,t.name tname,s.tid tid from tb_student s join tb_teacher t on s.tid = t.id
     * [com.zyz.mybatis.mapper.StudentMapper.getStudent]-==> Parameters:
     * [com.zyz.mybatis.mapper.StudentMapper.getStudent]-<==      Total: 8
     * Student{id=1, name='唐三', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=2, name='小舞', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=3, name='戴沐白', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=4, name='朱朱清', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=5, name='奥斯卡', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=6, name='宁荣荣', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=7, name='马红俊', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=8, name='白尘香', teacher=Teacher{id=1, name='玉小刚'}}
     *
     **/
}


/**
 * @description: 2、 按照查询嵌套处理  多对一
 * @author: zhengyuzhu
 * @date: 2023/11/22 23:07
 **/
@Test
public void testDemo2(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
    List studentList = studentMapper.getStudent2();

    for(Student student : studentList){
        System.out.println(student);
    }

    sqlSession.close();

    /**
     * 输出如下：
     *
     * [com.zyz.mybatis.mapper.StudentMapper.getStudent2]-==>  Preparing: select * from tb_student;
     * [com.zyz.mybatis.mapper.StudentMapper.getStudent2]-==> Parameters:
     * [com.zyz.mybatis.mapper.StudentMapper.getTeacher]-====>  Preparing: select * from tb_teacher where id = ?;
     * [com.zyz.mybatis.mapper.StudentMapper.getTeacher]-====> Parameters: 1(Integer)
     * [com.zyz.mybatis.mapper.StudentMapper.getTeacher]-<====      Total: 1
     * [com.zyz.mybatis.mapper.StudentMapper.getStudent2]-<==      Total: 8
     * Student{id=1, name='唐三', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=2, name='小舞', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=3, name='戴沐白', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=4, name='朱朱清', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=5, name='奥斯卡', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=6, name='宁荣荣', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=7, name='马红俊', teacher=Teacher{id=1, name='玉小刚'}}
     * Student{id=8, name='白尘香', teacher=Teacher{id=1, name='玉小刚'}}
     *
     **/
}

11、一对多处理

具体搭建过程同 多对一处理

1、实体类TeacherT，StudentT
同一个环境测试，实体类的字段有所不同。通过起别名的方式完善。

@Data                              //get，set
@NoArgsConstructor                 //无参构造
@AllArgsConstructor                //有参构造
public class StudentT {
    private Integer id;
    private String name;
    private Integer tid;

}

@Data                              //get，set
@NoArgsConstructor                 //无参构造
@AllArgsConstructor                //有参构造
public class TeacherT {
    private Integer id;
    private String name;
    private List studentTs;

}

2、mybatis 核心配置文件

3、mapper 接口

public interface TeacherMapper {
    
    /**
     * @description: 1、按照结果嵌套处理  多对一
     * @author: zhengyuzhu
     * @date: 2023/11/22 23:50  
     * @return: com.zyz.mybatis.vo.Teacher
     **/
    TeacherT getTeacherById(Integer id);

    /**
     * @description:  2、按照查询嵌套处理   一对多
     * @author: zhengyuzhu
     * @date: 2023/11/23 0:12
     * @param: id
     * @return: com.zyz.mybatis.vo.TeacherT
     **/
    TeacherT getTeacher2(Integer id);

}

4、mapper.xml

    
    
        select t.id id, t.name tname, s.id sid,s.name sname,s.tid tid
        from tb_teacher t
                 join tb_student s
                      on t.id = s.tid;
    

    
        
        
        
        
            
            
            
        
    

    
    
        select * from tb_teacher where id = #{tid}
    

    
        
        
    

    
        select * from  tb_student where tid = #{tid}
    

5、测试单元

  /**
     * @description: 1、 按结果嵌套查询  一对多
     * @author: zhengyuzhu
     * @date: 2023/11/22 23:07
     **/
    @Test
    public void testDemo3(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper teacherMapper = sqlSession.getMapper(TeacherMapper.class);
        TeacherT teacher = teacherMapper.getTeacherById(1);

        System.out.println(teacher);

        sqlSession.close();

        /**
         * 输出如下：
         *
         [org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 1486566962.
         [com.zyz.mybatis.mapper.TeacherMapper.getTeacherById]-==>  Preparing: select t.id id, t.name tname, s.id sid,s.name sname,s.tid tid from tb_teacher t join tb_student s on t.id = s.tid;
         [com.zyz.mybatis.mapper.TeacherMapper.getTeacherById]-==> Parameters:
         [com.zyz.mybatis.mapper.TeacherMapper.getTeacherById]-<==      Total: 8
         TeacherT(id=1, name=玉小刚, studentTs=[
                                               StudentT(id=1, name=唐三, tid=1),
                                               StudentT(id=2, name=小舞, tid=1),
                                               StudentT(id=3, name=戴沐白, tid=1),
                                               StudentT(id=4, name=朱朱清, tid=1),
                                               StudentT(id=5, name=奥斯卡, tid=1),
                                               StudentT(id=6, name=宁荣荣, tid=1),
                                               StudentT(id=7, name=马红俊, tid=1),
                                               StudentT(id=8, name=白尘香, tid=1)
                                               ])
         [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@589b3632]
         *
         **/
    }

    /**
     * @description: 2、 按照查询嵌套处理  一对多
     * @author: zhengyuzhu
     * @date: 2023/11/22 23:07
     **/
    @Test
    public void testDemo4(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper teacherMapper = sqlSession.getMapper(TeacherMapper.class);
        TeacherT teacher = teacherMapper.getTeacher2(1);

        System.out.println(teacher);

        sqlSession.close();

        /**
         * 输出如下：
         *
         [org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 1486566962.
         [com.zyz.mybatis.mapper.TeacherMapper.getTeacher2]-==>  Preparing: select * from tb_teacher where id = ?
         [com.zyz.mybatis.mapper.TeacherMapper.getTeacher2]-==> Parameters: 1(Integer)
         [com.zyz.mybatis.mapper.TeacherMapper.getStudentByTeacherId]-====>  Preparing: select * from tb_student where tid = ?
         [com.zyz.mybatis.mapper.TeacherMapper.getStudentByTeacherId]-====> Parameters: 1(Integer)
         [com.zyz.mybatis.mapper.TeacherMapper.getStudentByTeacherId]-<====      Total: 8
         [com.zyz.mybatis.mapper.TeacherMapper.getTeacher2]-<==      Total: 1
         TeacherT(id=1, name=玉小刚, studentTs=[
                                               StudentT(id=1, name=唐三, tid=1),
                                               StudentT(id=2, name=小舞, tid=1),
                                               StudentT(id=3, name=戴沐白, tid=1),
                                               StudentT(id=4, name=朱朱清, tid=1),
                                               StudentT(id=5, name=奥斯卡, tid=1),
                                               StudentT(id=6, name=宁荣荣, tid=1),
                                               StudentT(id=7, name=马红俊, tid=1),
                                               StudentT(id=8, name=白尘香, tid=1)
                                               ])
         [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@589b3632]
         *
         **/
    }

12、动态SQL

所谓的动态SQL，本质还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码
什么是动态SQL：动态SQL就是 指根据不同的条件生成不同的SQL语句
查询搜索的时候用的多

12.1 搭建环境

大致过程
● 1、创建数据表
● 2、新建实体类
● 3、编写实体类对应Mapper接口
● 4、和Mapper.XML文件
● 5、修改mybatis 核心配置文件
● 6、测试单元

1、创建数据表

CREATE TABLE `blog`  (
  `id` int(10) NOT NULL COMMENT '博客id',
  `title` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '博客标题',
  `author` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '博客作者',
  `create_time` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '创建时间',
  `views` int(30) NOT NULL COMMENT '浏览量'
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

2、创建 Blog 实体类

@Data                              //get，set
@NoArgsConstructor                 //无参构造
@AllArgsConstructor                //有参构造
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime; //属性名和字段名不一致
    private int views;
}

3、编写实体类对应Mapper接口

/**
 * @author zyz
 * @version 1.0
 * @data 2023/11/23 11:18
 * @Description:
 */
public interface BlogMapper {

    /**
     * @description: IF的使用 查询博客
     * @author: zhengyuzhu
     * @date: 2023/11/23 11:27
     * @param: map
     * @return: com.zyz.mybatis.entity.Blog
     **/
    Blog queryBlogIF(HashMap map);
    
    /**
     * @description: choose (when, otherwise)的使用 查询博客
     * @author: zhengyuzhu
     * @date: 2023/11/23 11:30
     * @param: map 
     * @return: com.zyz.mybatis.entity.Blog
     **/
    Blog queryBlogChoose(HashMap map);

    /**
     * @description: trim (where, set)的使用 查询
     * @author: zhengyuzhu
     * @date: 2023/11/23 11:34
     * @param: map 
     * @return: com.zyz.mybatis.entity.Blog
     **/
    Blog queryBlogIFTwo(HashMap map);

    /**
     * @description: trim (where, set)的使用 修改
     * @author: zhengyuzhu
     * @date: 2023/11/23 11:35
     * @param: map 
     **/
    void updateBlog(HashMap map);
    
    
    /**
     * @description: Foreach 的使用
     * @author: zhengyuzhu
     * @date: 2023/11/23 14:02
     * @param: map 
     * @return: java.util.List
     **/
    List queryBlogForeach(HashMap map);


    /**
     * @description: IF的使用 使用代码片段
     * @author: zhengyuzhu
     * @date: 2023/11/23 11:27
     * @param: map
     * @return: com.zyz.mybatis.entity.Blog
     **/
    Blog queryBlogIFThree(HashMap map);


}

4、修改mybatis 核心配置文件

具体的动态SQL 编写以及具体的 测试单元分成如下小节

12.2 IF

mapper.xml 文件
由于 实体类 和 数据库 字段不一致，这里进行了映射

  
    
        
        
        
        
        
        
    


    
    
        select * from blog where 1=1
        
            and title = #{title}
        
        
            and author = #{author}
        
    

测试单元

/**
 * @description: IF 测试
 * @author: zhengyuzhu
 * @date: 2023/11/23 12:46
 **/
@Test
public void testDemo1(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);
    HashMap blogMap = new HashMap<>();
    blogMap.put("title","张麻子娶亲");
    blogMap.put("author","张老头");

    Blog blog = blogMapper.queryBlogIF(blogMap);//查询

    System.out.println(blog);

    sqlSession.close();

    /**
     *
     *
     * blogMap.put("title","张麻子娶亲");
     * blogMap.put("author","张老头");
     *
     * 查询条件两个：输出如下：
     *
     * [org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 846947180.
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIF]-==>  Preparing: select * from blog where 1=1 and title = ? and author = ?
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIF]-==> Parameters: 张麻子娶亲(String), 张老头(String)
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIF]-<==      Total: 1
     * Blog(id=1, title=张麻子娶亲, author=张老头, createTime=2023-11-23 00:00:00, views=30)
     * [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@327b636c]
     *
     *
     * blogMap.put("title","张麻子娶亲");
     * 查询条件一个输出如下
     *
     * [org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 1172131546.
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIF]-==>  Preparing: select * from blog where 1=1 and title = ?
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIF]-==> Parameters: 张麻子娶亲(String)
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIF]-<==      Total: 1
     * Blog(id=1, title=张麻子娶亲, author=张老头, createTime=2023-11-23 00:00:00, views=30)
     * [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@45dd4eda]
     *
     *
     *
     *
      **/
}

12.3 choose (when, otherwise)

mapper.xml 文件
这里也进行了结果集映射，如上

    select * from blog
    
        
            
                title = #{title}
            
            
                and author = #{author}
            
            
                and views = #{views}
            
        
    

测试单元

   /**
     * @description: choose 测试 when  otherwise
     * @author: zhengyuzhu
     * @date: 2023/11/23 13:34
     **/
    @Test
    public void testDemo2(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);
        HashMap blogMap = new HashMap<>();
        // blogMap.put("title","张麻子娶亲");
        // blogMap.put("author","张老头");
        blogMap.put("views",30);

        Blog blog = blogMapper.queryBlogChoose(blogMap);

        System.out.println(blog);

        sqlSession.close();

        /**
         *
         * 1、多个参数不会拼接，哪个有值 用哪个
         *
         * blogMap.put("title","张麻子娶亲");
         * blogMap.put("author","张老头");
         *
         * 查询条件两个 但是拼接的时候 第一个有值，就不会在拼接接下来的数据
         *
         * [org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 846947180.
         * [com.zyz.mybatis.mapper.BlogMapper.queryBlogChoose]-==>  Preparing: select * from blog WHERE title = ?
         * [com.zyz.mybatis.mapper.BlogMapper.queryBlogChoose]-==> Parameters: 张麻子娶亲(String)
         * [com.zyz.mybatis.mapper.BlogMapper.queryBlogChoose]-<==      Total: 1
         * Blog(id=1, title=张麻子娶亲, author=张老头, createTime=2023-11-23 00:00:00, views=30)
         * [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@327b636c]
         *
         *
         * blogMap.put("author","张老头");
         * 2、查询条件一个输出如下
         *
         [org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 1172131546.
         [com.zyz.mybatis.mapper.BlogMapper.queryBlogChoose]-==>  Preparing: select * from blog WHERE author = ?
         [com.zyz.mybatis.mapper.BlogMapper.queryBlogChoose]-==> Parameters: 张老头(String)
         [com.zyz.mybatis.mapper.BlogMapper.queryBlogChoose]-<==      Total: 1
         Blog(id=1, title=张麻子娶亲, author=张老头, createTime=2023-11-23 00:00:00, views=30)
         [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@45dd4eda]
         *
         *
         *
         * 3、查询条件 一个 都不满足情况 otherwise
         * blogMap.put("views",30);
         *
         * [com.zyz.mybatis.mapper.BlogMapper.queryBlogChoose]-==>  Preparing: select * from blog WHERE views = ?
         * [com.zyz.mybatis.mapper.BlogMapper.queryBlogChoose]-==> Parameters: 30(Integer)
         * [com.zyz.mybatis.mapper.BlogMapper.queryBlogChoose]-<==      Total: 1
         * Blog(id=1, title=张麻子娶亲, author=张老头, createTime=2023-11-23 00:00:00, views=30)
         * [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@45dd4eda]
         *
         **/
    }

12.4 trim (where, set)

mapper.xml 文件
这里也进行了结果集映射，如上

   
    
        select * from blog
        
            
                and title = #{title}
            
            
                and author = #{author}
            
        

    

    
    
        update blog
        
            
                title = #{title},
            
            
                author = #{author}
            
        
        where id = #{id}
    

测试单元

/**
 * @description: trim (where, set)的使用 查询
 * @author: zhengyuzhu
 * @date: 2023/11/23 13:36
 **/
@Test
public void testDemo3(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);
    HashMap blogMap = new HashMap<>();
    blogMap.put("title","张麻子娶亲");
    blogMap.put("author","张老头");

    Blog blog = blogMapper.queryBlogIFTwo(blogMap);//查询

    System.out.println(blog);

    sqlSession.close();

    /**
     *
     *
     * blogMap.put("title","张麻子娶亲");
     * blogMap.put("author","张老头");
     * 查询条件两个：输出如下：
     *
     * [org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 846947180.
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIFTwo]-==>  Preparing: select * from blog WHERE title = ? and author = ?
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIFTwo]-==> Parameters: 张麻子娶亲(String), 张老头(String)
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIFTwo]-<==      Total: 1
     * Blog(id=1, title=张麻子娶亲, author=张老头, createTime=2023-11-23 00:00:00, views=30)
     * [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@327b636c]
     *
     *
     * blogMap.put("title","张麻子娶亲");
     * 查询条件一个输出如下
     *
     * [org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 1172131546.
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIF]-==>  Preparing: select * from blog where 1=1 and title = ?
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIF]-==> Parameters: 张麻子娶亲(String)
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIF]-<==      Total: 1
     * Blog(id=1, title=张麻子娶亲, author=张老头, createTime=2023-11-23 00:00:00, views=30)
     * [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@45dd4eda]
     *
     *
     *
     *
     **/
}

/**
 * @description: trim (where, set)的使用 修改
 * @author: zhengyuzhu
 * @date: 2023/11/23 13:36
 **/
@Test
public void testDemo4(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);
    HashMap blogMap = new HashMap<>();
    blogMap.put("title","张麻子娶亲");
    blogMap.put("author","张老头");

    Blog blog = blogMapper.queryBlogIFTwo(blogMap);//查询

    System.out.println("修改前的数据:" + blog);

    HashMap blogMapTwo = new HashMap<>();
    blogMapTwo.put("id",1);
    blogMapTwo.put("title","如何学号java ?");
    blogMapTwo.put("author","小明");
    Blog blog1 = new Blog();
    blog1.setAuthor("如何学号java ?");
    blog1.setAuthor("小明");
    blogMapper.updateBlog(blogMapTwo);//修改

    HashMap blogMap3 = new HashMap<>();
    blogMap3.put("title","如何学号java ?");

    Blog blog2 = blogMapper.queryBlogIFTwo(blogMap3);//查询
    System.out.println("修改后的数据:" + blog2);

    sqlSession.close();

    /**
     *
     *
     * blogMapTwo.put("id",1);
     * blogMapTwo.put("title","如何学号java ?");
     * blogMapTwo.put("author","小明");
     * 查询条件两个：输出如下：
     *
     * [org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 846947180.
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIFTwo]-==>  Preparing: select * from blog WHERE title = ? and author = ?
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIFTwo]-==> Parameters: 张麻子娶亲(String), 张老头(String)
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIFTwo]-<==      Total: 1
     * 修改前的数据:Blog(id=1, title=张麻子娶亲, author=张老头, createTime=2023-11-23 00:00:00, views=30)
     * [com.zyz.mybatis.mapper.BlogMapper.updateBlog]-==>  Preparing: update blog SET title = ?, author = ? where id = ?
     * [com.zyz.mybatis.mapper.BlogMapper.updateBlog]-==> Parameters: 如何学号java ?(String), 小明(String), 1(Integer)
     * [com.zyz.mybatis.mapper.BlogMapper.updateBlog]-<==    Updates: 1
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIFTwo]-==>  Preparing: select * from blog WHERE title = ?
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIFTwo]-==> Parameters: 如何学号java ?(String)
     * [com.zyz.mybatis.mapper.BlogMapper.queryBlogIFTwo]-<==      Total: 1
     * 修改后的数据:Blog(id=1, title=如何学号java ?, author=小明, createTime=2023-11-23 00:00:00, views=30)
     * [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@327b636c]
     *
     *
     *
     **/
}

12.5 foreach

更详细的资料参考：mybatis之foreach用法
foreach元素的属性主要有item，index，collection，open，separator，close。
● 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将会失效。 除了入参这种情况外，还有一种作为参数对象的某个字段的时候。举个例子：如果User有属性List ids。入参是User对象，那么这个collection = “ids”.如果User有属性Ids ids;其中Ids是个对象，Ids有个属性List id;入参是User对象，那么collection = “ids.id”
在使用foreach的时候最关键的也是最容易出错的就是collection属性，该属性是必须指定的，但是在不同情况下，该属性的值是不一样的，主要有一下3种情况：
● 如果传入的是单参数且参数类型是一个List的时候，collection属性值为list .
● 如果传入的是单参数且参数类型是一个array数组的时候，collection的属性值为array .
● 如果传入的参数是多个的时候，我们就需要把它们封装成一个Map了，当然单参数也可以封装成map，实际上如果你在传入参数的时候，在MyBatis里面也是会把它封装成一个Map的，map的key就是参数名，所以这个时候collection属性值就是传入的List或array对象在自己封装的map里面的key.
针对最后一条，我们来看一下官方说法：
注意 你可以将一个 List 实例或者数组作为参数对象传给 MyBatis，当你这么做的时候，MyBatis 会自动将它包装在一个 Map 中并以名称为键。List 实例将会以“list”作为键，而数组实例的键将是“array”。
所以，不管是多参数还是单参数的list,array类型，都可以封装为map进行传递。如果传递的是一个List，则mybatis会封装为一个list为key，list值为object的map，如果是array，则封装成一个array为key，array的值为object的map，如果自己封装呢，则colloection里放的是自己封装的map里的key值。

mapper.xml 文件
这里也进行了结果集映射

  
    
        select * from blog
        
            
                id = #{id}
            
        
    

测试单元

 /**
     * @description:  Foreach 的使用
     * @author: zhengyuzhu
     * @date: 2023/11/23 14:03
     **/
    @Test
    public void testDemo5(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);
        ArrayList