【重温版】MyBatis详解

快来打我* 2023-09-27 12:38 115阅读 0赞

#### 文章目录 ####

*  1.Mybatis简介
 *   *  1.MyBatis历史
     *  2.MyBatis特性
     *  3.MyBatis下载
     *  4.和其它持久化层技术对比
 *  2.搭建MyBatis
 *   *  1.开发环境
     *  2.创建maven工程
     *  3.创建MyBatis的核心配置文件
     *  4.创建mapper接口
     *  5.创建MyBatis的映射文件
     *  6.通过junit测试功能
     *  7.加入log4j日志功能
 *  3.核心配置文件详解
 *  4.默认的类型别名
 *  5.MyBatis的增删改查
 *   *  1.添加
     *  2.删除
     *  3.修改
     *  4.查询一个实体类对象
     *  5.查询集合
 *  6.MyBatis获取参数值的两种方式（重点）
 *   *  1.单个字面量类型的参数
     *  2.多个字面量类型的参数
     *  3.map集合类型的参数
     *  4.实体类类型的参数
     *  5.使用@Param标识参数
     *  6.总结
 *  7.MyBatis的各种查询功能
 *   *  1.查询一个实体类对象
     *  2.查询一个List集合
     *  3.查询单个数据
     *  4.查询一条数据为map集合
     *  5.查询多条数据为map集合
     *   *  1.方法一
         *  2.方法二
 *  8.特殊SQL的执行
 *   *  1.模糊查询
     *  2.批量删除
     *  3.动态设置表名
     *  4.添加功能获取自增的主键
 *  9.自定义映射resultMap
 *   *  1.resultMap处理字段和属性的映射关系
     *  2.多对一映射处理
     *   *  1.级联方式处理映射关系
         *  2.使用association处理映射关系
         *  3.分步查询
         *   *  1. 查询员工信息
             *  2. 查询部门信息
     *  3.一对多映射处理
     *   *  1.collection
         *  2.分步查询
         *   *  1. 查询部门信息
             *  2. 根据部门id查询部门中的所有员工
     *  4.延迟加载
 *  10.动态SQL
 *   *  1.if
     *  2.where
     *  3.trim
     *  4.choose、when、otherwise
     *  5.foreach
     *   *  1.批量删除
         *   *  1.方式一
             *  2.方式二
             *  3.方式三
         *  2.批量添加
     *  6.SQL片段
 *  11.MyBatis的缓存
 *   *  1.MyBatis的一级缓存
     *  2.MyBatis的二级缓存
     *  3.二级缓存的相关配置
     *  4.MyBatis缓存查询的顺序
     *  5.整合第三方缓存EHCache（了解）
     *   *  1.添加依赖
         *  2.各个jar包的功能
         *  3.创建EHCache的配置文件ehcache.xml
         *  4.设置二级缓存的类型
         *  5.加入logback日志
         *  6.EHCache配置文件说明
 *  12.MyBatis的逆向工程
 *   *  1.创建逆向工程的步骤
     *   *  1.添加依赖和插件
         *  2.创建MyBatis的核心配置文件
         *  3.创建逆向工程的配置文件
         *  4.执行MBG插件的generate目标
     *  2.QBC
     *   *  1.查询
         *  2.增改
 *  13.分页插件
 *   *  1.分页插件使用步骤
     *   *  1.添加依赖
         *  2.配置分页插件
     *  2.分页插件的使用
     *   *  1.开启分页功能
         *  2.分页相关数据
         *   *  1.方法一：直接输出
             *  2.方法二:使用PageInfo
             *  3.常用数据：

## 1.Mybatis简介 ##

### 1.MyBatis历史 ###

`MyBatis最初是Apache的一个开源项目iBatis`, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下，iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到Github

iBatis一词来源于`internet`和`abatis`的组合，是一个基于Java的`持久层框架`。iBatis提供的持久层框架`包括SQL Maps和Data Access Objects（DAO）`

### 2.MyBatis特性 ###

1.  MyBatis 是支持定`制化 SQL`、`存储过程`以及`高级映射`的优秀的`持久层框架`
2.  MyBatis `避免`了几乎所有的 `JDBC 代码`和`手动设置参数`以及`获取结果集`
3.  MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录
4.  MyBatis 是一个 `半自动`的ORM（Object Relation Mapping）框架

### 3.MyBatis下载 ###

[MyBatis下载地址][MyBatis]

### 4.和其它持久化层技术对比 ###

*  `JDBC`
    
     *  SQL 夹杂在Java代码中`耦合度高`，导致硬编码内伤
     *  维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
     *  `代码冗长，开发效率低`
 *  `Hibernate 和 JPA`
    
     *  `操作简便，开发效率高`
     *  程序中的长难复杂 SQL 需要绕过框架
     *  内部自动生产的 SQL，不容易做特殊优化
     *  `基于全映射的全自动框架`，大量字段的 POJO 进行部分映射时比较困难。
     *  `反射操作太多，导致数据库性能下降`
 *  `MyBatis`
    
     *  `轻量级，性能出色`
     *  SQL 和 Java 编码分开，功能边界清晰。Java代码专注业务、SQL语句专注数据
     *  开发效率稍逊于HIbernate，但是完全能够接受。

## 2.搭建MyBatis ##

### 1.开发环境 ###

*  IDE：idea 2021.3
 *  构建工具：maven 3.8.x
 *  MySQL版本：MySQL 8.x
 *  MyBatis版本：MyBatis 3.5.7

### 2.创建maven工程 ###

*  打包方式：jar
 *  引入依赖

<dependencies>
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.5.7</version>
            </dependency>
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.27</version>
            </dependency>
        </dependencies>

### 3.创建MyBatis的核心配置文件 ###

习惯上命名为`mybatis-config.xml`，这个文件名仅仅只是建议，并非强制要求。

`核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息`

`核心配置文件存放的位置是src/main/resources目录下`

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    
    <configuration>
    
    
      <environments default="development">
            <environment id="development">
                <transactionManager type="JDBC"/>
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                    <property name="username" value="root"/>
                    <property name="password" value="123456"/>
                </dataSource>
            </environment>
        </environments>
    
    
        <mappers>
            <mapper resource="org/mybatis/example/UserMapper.xml"/>
        </mappers>
    
    </configuration>

### 4.创建mapper接口 ###

> MyBatis中的mapper接口相当于以前的dao。但是区别在于，mapper仅仅是接口，我们不需要提供实现类

package com.kk.mapper;
    /**
     * @author : k
     * @Date : 2022/8/10
     * @Desc :
     *
     * Mybatis面向接口编程的两个一致
     * 1.映射文件的namespace要和*Mapper接口的全类名保持一致
     * 2.映射文件中sql语句的id要和*Mapper接口中的方法名保持一致
     */
    public interface UserMapper {
        
    
        //添加用户信息
        int insertUser();
    
    }

### 5.创建MyBatis的映射文件 ###

*  \`\`相关概念：ORM（Object Relationship Mapping）对象关系映射。 \`\`\`
    
     *  `对象：Java的实体类对象`
     *  关系：关系型数据库
     *  映射：二者之间的对应关系

<table> 
 <thead> 
  <tr> 
   <th>Java概念</th> 
   <th>数据库概念</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类</td> 
   <td>表</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>字段/列</td> 
  </tr> 
  <tr> 
   <td>对象</td> 
   <td>记录/行</td> 
  </tr> 
 </tbody> 
</table>

*  `映射文件的命名规则`
    
     *  `表所对应的实体类的类名+Mapper.xml`
     *  例如：表t\_user，映射的实体类为User，所对应的映射文件为UserMapper.xml
     *  因此一个映射文件对应一个实体类，对应一张表的操作
     *  MyBatis映射文件用于编写SQL，访问以及操作表中的数据
     *  MyBatis映射文件存放的位置是src/main/resources/mappers目录下
 *  `MyBatis中可以面向接口操作数据，要保证两个一致`
    
     *  `mapper接口的全类名和映射文件的命名空间（namespace）保持一致`
     *  mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致

<?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.kk.mapper.UserMapper">
        <insert id="insertUser">
            insert into user
            values (null, 'admin', '123456', 16, '男', '123@qq.com', null);
        </insert>
    </mapper>

`mybatis-config.xml`

### 6.通过junit测试功能 ###

*  SqlSession：代表Java程序和数据库之间的会话。（HttpSession是Java程序和浏览器之间的会话）
 *  SqlSessionFactory：是“生产”SqlSession的“工厂”
 *  工厂模式：如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产”我们需要的对象

@Test
        public void test1() throws IOException {
        
            //加载MyBatis的核心配置文件
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    
            //获取SqlSessionFactoryBuilder
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    
            //通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
    
            //获取sqlSession，此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务
            //SqlSession sqlSession = sqlSessionFactory.openSession();
    
            //创建SqlSession对象，此时通过SqlSession对象所操作的sql都会自动提交
            SqlSession sqlSession = sqlSessionFactory.openSession(true);
    
            //通过代理模式创建UserMapper接口的代理实现类对象
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    
            //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，
            //通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的SQL语句
            int result = userMapper.insertUser();
    
            //提交事务
            //sqlSession.commit();
    
            System.out.println("result:" + result);
    
        }

*  此时需要手动提交事务，如果要自动提交事务，则在获取sqlSession对象时，使用`SqlSession sqlSession = sqlSessionFactory.openSession(true);`，传入一个Boolean类型的参数，值为true，这样就可以自动提交

### 7.加入log4j日志功能 ###

1.  加入依赖
    
        
                <dependency>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                    <version>1.2.17</version>
                </dependency>
2.  加入log4j的配置文件
    
     *  log4j的配置文件名为log4j.xml，存放的位置是src/main/resources目录下
     *  日志的级别：FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试) 从左到右打印的内容越来越详细
    
        <?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
        <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
            <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
                <param name="Encoding" value="UTF-8" />
                <layout class="org.apache.log4j.PatternLayout">
        			<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
                </layout>
            </appender>
            <logger name="java.sql">
                <level value="debug" />
            </logger>
            <logger name="org.apache.ibatis">
                <level value="info" />
            </logger>
            <root>
                <level value="debug" />
                <appender-ref ref="STDOUT" />
            </root>
        </log4j:configuration>

日志級別:从左到右日志越来越低

*  fatal（致命）
 *  ERROR（錯誤）
 *  WARN（警告）
 *  INFO（信息）
 *  DEBUG（調試）

`从左到右打印的内容越来越详细`

## 3.核心配置文件详解 ##

`核心配置文件中的标签必须按照固定的顺序(有的标签可以不写，但顺序一定不能乱)：`

properties、settings、typeAliases、typeHandlers、objectFactory、objectWrapperFactory、reflectorFactory、plugins、environments、databaseIdProvider、mappers

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//MyBatis.org//DTD Config 3.0//EN"
            "http://MyBatis.org/dtd/MyBatis-3-config.dtd">
    <configuration>
        
        <properties resource="jdbc.properties"></properties>
        
        
        <settings>
            
            <setting name="mapUnderscoreToCamelCase" value="true"/>
            
            <setting name="lazyLoadingEnabled" value="true"/>
        </settings>
        
        
        
     	<typeAliases>
            
            
            
    
            
            <package name="com.kk.pojo"/>
        </typeAliases>
    
        
        
        
        
        <environments default="mysql_test">
            
            <environment id="mysql_test">
                
                <transactionManager type="JDBC"/>
                
                <dataSource type="POOLED">
                    
                    <property name="driver" value="${jdbc.driver}"/>
                    
                    <property name="url" value="${jdbc.url}"/>
                    
                    <property name="username" value="${jdbc.username}"/>
                    
                    <property name="password" value="${jdbc.password}"/>
                </dataSource>
            </environment>
        </environments>
        
        
        
        
        <mappers>
            
            
            <package name="com.atguigu.mybatis.mapper"/>
        </mappers>
    </configuration>

![在这里插入图片描述][5d04bc27db7848c781d6faad2300c8b0.png]

## 4.默认的类型别名 ##

## 5.MyBatis的增删改查 ##

> UserMapper.java

package com.kk.mapper;
    import com.kk.pojo.User;
    import java.util.List;
    
    /**
     * @author : k
     * @Date : 2022/8/10
     * @Desc :
     *
     * Mybatis面向接口编程的两个一致
     * 1.映射文件的namespace要和*Mapper接口的全类名保持一致
     * 2.映射文件中sql语句的id要和*Mapper接口中的方法名保持一致
     */
    public interface UserMapper {
        
    
        //添加用户信息
        int insertUser();
    
        //修改用户信息
        int updateUser();
    
        //删除用户信息
        int deleteUser();
    
        //根据id查询用户信息
        User getUserById();
    
        //查询所有的用户信息
        List<User> getAllUser();
    }

### 1.添加 ###

<insert id="insertUser">
            insert into user
            values (null, 'admin', '123456', 16, '男', '123@qq.com', null);
    </insert>

### 2.删除 ###

<delete id="deleteUser">
            delete
            from user
            where id = 3;
    </delete>

### 3.修改 ###

<update id="updateUser">
            update user
            set username = '管理员'
            where id = 8;
    </update>

### 4.查询一个实体类对象 ###

<select id="getUserById" resultType="com.kk.pojo.User">
            select *
            from user
            where id = 1;
    </select>

### 5.查询集合 ###

<select id="getAllUser" resultType="com.kk.pojo.User">
            select * from  user
    </select>

> 測試

package com.kk.test;
    
    import com.kk.mapper.UserMapper;
    import com.kk.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.Test;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.List;
    
    /**
     * @author : k
     * @Date : 2022/8/10
     * @Desc :
     */
    public class MybatisTest {
        
    
        @Test
        public void test1() throws IOException {
        
            //加载MyBatis的核心配置文件
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    
            //获取SqlSessionFactoryBuilder
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    
            //通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
    
            //获取sqlSession，此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务
            //SqlSession sqlSession = sqlSessionFactory.openSession();
    
            //创建SqlSession对象，此时通过SqlSession对象所操作的sql都会自动提交
            SqlSession sqlSession = sqlSessionFactory.openSession(true);
    
            //通过代理模式创建UserMapper接口的代理实现类对象
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    
            //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，
            //通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的SQL语句
            int result = userMapper.insertUser();
    
            //提交事务
            //sqlSession.commit();
    
    
            System.out.println("result:" + result);
    
    
        }
    
    
        @Test
        public void test2() throws IOException {
        
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
            SqlSession sqlSession = sqlSessionFactory.openSession(true);
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            int i = mapper.updateUser();
            System.out.println(i);
        }
    
        @Test
        public void test3() throws IOException {
        
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
            SqlSession sqlSession = sqlSessionFactory.openSession(true);
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            int i = mapper.deleteUser();
            System.out.println(i);
        }
    
        @Test
        public void test4() throws IOException {
        
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
            SqlSession sqlSession = sqlSessionFactory.openSession(true);
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            User user = mapper.getUserById();
            System.out.println(user);
        }
    
        @Test
        public void test5() throws IOException {
        
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
            SqlSession sqlSession = sqlSessionFactory.openSession(true);
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            List<User> userList = mapper.getAllUser();
            userList.forEach(user -> System.out.println(user));
    
        }
    
    
    }

*  `注意：`

1.  `查询的标签select必须设置属性resultType或resultMap，用于设置实体类和数据库表的映射关系`  
    \- resultType：自动映射，用于属性名和表中字段名一致的情况  
    \- resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况  
    2. 当查询的数据为多条时，不能使用实体类作为返回值，只能使用集合，否则会抛出异常TooManyResultsException；但是若查询的数据只有一条，可以使用实体类或集合作为返回值

## 6.MyBatis获取参数值的两种方式（重点） ##

*  `MyBatis获取参数值的两种方式：${} 和 #{}`
 *  $\{\}的本质就是`字符串拼接`
 *  \#\{\}的本质就是`占位符赋值`
 *  $\{\}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，`需要手动加单引号；`
 *  \#\{\}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号

### 1.单个字面量类型的参数 ###

*  若mapper接口中的方法参数为单个的字面量类型，此时可以使用$\{\}和\#\{\}以任意的名称（最好见名识意）获取参数的值，`注意${}需要手动加单引号`

<select id="getUserByUsername" resultType="com.kk.pojo.User">
            select *
            from user
            where username = #{username}
        </select>

`测试`

@Test
    public void test2() throws IOException {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserByUsername("管理员");
        System.out.println(user);
    }

--------------------

<select id="getUserByUsername" resultType="User">  
    	select * from t_user where username = '${username}'  
    </select>

### 2.多个字面量类型的参数 ###

*  若mapper接口中的方法参数为多个时，此时MyBatis会自动将这些参数放在一个map集合中
    
    1.  以arg0,arg1…为键，以参数为值；
    2.  以param1,param2…为键，以参数为值；
 *  `因此只需要通过\${}和#{}访问map集合的键就可以获取相对应的值`，`注意${}需要手动加单引号。`
 *  使用arg或者param都行，`要注意的是，arg是从arg0开始的，param是从param1开始的`

<select id="checkLogin" resultType="com.kk.pojo.User">
            select *
            from user
            where username = #{arg0}
              and password = #{arg1}
        </select>

`測試`

@Test
    public void test3() throws IOException {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.checkLogin("管理员","123456");
        System.out.println(user);
    }

--------------------

<select id="checkLogin" resultType="User">
    	select * from t_user where username = '${param1}' and password = '${param2}'
    </select>

### 3.map集合类型的参数 ###

*  若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，`将这些数据放在map中只需要通过\${}和#{}访问map集合的键就可以获取相对应的值，`注意$\{\}需要手动加单引号

<select id="checkLoginByMap" resultType="com.kk.pojo.User">
            select *
            from user
            where username = #{username}
              and password = #{password}
        </select>

@Test
        public void test4() throws IOException {
        
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            Map<String,Object> map = new HashMap<>();
            map.put("username","管理员");
            map.put("password","123456");
            User user = mapper.checkLoginByMap(map);
            System.out.println(user);
            
            
            //在map中 键分别为username、password
        }

### 4.实体类类型的参数 ###

*  若mapper接口中的方法`参数为实体类对象`时此时可以使用$\{\}和\#\{\}，`通过访问实体类对象中的属性名获取属性值`，注意$\{\}需要手动加单引号

<insert id="insertUser">
            insert into user
            values (null, #{username}, #{password}, #{age}, #{sex}, #{email}, null);
        </insert>

@Test
        public void test5() {
        
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            User user = new User(null, "大白", "123456", 10, "男", "dabai@qq.com", null);
            mapper.insertUser(user);
        }

### 5.使用@Param标识参数 ###

*  `可以通过@Param注解标识mapper接口中的方法参数，此时，会将这些参数放在map集合中`

1.  以@Param注解的value属性值为键，以参数为值；  
    2. 以param1,param2…为键，以参数为值；

*  只需要通过$\{\}和\#\{\}访问map集合的键就可以获取相对应的值，注意$\{\}需要手动加单引号

<select id="CheckLoginByParam" resultType="com.kk.pojo.User">
            select *
            from user
            where username = #{username}
              and password = #{password}
        </select>

@Test
        public void test6() {
        
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            User user = mapper.CheckLoginByParam("管理员", "123456");
            System.out.println(user);
        }

### 6.总结 ###

> 建议分成两种情况进行处理

1.  `实体类类型的参数`
2.  `使用@Param标识参数`

## 7.MyBatis的各种查询功能 ##

1.  如果查询出的数据只有一条，可以通过
    
    1.  实体类对象接收
    2.  List集合接收
    3.  Map集合接收，结果`{password=123456, sex=男, id=1, age=23, username=admin}`
2.  如果查询出的数据有多条，一定不能用实体类对象接收，会抛异常TooManyResultsException，可以通过
    
    1.  实体类类型的LIst集合接收
    2.  Map类型的LIst集合接收
    3.  在mapper接口的方法上添加@MapKey注解

### 1.查询一个实体类对象 ###

/**
     * 根据用户id查询用户信息
     * @param id
     * @return
     */
    User getUserById(@Param("id") Integer id);

<select id="getUserById" resultType="com.kk.pojo.User">
            select *
            from user
            where id = #{id}
        </select>

`測試`

@Test
    public void test7() {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        User user = mapper.getUserById(10);
        System.out.println(user);
    }

### 2.查询一个List集合 ###

/**
     * 查询所有用户信息
     * @return
     */
    List<User> getUserList();

<select id="getUserList" resultType="com.kk.pojo.User">
            select *
            from user
        </select>

`測試`

@Test
    public void test8() {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        List<User> userList = mapper.getUserList();
        userList.forEach(System.out::println);
    }

### 3.查询单个数据 ###

/**  
     * 查询用户的总记录数  
     * @return  
     * 在MyBatis中，对于Java中常用的类型都设置了类型别名  
     * 例如：java.lang.Integer-->int|integer  
     * 例如：int-->_int|_integer  
     * 例如：Map-->map,List-->list  
     */  
    int getCount();

<select id="getCount" resultType="Integer">
            select count(*)
            from user
        </select>

`測試`

@Test
    public void test9() {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        int count = mapper.getCount();
        System.out.println(count);
    }

### 4.查询一条数据为map集合 ###

/**  
     * 根据用户id查询用户信息为map集合  
     * @param id  
     * @return  
     */  
    Map<String, Object> getUserToMap(@Param("id") int id);

<select id="getUserByIdToMap" resultType="map">
            select *
            from user
            where id = #{id}
        </select>

`测试`

@Test
    public void test10() {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        Map<String, Object> map = mapper.getUserByIdToMap(10);
        System.out.println(map);
    }

### 5.查询多条数据为map集合 ###

#### 1.方法一 ####

/**  
     * 查询所有用户信息为map集合  
     * @return  
     * 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，此时可以将这些map放在一个list集合中获取  
     */  
    List<Map<String, Object>> getAllUserToMap();

<select id="getAllUserToMap" resultType="map">
            select *
            from user
        </select>

`测试`

@Test
    public void test11() {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        List<Map<String, Object>> mapList = mapper.getAllUserToMap();
        mapList.forEach(System.out::println);
    }

#### 2.方法二 ####

/**
         * 查询所有用户信息为map集合
         * @return
         * 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，
         * 并且最终要以一个map的方式返回数据，此时需要通过@MapKey注解设置map集合的键，值是每条数据所对应的map集合
         * 把数据的某一个字段作为将，数据作为值
         */
        @MapKey("id")
        Map<String, Object> getAllUserToMap2();

<select id="getAllUserToMap2" resultType="java.util.Map">
            select *
            from user
        </select>

`测试`

@Test
    public void test12() {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        Map<String, Object> userToMap2 = mapper.getAllUserToMap2();
        System.out.println(userToMap2);
    }

## 8.特殊SQL的执行 ##

### 1.模糊查询 ###

//根据用户名进行模糊查询
    List<User> getUserByLike(@Param("username") String username);

<select id="getUserByLike" resultType="com.kk.pojo.User">
            
            
            select * from user where username like "%"#{username}"%"
    </select>

*  其中`select * from t_user where username like "%"#{username}"%"`是最常用的

`測試`

@Test
    public void test13() {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
        List<User> userList = mapper.getUserByLike("管理");
        userList.forEach(System.out::println);
    }

### 2.批量删除 ###

*  只能使用$\{\}，如果使用\#\{\}，则解析后的sql语句为`delete from t_user where id in ('1,2,3')`，这样是将`1,2,3`看做是一个整体，只有id为`1,2,3`的数据会被删除。
 *  正确的语句应该是`delete from t_user where id in (1,2,3)`，或者`delete from t_user where id in ('1','2','3')`。

//根据id批量删除
    int deleteMore(@Param("ids") String ids);

<delete id="deleteMore">
            delete
            from user
            where id in (${id});
        </delete>

`測試`

@Test
        public void test14() {
        
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
            int i = mapper.deleteMore("6,7");
            System.out.println(i);
        }

> DEBUG 08-11 16:16:56,736 ==> Preparing: delete from user where id in (6,7); (BaseJdbcLogger.java:137)  
> DEBUG 08-11 16:16:56,762 > Parameters: (BaseJdbcLogger.java:137)  
> DEBUG 08-11 16:16:56,769 < Updates: 2 (BaseJdbcLogger.java:137)

### 3.动态设置表名 ###

*  只能使用$\{\}，因为表名不能加单引号

//查询指定表中的数据
    List<User> getUserByTable(@Param("tableName") String tableName);

<select id="getUserByTable" resultType="com.kk.pojo.User">
            select *
            from ${tableName}
        </select>

`測試`

@Test
    public void test15() {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
        List<User> userList = mapper.getUserByTable("user");
        userList.forEach(System.out::println);
    }

### 4.添加功能获取自增的主键 ###

*  使用场景
    
     *  t\_clazz(clazz\_id,clazz\_name)
     *  t\_student(student\_id,student\_name,clazz\_id)
    
    1.  添加班级信息
    2.  获取新添加的班级的id
    3.  为班级分配学生，即将某学生的班级id修改为新添加的班级的id
 *  在mapper.xml中设置两个属性
    
     *  useGeneratedKeys：设置使用自增的主键
    
     *  keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中

//添加用户信息
    void insertUser(User user);

<insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
            insert into user
            values (null, #{username}, #{password}, #{age}, #{sex}, #{email}, null)
        </insert>

`测试`

@Test
        public void test16() {
        
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
            User user = new User(null, "小白", "123456", 9, "男", "xiaobai@qq.com", null);
            mapper.insertUser(user);
            System.out.println(user);
        }
    
    /*User(id=11, username=小白, password=123456, age=9, sex=男, email=xiaobai@qq.com, perms=null)
    */

## 9.自定义映射resultMap ##

### 1.resultMap处理字段和属性的映射关系 ###

*  resultMap：设置自定义映射
    
     *  属性：
        
         *  id：表示自定义映射的唯一标识，不能重复
         *  type：查询的数据要`映射的实体类的类型`
     *  子标签：
        
         *  id：设置`主键`的映射关系
         *  result：设置`普通字段`的映射关系
         *  子标签属性：
            
             *  property：设置映射关系中`实体类中的属性名`
             *  column：设置映射关系中(数据库)`表中的字段名`
 *  若字段名和实体类中的属性名不一致，则可以通过resultMap设置自定义映射，即使字段名和属性名一致的属性也要映射，也就是全部属性都要列出来

<resultMap id="empResultMap" type="Emp">
            <id property="eid" column="eid"/>
            <result property="empName" column="emp_name"/>
            <result property="age" column="age"/>
            <result property="sex" column="sex"/>
            <result property="email" column="email"/>
        </resultMap>
    
        <select id="getAllEmp" resultMap="empResultMap">
            select * from t_emp
        </select>

*  若字段名和实体类中的属性名不一致，但是字段名符合数据库的规则（使用 \_ ），实体类中的属性名符合Java的规则（使用驼峰）。此时也可通过以下两种方式处理字段名和实体类中的属性的映射关系
    
    1.  可以通过为字段起别名的方式，保证和实体类中的属性名保持一致
        
            
            <select id="getAllEmp" resultType="Emp">
            	select eid,emp_name empName,age,sex,email from t_emp
            </select>
    2.  可以在MyBatis的核心配置文件中的`setting`标签中，设置一个全局配置信息mapUnderscoreToCamelCase，可以在查询表中数据时，自动将 \_ 类型的字段名转换为驼峰，例如：字段名user\_name，设置为mapUnderscoreToCamelCase，此时字段名就会转换为userName。核心配置文件详解
    
        ```xml
        
            <settings>
                <setting name="mapUnderscoreToCamelCase" value="true"/>
            </settings>
        ```

### 2.多对一映射处理 ###

> 查询员工信息以及员工所对应的部门信息

package com.kk.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @author : k
     * @Date : 2022/8/11
     * @Desc :
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Emp {
        
    
        private Integer eid;
        private String empName;  
        private Integer age;
        private String sex;
        private String email;
        private Dept dept;
    
    }

#### 1.级联方式处理映射关系 ####

<resultMap id="empAndDeptResultMapOne" type="Emp">
            <id property="eid" column="eid"/>
            <result property="empName" column="emp_name"/>
            <result property="age" column="age"/>
            <result property="sex" column="sex"/>
            <result property="email" column="email"/>
            <result property="dept.did" column="did"/>
            <result property="dept.deptName" column="dept_name"/>
        </resultMap>
    
        <select id="getEmpAndDept" resultMap="empAndDeptResultMapOne">
            select *
            from t_emp
                     left join t_dept on t_emp.did = t_dept.did
            where t_emp.eid = #{eid}
        </select>

#### 2.使用association处理映射关系 ####

*  association：处理多对一的映射关系
 *  property：需要处理多对的映射关系的`属性名`
 *  javaType：`该属性的类型`

<resultMap id="empAndDeptResultMapTwo" type="Emp">
            <id property="eid" column="eid"/>
            <result property="empName" column="emp_name"/>
            <result property="age" column="age"/>
            <result property="sex" column="sex"/>
            <result property="email" column="email"/>
            <association property="dept" javaType="Dept">
                <id property="did" column="did"/>
                <result property="deptName" column="dept_name"/>
            </association>
        </resultMap>
    
        <select id="getEmpAndDept" resultMap="empAndDeptResultMapTwo">
            select *
            from t_emp
                     left join t_dept on t_emp.did = t_dept.did
            where t_emp.eid = #{eid}
        </select>

#### 3.分步查询 ####

##### 1. 查询员工信息 #####

*  select：设置分布查询的sql的唯一标识`（namespace.SQLId或mapper接口的全类名.方法名）`
 *  column：`设置分步查询的条件`

//EmpMapper
    /**
     * 通过分步查询，员工及所对应的部门信息
     * 分步查询第一步：查询员工信息
     */
    Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);

<resultMap id="empAndDeptByStepResultMap" type="Emp">
            <id property="eid" column="eid"/>
            <result property="empName" column="emp_name"/>
            <result property="age" column="age"/>
            <result property="sex" column="sex"/>
            <result property="email" column="email"/>
            <association property="dept"
                         select="com.kk.mapper.DeptMapper.getEmpAndDeptByStepTwo" 
                         column="did"/>
        </resultMap>
        
        <select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap">
            select *
            from t_emp
            where eid = #{eid}
        </select>

##### 2. 查询部门信息 #####

//DeptMapper
    /**
     * 通过分步查询，员工及所对应的部门信息
     * 分步查询第二步：通过did查询员工对应的部门信息
     */
    Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);

<resultMap id="EmpAndDeptByStepTwoResultMap" type="Dept">
    	<id property="did" column="did"></id>
    	<result property="deptName" column="dept_name"></result>
    </resultMap>
     
        <select id="getEmpAndDeptByStepTwo" resultType="EmpAndDeptByStepTwoResultMap">
            select *
            from t_dept
            where did = #{did}
        </select>

> DEBUG 08-11 21:03:05,819 ==> Preparing: select \* from t\_emp where eid = ? (BaseJdbcLogger.java:137)  
> DEBUG 08-11 21:03:05,855 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:137)  
> DEBUG 08-11 21:03:05,874 ==> Preparing: select \* from t\_dept where did = ? (BaseJdbcLogger.java:137)  
> DEBUG 08-11 21:03:05,875 > Parameters: 1(Integer) (BaseJdbcLogger.java:137)  
> DEBUG 08-11 21:03:05,878 < Total: 1 (BaseJdbcLogger.java:137)  
> DEBUG 08-11 21:03:05,880 < Total: 1 (BaseJdbcLogger.java:137)
> 
> Emp(eid=1, empName=张三, age=16, sex=男, email=123@qq.com, dept=Dept(did=1, deptName=A))

### 3.一对多映射处理 ###

package com.kk.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.util.List;
    
    /**
     * @author : k
     * @Date : 2022/8/11
     * @Desc :
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Dept {
        
        private Integer did;
        private String deptName;
        private List<Emp> emps;
    }

#### 1.collection ####

*  collection：`用来处理一对多的映射关系`
 *  ofType：`表示该属性对应的集合中存储的数据的类型`

`即属性emp对应的集合中存储的数据类型是Emp`

//collection來查詢部门及对应的所有员工信息
    Dept getDeptAndEmp(@Param("did") Integer did);

<resultMap id="DeptAndEmpResultMap" type="Dept">
            <id property="did" column="did"/>
            <result property="deptName" column="dept_name"/>
            <collection property="emps" ofType="Emp">
                <id property="eid" column="edi"/>
                <result property="empName" column="emp_name"/>
                <result property="age" column="age"/>
                <result property="sex" column="sex"/>
                <result property="email" column="email"/>
            </collection>
        </resultMap>
    
    
        
        <select id="getDeptAndEmp" resultMap="DeptAndEmpResultMap">
            select *
            from t_dept
                     left join t_emp on t_dept.did = t_emp.did
            where t_dept.did = #{did}
        </select>

`测试`

@Test
    public void test7() {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
        Dept dept = mapper.getDeptAndEmp(1);
        System.out.println(dept);
    }

#### 2.分步查询 ####

##### 1. 查询部门信息 #####

//DeptMapper
    /**
     * 通过分步查询，查询部门及对应的所有员工信息
     * 分步查询第一步：查询部门信息
     */
    Dept getDeptAndEmpByStepOne(@Param("did") Integer did);

<resultMap id="DeptAndEmpByStepOneResultMap" type="Dept">
            <id property="did" column="did"/>
            <result property="deptName" column="dept_name"/>
            <collection property="emps"
                        select="com.kk.mapper.EmpMapper.getDeptAndEmpByStepTwo"
                        column="did"/>
        </resultMap>
    
    
        
        <select id="getDeptAndEmpByStepOne" resultMap="DeptAndEmpByStepOneResultMap">
            select *
            from t_dept
            where did = #{did}
        </select>

##### 2. 根据部门id查询部门中的所有员工 #####

//EmpMapper
    /**
     * 通过分步查询，查询部门及对应的所有员工信息
     * 分步查询第二步：根据部门id查询部门中的所有员工
     */
    List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did);

<select id="getDeptAndEmpByStepTwo" resultType="Emp">
            select *
            from t_emp
            where did = #{did}
        </select>

### 4.延迟加载 ###

*  分步查询的优点：可以实现延迟加载，但是必须在核心配置文件中设置全局配置信息：
    
     *  lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载
     *  aggressiveLazyLoading：当开启时，任何方法的调用都会加载该对象的所有属性。 否则，每个属性会按需加载
 *  此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。此时可通过association和collection中的fetchType属性设置当前的分步查询是否使用延迟加载，fetchType=“lazy(延迟加载)|eager(立即加载)”

@Test
    public void getEmpAndDeptByStepOne() {
        
    	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    	Emp emp = mapper.getEmpAndDeptByStepOne(1);
    	System.out.println(emp.getEmpName());
    }

*  关闭延迟加载，两条SQL语句都运行了
 *  开启延迟加载，只运行获取emp的SQL语句

> DEBUG 08-11 21:27:53,903 ==> Preparing: select \* from t\_emp where eid = ? (BaseJdbcLogger.java:137)  
> DEBUG 08-11 21:27:53,929 > Parameters: 1(Integer) (BaseJdbcLogger.java:137)  
> DEBUG 08-11 21:27:54,004 < Total: 1 (BaseJdbcLogger.java:137)  
> 张三

--------------------

*  开启后，需要用到查询dept的时候才会调用相应的SQL语句

> DEBUG 08-11 21:29:33,455 ==> Preparing: select \* from t\_emp where eid = ? (BaseJdbcLogger.java:137)  
> DEBUG 08-11 21:29:33,476 > Parameters: 1(Integer) (BaseJdbcLogger.java:137)  
> DEBUG 08-11 21:29:33,535 < Total: 1 (BaseJdbcLogger.java:137)
> 
> 张三
> 
> DEBUG 08-11 21:29:33,536 ==> Preparing: select \* from t\_dept where did = ? (BaseJdbcLogger.java:137)  
> DEBUG 08-11 21:29:33,537 > Parameters: 1(Integer) (BaseJdbcLogger.java:137)  
> DEBUG 08-11 21:29:33,538 < Total: 1 (BaseJdbcLogger.java:137)  
> Dept(did=1, deptName=A, emps=null)

--------------------

*  fetchType：`当开启了全局的延迟加载之后，可以通过该属性手动控制延迟加载的效果，fetchType="lazy(延迟加载)|eager(立即加载)"`
    
    `設置局部延迟加载`
    
        <resultMap id="empAndDeptByStepResultMap" type="Emp">
                <id property="eid" column="eid"/>
                <result property="empName" column="emp_name"/>
                <result property="age" column="age"/>
                <result property="sex" column="sex"/>
                <result property="email" column="email"/>
                <association property="dept"
                             select="com.kk.mapper.DeptMapper.getEmpAndDeptByStepTwo"
                             column="did"
                             fetchType="lazy"/>
            </resultMap>

## 10.动态SQL ##

Mybatis框架的动态SQL技术是一种`根据特定条件动态拼装SQL语句的功能`，它存在的意义是`为了解决拼接SQL语句字符串时的痛点问题`

### 1.if ###

*  if标签可通过test属性（即传递过来的数据）的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之标签中的内容不会执行
 *  在where后面添加一个恒成立条件`1=1`
    
     *  这个恒成立条件并不会影响查询的结果
     *  这个`1=1`可以用来拼接`and`语句，例如：当empName为null时
        
         *  如果不加上恒成立条件，则SQL语句为`select * from t_emp where and age = ? and sex = ? and email = ?`，此时`where`会与`and`连用，SQL语句会报错
         *  如果加上一个恒成立条件，则SQL语句为`select * from t_emp where 1= 1 and age = ? and sex = ? and email = ?`，此时不报错

package com.kk.mapper;
    
    import com.kk.pojo.Emp;
    
    import java.util.List;
    
    /**
     * @author : k
     * @Date : 2022/8/11
     * @Desc :
     */
    public interface DynamicSqlMapper {
        
    
        //多条件查询
        List<Emp> getEmpByCondition(Emp emp);
    
    }

<select id="getEmpByCondition" resultType="com.kk.pojo.Emp">
            select *
            from t_emp
            where 1 = 1
    
            <if test="empName != null and empName !=''">
                and emp_name = #{empName}
            </if>
    
            <if test="age != null and age !=''">
                and age = #{age}
            </if>
    
            <if test="sex != null and sex !=''">
                and sex = #{sex}
            </if>
    
            <if test="email != null and email !=''">
                and email = #{email}
            </if>
        </select>

`测试`

@Test
    public void test8() {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
        Emp emp = new Emp(null, "张三", 16, "男", "123@qq.com", null);
        List<Emp> empList = mapper.getEmpByCondition(emp);
        empList.forEach(System.out::println);
    }

> DEBUG 08-11 22:19:47,358 ==> Preparing: select \* from t\_emp where 1 = 1 and emp\_name = ? and age = ? and sex = ? and email = ? (BaseJdbcLogger.java:137)  
> DEBUG 08-11 22:19:47,375 > Parameters: 张三(String), 16(Integer), 男(String), 123@qq.com(String) (BaseJdbcLogger.java:137)  
> DEBUG 08-11 22:19:47,416 < Total: 1 (BaseJdbcLogger.java:137)  
> Emp(eid=1, empName=张三, age=16, sex=男, email=123@qq.com, dept=null)

@Test
    public void test8() {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
        Emp emp = new Emp(null, "张三", null, "男", "123@qq.com", null);
        List<Emp> empList = mapper.getEmpByCondition(emp);
        empList.forEach(System.out::println);
    }

> DEBUG 08-11 22:15:00,286 ==> Preparing: select \* from t\_emp where 1 = 1 and emp\_name = ? and sex = ? and email = ? (BaseJdbcLogger.java:137)  
> DEBUG 08-11 22:15:00,315 > Parameters: 张三(String), 男(String), 123@qq.com(String) (BaseJdbcLogger.java:137)  
> DEBUG 08-11 22:15:00,353 < Total: 1 (BaseJdbcLogger.java:137)

### 2.where ###

*  where和if一般结合使用：
    
     *  若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字
     *  若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的and/or去掉

<select id="getEmpByCondition" resultType="com.kk.pojo.Emp">
            select *
            from t_emp
            <where>
                <if test="empName != null and empName !=''">
                    and emp_name = #{empName}
                </if>
    
                <if test="age != null and age !=''">
                    and age = #{age}
                </if>
    
                <if test="sex != null and sex !=''">
                    or sex = #{sex}
                </if>
    
                <if test="email != null and email !=''">
                    and email = #{email}
                </if>
            </where>
    
        </select>

`測試`

@Test
    public void test8() {
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
        Emp emp = new Emp(null, null, 16, "男", "123@qq.com", null);
        List<Emp> empList = mapper.getEmpByCondition(emp);
        empList.forEach(System.out::println);
    }

> DEBUG 08-11 22:23:30,495 ==> Preparing: select \* from t\_emp WHERE age = ? or sex = ? and email = ? (BaseJdbcLogger.java:137)  
> DEBUG 08-11 22:23:30,526 > Parameters: 16(Integer), 男(String), 123@qq.com(String) (BaseJdbcLogger.java:137)  
> DEBUG 08-11 22:23:30,557 < Total: 5 (BaseJdbcLogger.java:137)  
> Emp(eid=1, empName=张三, age=16, sex=男, email=123@qq.com, dept=null)  
> Emp(eid=2, empName=李四, age=20, sex=男, email=123@qq.com, dept=null)  
> Emp(eid=3, empName=王五, age=18, sex=男, email=123@qq.com, dept=null)  
> Emp(eid=4, empName=赵六, age=13, sex=男, email=123@qq.com, dept=null)  
> Emp(eid=5, empName=田七, age=17, sex=男, email=123@qq.com, dept=null)

*  `注意：where标签不能去掉条件后多余的and/or`
    
        
        <if test="empName != null and empName !=''">
        emp_name = #{empName} and
        </if>
        <if test="age != null and age !=''">
        	age = #{age}
        </if>

### 3.trim ###

*  `trim用于去掉或添加标签中的内容`
 *  常用属性
    
     *  prefix：在trim标签中的内容的`前面`添加某些内容
     *  suffix：在trim标签中的内容的`后面`添加某些内容
     *  prefixOverrides：在trim标签中的内容的`前面去掉`某些内容
     *  suffixOverrides：在trim标签中的内容的`后面去掉`某些内容
 *  `若trim中的标签都不满足条件，则trim标签没有任何效果`，也就是只剩下`select * from t_emp`

//多条件查询
    List<Emp> getEmpByConditionTwo(Emp emp);

<select id="getEmpByCondition" resultType="Emp">
    	select * from t_emp
    	<trim prefix="where" suffixOverrides="and|or">
    		<if test="empName != null and empName !=''">
    			emp_name = #{empName} and
    		</if>
    		<if test="age != null and age !=''">
    			age = #{age} and
    		</if>
    		<if test="sex != null and sex !=''">
    			sex = #{sex} or
    		</if>
    		<if test="email != null and email !=''">
    			email = #{email}
    		</if>
    	</trim>
    </select>

@Test
        public void test9() {
        
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
            Emp emp = new Emp(null, null, 16, "", "123@qq.com", null);
            List<Emp> empList = mapper.getEmpByConditionTwo(emp);
            empList.forEach(System.out::println);
        }

> DEBUG 08-11 22:31:14,637 ==> Preparing: select \* from t\_emp where age = ? and email = ? (BaseJdbcLogger.java:137)  
> DEBUG 08-11 22:31:14,676 > Parameters: 16(Integer), 123@qq.com(String) (BaseJdbcLogger.java:137)  
> DEBUG 08-11 22:31:14,714 < Total: 1 (BaseJdbcLogger.java:137)  
> Emp(eid=1, empName=张三, age=16, sex=男, email=123@qq.com, dept=null)

### 4.choose、when、otherwise ###

*  `choose、when、otherwise`相当于`if...else if..else`
 *  when至少要有一个，otherwise至多只有一个

//測試 choose、when、otherwise
        List<Emp> getEmpByChoose();

<select id="getEmpByChoose" resultType="com.kk.pojo.Emp">
            select * from t_emp
            <where>
                <choose>
                    <when test="empName != null and empName != ''">
                        emp_name = #{empName}
                    </when>
                    <when test="age != null and age != ''">
                        age = #{age}
                    </when>
                    <when test="sex != null and sex != ''">
                        sex = #{sex}
                    </when>
                    <when test="email != null and email != ''">
                        email = #{email}
                    </when>
                    <otherwise>
                        did = 1
                    </otherwise>
                </choose>
            </where>
        </select>

@Test
        public void test10() {
        
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
            Emp emp = new Emp(null, null, null, "", "", null);
            List<Emp> empList = mapper.getEmpByChoose(emp);
            empList.forEach(System.out::println);
        }

> DEBUG 08-11 22:43:12,399 ==> Preparing: select \* from t\_emp WHERE did = 1 (BaseJdbcLogger.java:137)  
> DEBUG 08-11 22:43:12,422 > Parameters: (BaseJdbcLogger.java:137)  
> DEBUG 08-11 22:43:12,451 < Total: 2 (BaseJdbcLogger.java:137)  
> Emp(eid=1, empName=张三, age=16, sex=男, email=123@qq.com, dept=null)  
> Emp(eid=4, empName=赵六, age=13, sex=男, email=123@qq.com, dept=null)

*  相当于`if a else if b else if c else d`，只会执行其中一个

### 5.foreach ###

*  属性：
    
     *  collection：设置要循环的数组或集合
     *  item：表示集合或数组中的每一个数据
     *  separator：设置循环体之间的分隔符，分隔符前后默认有一个空格，如`,`
     *  open：设置foreach标签中的内容的开始符
     *  close：设置foreach标签中的内容的结束符
    
    #### 1.批量删除 ####
    
    ##### 1.方式一 #####
    
        //通过数组实现批量删除
            int deleteMoreByArray(@Param("edis") Integer[] edis);
    
        
            <delete id="deleteMoreByArray">
                delete
                from t_emp
                where eid in
                (
                <foreach collection="edis" item="eid" separator=",">
                    #{eid}
                </foreach>
                )
            </delete>
    
    `测试`
    
        @Test
            public void test11() {
              
                SqlSession sqlSession = SqlSessionUtil.getSqlSession();
                DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
                mapper.deleteMoreByArray(new Integer[]{
              6,7,8});
            }
    
    > DEBUG 08-11 22:55:36,240 ==> Preparing: delete from t\_emp where eid in ( ? , ? , ? ) (BaseJdbcLogger.java:137)  
    > DEBUG 08-11 22:55:36,270 > Parameters: 6(Integer), 7(Integer), 8(Integer) (BaseJdbcLogger.java:137)  
    > DEBUG 08-11 22:55:36,275 < Updates: 3 (BaseJdbcLogger.java:137)
    
    ##### 2.方式二 #####
    
        //通过数组实现批量删除
        int deleteMoreByArray(Integer[] edis);
    
        
            <delete id="deleteMoreByArray">
                delete
                from t_emp
                where eid in
                <foreach collection="edis" item="eid" separator="," open="(" close=")">
                    #{eid}
                </foreach>
            </delete>
    
    `测试`
    
        @Test
            public void test11() {
              
                SqlSession sqlSession = SqlSessionUtil.getSqlSession();
                DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
                mapper.deleteMoreByArray(new Integer[]{
              6,7,8});
            }
    
    ##### 3.方式三 #####
    
        
        
        <delete id="deleteMoreByArray">
            delete
            from t_emp
            where eid in
            <foreach collection="edis" item="eid" separator="or" open="(" close=")">
                eid = #{eid}
            </foreach>
        </delete>
    
    #### 2.批量添加 ####
    
        //通过数组实现批量添加
        int insertMoreByList(@Param("emps") List<Emp> emps);
    
        
            <insert id="insertMoreByList">
                insert into t_emp
                values
                <foreach collection="emps" item="emp" separator=",">
                    (null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},null)
                </foreach>
            </insert>
    
    `測試`
    
        @Test
            public void test12() {
              
                SqlSession sqlSession = SqlSessionUtil.getSqlSession();
                DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
                Emp emp1 = new Emp(null,"a",1,"男","123@qq.com",null);
                Emp emp2 = new Emp(null,"b",1,"男","123@qq.com",null);
                Emp emp3 = new Emp(null,"c",1,"男","123@qq.com",null);
                //List<Emp> emps = Arrays.asList(emp1, emp2, emp3);
                List<Emp> emps = new ArrayList<>();
                emps.add(emp1);
                emps.add(emp2);
                emps.add(emp3);
                int result = mapper.insertMoreByList(emps);
                System.out.println(result);
            }

### 6.SQL片段 ###

*  sql片段，可以记录一段公共sql片段，在使用的地方通过include标签进行引入
 *  声明sql片段：`<sql>`标签

//多条件查询
    List<Emp> getEmpByCondition(Emp emp);

<sql id="empColumns">eid,emp_name,age,sex,email</sql>

*  引用sql片段：`<include>`标签

<select id="getEmpByCondition" resultType="com.kk.pojo.Emp">
            select <include refid="empColumns"/> from t_emp
            <where>
                <if test="empName != null and empName !=''">
                    and emp_name = #{empName}
                </if>
    
                <if test="age != null and age !=''">
                    and age = #{age}
                </if>
    
                <if test="sex != null and sex !=''">
                    or sex = #{sex}
                </if>
    
                <if test="email != null and email !=''">
                    and email = #{email}
                </if>
            </where>
        </select>

`測試`

@Test
        public void test8() {
        
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
            Emp emp = new Emp(null, null, 16, "男", "123@qq.com", null);
            List<Emp> empList = mapper.getEmpByCondition(emp);
            empList.forEach(System.out::println);
        }

## 11.MyBatis的缓存 ##

### 1.MyBatis的一级缓存 ###

*  `一级缓存是SqlSession级别的`，通过`同一个SqlSession查询的数据会被缓存`，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问
 *  `使一级缓存失效的四种情况：`

1.  `不同的`SqlSession`对应不同的一级缓存`  
    2. `同一个`SqlSession但是`查询条件不同`  
    3. `同一个`SqlSession`两次查询期间执行了任何一次增删改操作`  
    4. `同一个`SqlSession`两次查询期间手动清空了缓存`（sqlSession.clearCache();）

`CacheMapper`

package com.kk.mapper;
    
    import com.kk.pojo.Emp;
    import org.apache.ibatis.annotations.Param;
    
    /**
     * @author : k
     * @Date : 2022/8/12
     * @Desc :
     */
    public interface CacheMapper {
        
    
        Emp getEmpByEid(@Param("eid") Integer eid);
    
    }

`CacheMapper.xml`

<select id="getEmpByEid" resultType="com.kk.pojo.Emp">
            select *
            from t_emp
            where eid = #{eid}
        </select>

`測試`

@Test
    public void test1(){
        
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
        Emp emp1 = mapper.getEmpByEid(1);
        System.out.println(emp1);
        //sqlSession.clearCache();
        Emp emp2 = mapper.getEmpByEid(1);
        System.out.println(emp2);
    }

> (LoggingCache.java:60)  
> DEBUG 08-12 14:54:06,047 ==> Preparing: select \* from t\_emp where eid = ? (BaseJdbcLogger.java:137)  
> DEBUG 08-12 14:54:06,072 > Parameters: 1(Integer) (BaseJdbcLogger.java:137)  
> DEBUG 08-12 14:54:06,096 < Total: 1 (BaseJdbcLogger.java:137)  
> Emp(eid=1, empName=张三, age=16, sex=男, email=123@qq.com, dept=null)  
> (LoggingCache.java:60)  
> Emp(eid=1, empName=张三, age=16, sex=男, email=123@qq.com, dept=null)

### 2.MyBatis的二级缓存 ###

*  二级缓存是SqlSessionFactory级别，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取
 *  二级缓存开启的条件
    
    1.  在核心配置文件中，设置全局配置属性cacheEnabled=“true”，默认为true，不需要设置
    2.  在映射文件中设置标签
    3.  `二级缓存必须在SqlSession关闭或提交之后有效`
    4.  查询的数据所转换的实体类类型必须`实现序列化的接口` (implements Serializable)
 *  使二级缓存失效的情况：`两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效`

`CacheMapper.xml`

<cache/>
        
        <select id="getEmpByEid" resultType="com.kk.pojo.Emp">
            select *
            from t_emp
            where eid = #{eid}
        </select>

`測試`

@Test
    public void test2(){
        
        try {
        
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    
            SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
            SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
    
            CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
            System.out.println(mapper1.getEmpByEid(1));
            sqlSession1.close();
    
            CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
            System.out.println(mapper2.getEmpByEid(1));
            sqlSession2.close();
        } catch (IOException e) {
        
            e.printStackTrace();
        }
    }

> DEBUG 08-12 14:55:33,037 Cache Hit Ratio \[com.kk.mapper.CacheMapper\]: 0.0 (LoggingCache.java:60)  
> DEBUG 08-12 14:55:33,793 ==> Preparing: select \* from t\_emp where eid = ? (BaseJdbcLogger.java:137)  
> DEBUG 08-12 14:55:33,815 > Parameters: 1(Integer) (BaseJdbcLogger.java:137)  
> DEBUG 08-12 14:55:33,837 < Total: 1 (BaseJdbcLogger.java:137)  
> Emp(eid=1, empName=张三, age=16, sex=男, email=123@qq.com, dept=null)  
> WARN 08-12 14:55:33,852 As you are using functionality that deserializes object streams, it is recommended to define the JEP-290 serial filter. Please refer to https://docs.oracle.com/pls/topic/lookup?ctx=javase15&id=GUID-8296D8E8-2B93-4B9A-856E-0A65AF9B8C66 (SerialFilterChecker.java:46)  
> DEBUG 08-12 14:55:33,854 Cache Hit Ratio \[com.kk.mapper.CacheMapper\]: 0.5 (LoggingCache.java:60)  
> Emp(eid=1, empName=张三, age=16, sex=男, email=123@qq.com, dept=null)

### 3.二级缓存的相关配置 ###

*  在mapper配置文件中添加的cache标签可以设置一些属性
 *  eviction属性：缓存回收策略
    
     *  LRU（Least Recently Used） – `最近最少使用的：移除最长时间不被使用的对象。`
     *  FIFO（First in First out） – `先进先出：按对象进入缓存的顺序来移除它们。`
     *  SOFT – `软引用：移除基于垃圾回收器状态和软引用规则的对象。`
     *  WEAK – `弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。`
     *  `默认的是 LRU`
 *  flushInterval属性：刷新间隔，单位毫秒
    
     *  默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句（增删改）时刷新
 *  size属性：引用数目，正整数
    
     *  代表缓存最多可以存储多少个对象，太大容易导致内存溢出
 *  readOnly属性：只读，true/false
    
     *  true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
     *  false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false

### 4.MyBatis缓存查询的顺序 ###

*  先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用
 *  如果二级缓存没有命中，再查询一级缓存
 *  如果一级缓存也没有命中，则查询数据库
 *  `SqlSession关闭之后，一级缓存中的数据会写入二级缓存`

### 5.整合第三方缓存EHCache（了解） ###

#### 1.添加依赖 ####

<dependency>
    	<groupId>org.mybatis.caches</groupId>
    	<artifactId>mybatis-ehcache</artifactId>
    	<version>1.2.1</version>
    </dependency>
    
    <dependency>
    	<groupId>ch.qos.logback</groupId>
    	<artifactId>logback-classic</artifactId>
    	<version>1.2.3</version>
    </dependency>

#### 2.各个jar包的功能 ####

<table> 
 <thead> 
  <tr> 
   <th>jar包名称</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>mybatis-ehcache</td> 
   <td>Mybatis和EHCache的整合包</td> 
  </tr> 
  <tr> 
   <td>ehcache</td> 
   <td>EHCache核心包</td> 
  </tr> 
  <tr> 
   <td>slf4j-api</td> 
   <td>SLF4J日志门面包</td> 
  </tr> 
  <tr> 
   <td>logback-classic</td> 
   <td>支持SLF4J门面接口的一个具体实现</td> 
  </tr> 
 </tbody> 
</table>

#### 3.创建EHCache的配置文件ehcache.xml ####

*  名字必须叫`ehcache.xml`

<?xml version="1.0" encoding="utf-8" ?>
    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
        
        <diskStore path="D:\ehcache"/>
        <defaultCache
                maxElementsInMemory="1000"
                maxElementsOnDisk="10000000"
                eternal="false"
                overflowToDisk="true"
                timeToIdleSeconds="120"
                timeToLiveSeconds="120"
                diskExpiryThreadIntervalSeconds="120"
                memoryStoreEvictionPolicy="LRU"/>
    </ehcache>

#### 4.设置二级缓存的类型 ####

*  在xxxMapper.xml文件中设置二级缓存类型

#### 5.加入logback日志 ####

*  存在SLF4J时，作为简易日志的log4j将失效，此时我们需要借助SLF4J的具体实现logback来打印日志。创建logback的配置文件`logback.xml`，名字固定，不可改变

<?xml version="1.0" encoding="UTF-8"?>
    <configuration debug="true">
        
        <appender name="STDOUT"
                  class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                
                
                <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern>
            </encoder>
        </appender>
        
        
        <root level="DEBUG">
            
            <appender-ref ref="STDOUT" />
        </root>
        
        <logger name="com.atguigu.crowd.mapper" level="DEBUG"/>
    </configuration>

#### 6.EHCache配置文件说明 ####

<table> 
 <thead> 
  <tr> 
   <th>属性名</th> 
   <th>是否必须</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>maxElementsInMemory</td> 
   <td>是</td> 
   <td>在内存中缓存的element的最大数目</td> 
  </tr> 
  <tr> 
   <td>maxElementsOnDisk</td> 
   <td>是</td> 
   <td>在磁盘上缓存的element的最大数目，若是0表示无穷大</td> 
  </tr> 
  <tr> 
   <td>eternal</td> 
   <td>是</td> 
   <td>设定缓存的elements是否永远不过期。 如果为true，则缓存的数据始终有效， 如果为false那么还要根据timeToIdleSeconds、timeToLiveSeconds判断</td> 
  </tr> 
  <tr> 
   <td>overflowToDisk</td> 
   <td>是</td> 
   <td>设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上</td> 
  </tr> 
  <tr> 
   <td>timeToIdleSeconds</td> 
   <td>否</td> 
   <td>当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时， 这些数据便会删除，默认值是0,也就是可闲置时间无穷大</td> 
  </tr> 
  <tr> 
   <td>timeToLiveSeconds</td> 
   <td>否</td> 
   <td>缓存element的有效生命期，默认是0.,也就是element存活时间无穷大</td> 
  </tr> 
  <tr> 
   <td>diskSpoolBufferSizeMB</td> 
   <td>否</td> 
   <td>DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区</td> 
  </tr> 
  <tr> 
   <td>diskPersistent</td> 
   <td>否</td> 
   <td>在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false</td> 
  </tr> 
  <tr> 
   <td>diskExpiryThreadIntervalSeconds</td> 
   <td>否</td> 
   <td>磁盘缓存的清理线程运行间隔，默认是120秒。每个120s， 相应的线程会进行一次EhCache中数据的清理工作</td> 
  </tr> 
  <tr> 
   <td>memoryStoreEvictionPolicy</td> 
   <td>否</td> 
   <td>当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。 默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出</td> 
  </tr> 
 </tbody> 
</table>

## 12.MyBatis的逆向工程 ##

*  正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表。Hibernate是支持正向工程的
 *  逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成如下资源：
    
     *  Java实体类
     *  Mapper接口
     *  Mapper映射文件

### 1.创建逆向工程的步骤 ###

#### 1.添加依赖和插件 ####

<dependencies>
    	
    	<dependency>
    		<groupId>org.mybatis</groupId>
    		<artifactId>mybatis</artifactId>
    		<version>3.5.9</version>
    	</dependency>
    	
    	<dependency>
    		<groupId>junit</groupId>
    		<artifactId>junit</artifactId>
    		<version>4.13.2</version>
    		<scope>test</scope>
    	</dependency>
    	
    	<dependency>
    		<groupId>mysql</groupId>
    		<artifactId>mysql-connector-java</artifactId>
    		<version>8.0.27</version>
    	</dependency>
    	
    	<dependency>
    		<groupId>log4j</groupId>
    		<artifactId>log4j</artifactId>
    		<version>1.2.17</version>
    	</dependency>
    </dependencies>
    
    <build>
    	
    	<plugins>
    		
    		<plugin>
    			<groupId>org.mybatis.generator</groupId>
    			<artifactId>mybatis-generator-maven-plugin</artifactId>
    			<version>1.3.0</version>
    			
    			<dependencies>
    				
    				<dependency>
    					<groupId>org.mybatis.generator</groupId>
    					<artifactId>mybatis-generator-core</artifactId>
    					<version>1.3.2</version>
    				</dependency>
    				
    				<dependency>
    					<groupId>com.mchange</groupId>
    					<artifactId>c3p0</artifactId>
    					<version>0.9.2</version>
    				</dependency>
    				
    				<dependency>
    					<groupId>mysql</groupId>
    					<artifactId>mysql-connector-java</artifactId>
    					<version>8.0.27</version>
    				</dependency>
    			</dependencies>
    		</plugin>
    	</plugins>
    </build>

#### 2.创建MyBatis的核心配置文件 ####

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <properties resource="jdbc.properties"/>
        <typeAliases>
            <package name=""/>
        </typeAliases>
        <environments default="development">
            <environment id="development">
                <transactionManager type="JDBC"/>
                <dataSource type="POOLED">
                    <property name="driver" value="${jdbc.driver}"/>
                    <property name="url" value="${jdbc.url}"/>
                    <property name="username" value="${jdbc.username}"/>
                    <property name="password" value="${jdbc.password}"/>
                </dataSource>
            </environment>
        </environments>
        <mappers>
            <package name=""/>
        </mappers>
    </configuration>

#### 3.创建逆向工程的配置文件 ####

*  文件名必须是：`generatorConfig.xml`

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE generatorConfiguration
            PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
            "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
    <generatorConfiguration>
        
        <context id="DB2Tables" targetRuntime="MyBatis3Simple">
            
            <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                            connectionURL="jdbc:mysql://localhost:3306/mybatis"
                            userId="root"
                            password="123456">
            </jdbcConnection>
    
            
            <javaModelGenerator targetPackage="com.kk.pojo" targetProject=".\src\main\java">
                <property name="enableSubPackages" value="true" />
                <property name="trimStrings" value="true" />
            </javaModelGenerator>
    
            
            <sqlMapGenerator targetPackage="com.kk.mapper"
                             targetProject=".\src\main\resources">
                <property name="enableSubPackages" value="true" />
            </sqlMapGenerator>
    
            
            <javaClientGenerator type="XMLMAPPER"
                                 targetPackage="com.kk.mapper" targetProject=".\src\main\java">
                <property name="enableSubPackages" value="true" />
            </javaClientGenerator>
    
            
            
            
            <table tableName="t_emp" domainObjectName="Emp"/>
            <table tableName="t_dept" domainObjectName="Dept"/>
    
            
        </context>
    </generatorConfiguration>

#### 4.执行MBG插件的generate目标 ####

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SB2R87HY-1668236463470)(C:\\Users\\30666\\AppData\\Roaming\\Typora\\typora-user-images\\image-20220812152249636.png)\]][img-SB2R87HY-1668236463470_C_Users_30666_AppData_Roaming_Typora_typora-user-images_image-20220812152249636.png]

*  如果出现报错：`Exception getting JDBC Driver`，可能是pom.xml中，数据库驱动配置错误
    
     *  dependency中的驱动
     *  mybatis-generator-maven-plugin插件中的驱动\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Dj1FxC6F-1668236463471)(Resources/插件中的驱动.png)\]
     *  两者的驱动版本应该相同
 *  执行结果`BUILD SUCCESS`

### 2.QBC ###

#### 1.查询 ####

*  `selectByExample`：按条件查询，需要传入一个example对象或者null；如果传入一个null，则表示没有条件，也就是查询所有数据
 *  `example.createCriteria().xxx`：创建条件对象，通过andXXX方法为SQL添加查询添加，每个条件之间是and关系
 *  `example.or().xxx`：将之前添加的条件通过or拼接其他条件  
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6mQGUMWP-1668236463472)(Resources/example的方法.png)\]

@Test public void testMBG() throws IOException {
        
    	InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    	SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    	SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
    	SqlSession sqlSession = sqlSessionFactory.openSession(true);
    	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    	EmpExample example = new EmpExample();
    	//名字为张三，且年龄大于等于20
    	example.createCriteria().andEmpNameEqualTo("张三").andAgeGreaterThanOrEqualTo(20);
    	//或者did不为空
    	example.or().andDidIsNotNull();
    	List<Emp> emps = mapper.selectByExample(example);
    	emps.forEach(System.out::println);
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GjonGCo2-1668236463472)(Resources/example测试结果.png)\]

#### 2.增改 ####

*  `updateByPrimaryKey`：通过主键进行数据修改，如果某一个值为null，也会将对应的字段改为null
    
     *  `mapper.updateByPrimaryKey(new Emp(1,"admin",22,null,"456@qq.com",3));`
 *  `updateByPrimaryKeySelective()`：通过主键进行选择性数据修改，如果某个值为null，则不修改这个字段
    
     *  `mapper.updateByPrimaryKeySelective(new Emp(2,"admin2",22,null,"456@qq.com",3));`

## 13.分页插件 ##

### 1.分页插件使用步骤 ###

#### 1.添加依赖 ####

<dependency>
    	<groupId>com.github.pagehelper</groupId>
    	<artifactId>pagehelper</artifactId>
    	<version>5.2.0</version>
    </dependency>

#### 2.配置分页插件 ####

*  在MyBatis的核心配置文件（mybatis-config.xml）中配置插件

### 2.分页插件的使用 ###

#### 1.开启分页功能 ####

*  在查询功能之前使用`PageHelper.startPage(int pageNum, int pageSize)`开启分页功能
    
     *  pageNum：当前页的页码
     *  pageSize：每页显示的条数

/**
         * limit index,pageSize
         * index：当前页的起始索引
         * pageNum：当前页的页码
         * pageSize：每页显示的条数
         * index = (pageNum-1)*pageSize
         */
    
        @Test
        public void test() {
        
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
            //访问第一页，每页四条数据
            PageHelper.startPage(1, 4);
            List<Emp> emps = mapper.selectByExample(null);
            //在查询到List集合后，打印分页数据
            System.out.println(emps);
    
        }

Page{
        count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=5, pages=2, reasonable=false, pageSizeZero=false}[Emp{
        eid=1, empName='李晓晓', age=10, sex='女', email='123@qq.com', did=1}, Emp{
        eid=2, empName='李四', age=20, sex='男', email='123@qq.com', did=2}, Emp{
        eid=3, empName='王五', age=18, sex='男', email='123@qq.com', did=3}, Emp{
        eid=4, empName='赵六', age=13, sex='男', email='123@qq.com', did=1}]

#### 2.分页相关数据 ####

##### 1.方法一：直接输出 #####

@Test
        public void test() {
        
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
            //访问第一页，每页四条数据
            Page<Object> page = PageHelper.startPage(1, 4);
            List<Emp> emps = mapper.selectByExample(null);
            //在查询到List集合后，打印分页数据
            System.out.println(page);
    
        }

*  分页相关数据：
    
        Page{
              count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=5, pages=2, reasonable=false, pageSizeZero=false}[Emp{
              eid=1, empName='李晓晓', age=10, sex='女', email='123@qq.com', did=1}, Emp{
              eid=2, empName='李四', age=20, sex='男', email='123@qq.com', did=2}, Emp{
              eid=3, empName='王五', age=18, sex='男', email='123@qq.com', did=3}, Emp{
              eid=4, empName='赵六', age=13, sex='男', email='123@qq.com', did=1}]

##### 2.方法二:使用PageInfo #####

*  在查询获取list集合之后，使用`PageInfo<T> pageInfo = new PageInfo<>(List<T> list, intnavigatePages)`获取分页相关数据
    
     *  list：分页之后的数据
     *  navigatePages：导航分页的页码数

@Test
        public void test() {
        
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
            PageHelper.startPage(1, 4);
            List<Emp> emps = mapper.selectByExample(null);
            PageInfo<Emp> page = new PageInfo<>(emps,5);
            System.out.println(page);
    
        }

*  分页相关数据：
    
        PageInfo{
              pageNum=1, pageSize=4, size=4, startRow=1, endRow=4, total=10, pages=3, list=Page{
              count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=10, pages=3,
        
        reasonable=false, pageSizeZero=false}[Emp{
              eid=1, empName='李晓晓', age=10, sex='女', email='123@qq.com', did=1}, Emp{
              eid=2, empName='李四', age=20, sex='男', email='123@qq.com', did=2}, Emp{
              eid=3, empName='王五', age=18, sex='男', email='123@qq.com', did=3}, Emp{
              eid=4, empName='赵六', age=13, sex='男', 
        email='123@qq.com', did=1}], 
        
        prePage=0, nextPage=2, isFirstPage=true, isLastPage=false, hasPreviousPage=false, hasNextPage=true, navigatePages=5, navigateFirstPage=1, navigateLastPage=3, navigatepageNums=[1, 2, 3]}
 *  其中list中的数据等同于方法一中直接输出的page数据

##### 3.常用数据： #####

*  pageNum：当前页的页码
 *  pageSize：每页显示的条数
 *  size：当前页显示的真实条数
 *  total：总记录数
 *  pages：总页数
 *  prePage：上一页的页码
 *  nextPage：下一页的页码
 *  isFirstPage/isLastPage：是否为第一页/最后一页
 *  hasPreviousPage/hasNextPage：是否存在上一页/下一页
 *  navigatePages：导航分页的页码数
 *  navigatepageNums：导航分页的页码，\[1,2,3,4,5\]

[MyBatis]: https://github.com/mybatis/mybatis-3
[5d04bc27db7848c781d6faad2300c8b0.png]: https://img-blog.csdnimg.cn/5d04bc27db7848c781d6faad2300c8b0.png
[img-SB2R87HY-1668236463470_C_Users_30666_AppData_Roaming_Typora_typora-user-images_image-20220812152249636.png]: https://img-blog.csdnimg.cn/427660476fcc43d387275c70b93f95b9.png