Mybatis轻松入门，一篇就够

「爱情、让人受尽委屈。」 2024-03-22 13:54 55阅读 0赞

**目录**

1、MyBatis简介

1.0、MyBatis是什么

1.1MyBatis历史

1.2、MyBatis特性

1.3、MyBatis下载

1.4、和其它持久化层技术对比

2、搭建MyBatis

2.1、开发环境

2.2、创建maven工程

2.3、创建MyBatis的核心配置文件

2.4、创建mapper接口

2.5、创建MyBatis的映射文件

2.6、通过junit测试功能

2.7、加入log4j日志功能

①加入依赖

②加入log4j的配置文件

3、核心配置文件详解

4、MyBatis的增删改查

4.1、新增

4.2、删除

4.3、修改

4.4、查询一个实体类对象

4.5、查询list集合

5、MyBatis获取参数值的两种方式

$\{\}和\#\{\}的区别

1、符号类型

2、防注入问题

3、sql执行过程

5.1、单个字面量类型的参数

5.2、多个字面量类型的参数

5.3、map集合类型的参数

5.4、实体类类型的参数

5.5、使用@Param标识参数

MyBatis获取参数值总结

6、MyBatis的各种查询功能

6.1、查询一个实体类对象

6.2、查询一个list集合

6.3、查询单个数据

6.4、查询一条数据为map集合

6.5、查询多条数据为map集合

①方式一

②方式二

7、特殊SQL的执行

7.1、模糊查询

7.2、批量删除

7.3、动态设置表名

7.4、添加功能获取自增的主键

8、自定义映射resultMap

8.1、resultMap处理字段和属性的映射关系

8.2、多对一映射处理

8.2.1、级联方式处理映射关系

8.2.2、使用association处理映射关系

8.2.3、分步查询

8.3、一对多映射处理

8.3.1、collection

8.3.2、分步查询

①查询部门信息

②根据部门id查询部门中的所有员工

9、动态SQL

9.1、if

9.2、where

9.3、trim

9.4、choose、when、otherwise

9.5、foreach循环标签

9.6、SQL片段

10、MyBatis的缓存

10.1、MyBatis的一级缓存

10.2、MyBatis的二级缓存

10.3、二级缓存的相关配置

10.4、MyBatis缓存查询的顺序

10.5、整合第三方缓存EHCache

10.5.1、添加依赖

10.5.2、各jar包功能

10.5.3、创建EHCache的配置文件ehcache.xml

10.5.4、设置二级缓存的类型

10.5.5、加入logback日志

10.5.6、EHCache配置文件说明

11、MyBatis的逆向工程

11.1、创建逆向工程的步骤

①添加依赖和插件

②创建MyBatis的核心配置文件

③创建逆向工程的配置文件

④执行MBG插件的generate目标

⑤效果

11.2、QBC查询

12、分页插件

12.1、分页插件的使用步骤

①添加依赖

②配置分页插件

12.2、分页插件的使用

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

## 1、MyBatis简介 ##

### 1.0、MyBatis是什么 ###

**MyBatis 是一个 半自动的ORM（Object Relation Mapping）（对象关系映射）框架**

对象：Java的实体类对象

关系：关系型数据库

映射：二者之间的对应关系

<table> 
 <thead> 
  <tr> 
   <th><strong>Java概念</strong></th> 
   <th><strong>数据库概念</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类</td> 
   <td>表</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>字段名（列）</td> 
  </tr> 
  <tr> 
   <td>对象 (一个对象对应着数据库中表的一行数据)</td> 
   <td>记录/行一行</td> 
  </tr> 
 </tbody> 
</table>

### 1.1MyBatis历史 ###

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）。

### 1.2、MyBatis特性 ###

1） MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架

2） MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集

3） MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java

Objects，普通的Java对象）映射成数据库中的记录

4） **MyBatis 是一个 半自动的ORM（Object Relation Mapping）（对象关系映射）框架**

对象：Java的实体类对象

关系：关系型数据库

映射：二者之间的对应关系

5）MyBatis 是直接面向接口编程的，不用实现实现类

通过代理模式创建UserMapper接口的代理实现类对象,mybatis是直接面向接口编程
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

### 1.3、MyBatis下载 ###

MyBatis下载地址：[GitHub - mybatis/mybatis-3: MyBatis SQL mapper framework for Java][GitHub - mybatis_mybatis-3_ MyBatis SQL mapper framework for Java]

![b3b85e0273a7496e92d6c2b6007a3294.png][]

![58cfb4027dbd479e8a794d1e288899f3.png][]

### 1.4、和其它持久化层技术对比 ###

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

## 2、搭建MyBatis ##

### 2.1、开发环境 ###

IDE：idea 2019.2

构建工具：maven 3.5.4

MySQL版本：MySQL 8

MyBatis版本：MyBatis 3.5.7

> MySQL不同版本的注意事项
> 
> 1、驱动类driver-class-name
> 
> MySQL 5版本使用jdbc5驱动，驱动类使用：com.mysql.jdbc.Driver
> 
> MySQL 8版本使用jdbc8驱动，驱动类使用：com.mysql.cj.jdbc.Driver
> 
> 2、连接地址url
> 
> MySQL 5版本的url：
> 
> jdbc:mysql://localhost:3306/ssm
> 
> MySQL 8版本的url：
> 
> jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
> 
> 否则运行测试用例报告如下错误：
> 
> java.sql.SQLException: The server time zone value 'ÖÐ¹ú±ê×¼Ê±¼ä' is unrecognized or
> 
> represents more

### 2.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.16</version>
       </dependency>
    </dependencies>

### 2.3、创建MyBatis的核心配置文件 ###

> 习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring
> 
> 之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。
> 
> 核心配置文件主要用于配置连接数据库的环境以及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/ssm?serverTimezone=UTC"/>
                    <property name="username" value="root"/>
                    <property name="password" value="123456"/>
                </dataSource>
            </environment>
        </environments>
    
        
        <mappers>
            <mapper resource="mappers/UserMapper.xml"/>
        </mappers>
    
    </configuration>

### 2.4、创建mapper接口 ###

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

public interface UserMapper {
    
        //添加用户
        int insertUser();
    
        //修改用户信息
        void updateUser();
    
        //删除用户信息
        void deleteUser();
    
        //根据id查询用户信息
        User getUserById();
    
        //查询所有的用户信息
        List<User> getAllUser();
    }

### 2.5、创建MyBatis的映射文件 ###

相关概念：**ORM**（**O**bject **R**elationship **M**apping）对象关系映射。

*  对象：Java的实体类对象
 *  关系：关系型数据库
 *  映射：二者之间的对应关系

<table> 
 <thead> 
  <tr> 
   <th><strong>Java概念</strong></th> 
   <th><strong>数据库概念</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类</td> 
   <td>表</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>字段/列</td> 
  </tr> 
  <tr> 
   <td>对象 (一个对象对应着数据库中一行数据)</td> 
   <td>记录/行</td> 
  </tr> 
 </tbody> 
</table>

> 1、映射文件的命名规则：
> 
> 表所对应的实体类的类名+Mapper.xml
> 
> 例如：表t\_user，映射的实体类为User，所对应的映射文件为UserMapper.xml
> 
> 因此一个映射文件对应一个实体类，对应一张表的操作
> 
> MyBatis映射文件用于编写SQL，访问以及操作表中的数据
> 
> MyBatis映射文件存放的位置是src/main/resources/mappers目录下
> 
> 2、 MyBatis中可以**面向接口**操作数据，要保证两个一致：
> 
> a>mapper接口的全类名和映射文件的命名空间（namespace）保持一致
> 
> b>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.yka.mybatis.mapper.UserMapper">
        
        <insert id="insertUser">
            insert into t_user values(null,'admin','123456',23,'男','12345@qq.com')
        </insert>
    
        
        <update id="updateUser">
            update t_user set username = 'root',password = '123' where id = 3;
        </update>
    
        
        <delete id="deleteUser">
            delete from ssm.t_user where id = 4
        </delete>
    
        
    
        
        <select id="getUserById" resultType="com.yka.mybatis.pojo.User">
            select * from ssm.t_user where id = 1;
        </select>
    
        
        <select id="getAllUser" resultType="com.yka.mybatis.pojo.User">
            select * from ssm.t_user;
        </select>
    </mapper>

### 2.6、通过junit测试功能 ###

先创建工具类SqlSessionUtil，简化以下测试类的代码

public class SqlSessionUtil {
        public static SqlSession getSqlSession(){
                SqlSession sqlSession = null;
            try {
                //获取核心配置文件的输入流
                InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
                //获取SqlSessionFactoryBuilder
                SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
                //通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
                SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
                //获取SqlSession对象
                sqlSession = sqlSessionFactory.openSession(true);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return sqlSession;
        }
    }
    public class MybatisTest {
    
        //新增
        @Test
        public void testInsert() throws IOException {
            //获取核心配置文件的输入流
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            System.out.println(is);
    
            //获取SqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            System.out.println(sqlSessionFactoryBuilder);
    
            //通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
            System.out.println(sqlSessionFactory);
    
            //获取sql的会话对象SqlSession(不会自动提交事物)，是MyBatis提供的操作数据库的对象
            //SqlSession sqlSession = sqlSessionFactory.openSession();
            //获取sql的会话对象SqlSession(true会自动提交事物)，是MyBatis提供的操作数据库的对象
            SqlSession sqlSession = sqlSessionFactory.openSession(true);
    
            //两种写法执行sql语句的，第二种不常用了解就行
            //第一种：通过代理模式 创建UserMapper接口的代理实现类对象 ,mybatis直接面向接口编程
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            System.out.println(mapper);
            //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配映射文件，通过调用的方法名匹配映射文件中的SQL标签的       id，并执行标签中的SQL语句
            int result = mapper.insertUser();
    
            //第二种：提交sql以及的唯一标识找到sql并执行，唯一标识是映射文件中 两个标签属性：namespace.splId
            //int result = sqlSession.insert("com.yka.mybatis.mapper.UserMapper.insertUser");
            System.out.println("结果："+result);
            //提交事物
    //        sqlSession.commit();
            //关闭sqlSession
            sqlSession.close();
        }
    
        //修改
        @Test
        public void testUpdate(){
            //调用SqlSessionUtil工具类的方法
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            //通过代理模式创建UserMapper接口的代理实现类对象,mybatis直接面向接口编程
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配映射文件中的namespace属性，通过调用的方法名与映射文件       中的SQL标签的id匹配，并执行标签中的SQL语句
            mapper.updateUser();
            sqlSession.close();
        }
    
        //删除
        @Test
        public void testDelete(){
            //调用SqlSessionUtil工具类的方法
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            //通过代理模式创建UserMapper接口的代理实现类对象,mybatis直接面向接口编程
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            System.out.println(mapper);
            //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配映射文件中的namespace属性，通过调用的方法名与映射文件       中的SQL标签的id匹配，并执行标签中的SQL语句
            mapper.deleteUser();
            sqlSession.close();
        }
    
        //根据id查询
        @Test
        public void testGetUserById(){
            //调用SqlSessionUtil工具类的方法
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            //通过代理模式创建UserMapper接口的代理实现类对象,mybatis直接面向接口编程
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            System.out.println(mapper);
            //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配映射文件中的namespace属性，通过调用的方法名与映射文件       中的SQL标签的id匹配，并执行标签中的SQL语句
            User user = mapper.getUserById();
            System.out.println(user);
            sqlSession.close();
        }
    
        //查询所有用户信息
        @Test
        public void testGetAllUser(){
            //调用SqlSessionUtil工具类的方法
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            //通过代理模式创建UserMapper接口的代理实现类对象,mybatis直接面向接口编程
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            System.out.println(mapper);
            //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配映射文件中的namespace属性，通过调用的方法名与映射文件       中的SQL标签的id匹配，并执行标签中的SQL语句
            List<User> list = mapper.getAllUser();
            list.forEach(v->{
                System.out.println(v);
            });
            System.out.println(list);
            sqlSession.close();
        }
    
    }

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

### 2.7、加入log4j日志功能 ###

#### ①加入依赖 ####

<dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>

#### ②加入log4j的配置文件 ####

> log4j的配置文件名为log4j.xml，存放的位置是src/main/resources目录下

<?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、核心配置文件详解 ##

配置jdbc.properties文件

jdbc.driver=com.mysql.cj.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
    jdbc.username=root
    jdbc.password=123456

核心配置文件中的标签必须按照固定的顺序：

properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,refl

ectorFactory?,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" />
     
        
        <typeAliases>
        
            
            
            <package name="com.yka.mybatis.pojo"/>
        </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>
         
         
            <environment id="test">
           <transactionManager type="JDBC"/>
           <dataSource type="POOLED">
              <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
              <property name="url"value="jdbc:mysql://localhost:3306/ssmserverTimezone=UTC"/>
              <property name="username" value="root"/>
              <property name="password" value="123456"/>
                </dataSource>
            </environment>
        </environments>
        
        <mappers>
        
        
            <package name="com.yka.mybatis.mapper"/>
        </mappers>
    </configuration>

## 4、MyBatis的增删改查 ##

### 4.1、新增 ###

<insert id="insertUser">
        insert into t_user values(null,'admin','123456',23,'男')
    </insert>

### 4.2、删除 ###

<delete id="deleteUser">
        delete from t_user where id = 7
    </delete>

### 4.3、修改 ###

<update id="updateUser">
        update t_user set username='ybc',password='123' where id = 6
    </update>

### 4.4、查询一个实体类对象 ###

<select id="getUserById" resultType="com.atguigu.mybatis.bean.User">
        select * from t_user where id = 2
    </select>

### 4.5、查询list集合 ###

<select id="getUserList" resultType="com.atguigu.mybatis.bean.User">
        select * from t_user
    </select>

> 注意：
> 
> 1、查询的标签select必须设置属性resultType或resultMap，用于设置实体类和数据库表的映射关系
> 
> resultType：自动映射，用于属性名和表中字段名一致的情况，查询的数据结果要转化为Java类型(实体类或字面量类型)
> 
> resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况

## 5、MyBatis获取参数值的两种方式 ##

> MyBatis获取参数值的两种方式：**$\{\}**和**\#\{\}**
> 
> $\{\}的本质就是字符串拼接(传过来是真实的数据)，\#\{\}的本质就是占位符赋值预编译(传过来是占位符？)
> 
> $\{\}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号；$\{\}：不带引号就是传过来的数据，不带任何引号
> 
> 但是\#\{\}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，
> 
> 可以自动添加单引号

### **$\{\}**和**\#\{\}**的区别 ###

> #### 1、符号类型 ####
> 
> （1）\#\{\}：参数占位符，即预编译 （2）$\{\} ：字符串拼接，即SQL拼接
> 
> #### 2、防注入问题 ####
> 
> （1）\#\{\}：很大程度上能防止sql 注入 （2）$\{\}：不能防止sql 注入
> 
> #### 3、sql执行过程 ####
> 
> （1）\#\{\}：编译好SQL后语句再去取值 （2）$\{\}：取值以后再去编译SQL语句

### 5.1、单个字面量类型的参数 ###

> 若mapper接口中的方法参数为单个的字面量类型（string,int...：是字面量，除了类类型(实体类对象)的其他的都是字面量）
> 
> 此时可以使用$\{\}和\#\{\}以任意的名称获取参数的值，注意$\{\}需要手动加单引号
> 
>     select * from ssm.t_user where username = #{username}
>     select * from ssm.t_user where username = '${username}'

### 5.2、多个字面量类型的参数 ###

> 若mapper接口中的方法参数为多个时
> 
> 此时MyBatis会自动将这些参数放在一个map集合中，以arg0,arg1...为键，以参数为值；以
> 
> param1,param2...为键，以参数为值；因此只需要通过$\{\}和\#\{\}访问map集合的键就可以获取相
> 
> 对应的值，注意$\{\}需要手动加单引号
> 
>     select * from ssm.t_user where username = '${arg0}' and password = '${arg1}'
>     select * from ssm.t_user where username = #{arg0} and password = #{arg1}
>     select * from ssm.t_user where username = '${param1}' and password = '${param2}'
>     select * from ssm.t_user where username = #{param1} and password = #{param2}

### 5.3、map集合类型的参数 ###

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

### 5.4、实体类类型的参数 ###

> 若mapper接口中的方法参数为实体类对象时
> 
> 此时可以使用$\{\}和\#\{\}，通过访问实体类对象中的属性名获取属性值，注意$\{\}需要手动加单引号
> 
> 属性名：跟成员变量时没关系了，属性名是get和set方法名把get和set去掉剩下的字母小写就是属性名
> 
>     insert into ssm.t_user values (null,#{username},#{password},#{age},#{gender},#{email})

### 5.5、使用@Param标识参数 ###

> 可以在mapper接口方法的参数上设置@Param注解
> 
> 此时，会将这些参数放在map集合中，以两种方式进行存储：
> 
> a> 以@Param注解的value属性值为键，以参数为值
> 
> b> 以param1,param2...为键，以参数为值
> 
> 只需要通过$\{\}和\#\{\}访问map集合的键就可以获取相对应的值，注意$\{\}需要手动加单引号
> 
>     
>     select * from ssm.t_user where username = #{username} and password = #{password}

### MyBatis获取参数值总结 ###

总结下来以上五种获取参数的方式只需要记住两种即可：

1、若mapper接口中的方法参数为一个或多个参数统一使用@Param注解的方式标识参数，

以@Param注解的value属性值为键，以参数为值

2、若mapper接口中的方法参数为实体类对象时，通过访问实体类对象中的属性名获取属性值

## 6、MyBatis的各种查询功能 ##

### 6.1、查询一个实体类对象 ###

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

<select id="getUserById" resultType="User">
        select * from t_user where id = #{id}
    </select>

### 6.2、查询一个list集合 ###

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

<select id="getUserList" resultType="User">
        select * from t_user
    </select>

> 当查询的数据为多条时，不能使用实体类作为返回值，否则会抛出异常
> 
> TooManyResultsException；但是若查询的数据只有一条，可以使用实体类或集合作为返回值

### 6.3、查询单个数据 ###

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

<select id="getCount" resultType="_integer">
        select count(id) from t_user
    </select>

### 6.4、查询一条数据为map集合 ###

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

<select id="getUserToMap" resultType="map">
        select * from t_user where id = #{id}
    </select>

### 6.5、查询多条数据为map集合 ###

#### ①方式一 ####

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

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

#### ②方式二 ####

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

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

## 7、特殊SQL的执行 ##

### 7.1、模糊查询 ###

/**
    * 测试模糊查询
    * @param mohu
    * @return
    */
    List<User> testMohu(@Param("mohu") String mohu);

<select id="testMohu" resultType="User">
        
        
        select * from t_user where username like "%"#{mohu}"%"
    </select>

### 7.2、批量删除 ###

/**
    * 批量删除
    * @param ids
    * @return
    */
    int deleteMore(@Param("ids") String ids);

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

//测试类
    int i = mapper.deleteMoreUser("7,8");

### 7.3、动态设置表名 ###

/**
    * 动态设置表名，查询所有的用户信息
    * @param tableName
    * @return
    */
    List<User> getAllUser(@Param("tableName") String tableName);

<select id="getAllUser" resultType="User">
        select * from ${tableName}
    </select>

### 7.4、添加功能获取自增的主键 ###

> 场景模拟：
> 
> t\_clazz(clazz\_id,clazz\_name)
> 
> t\_student(student\_id,student\_name,clazz\_id)
> 
> 1、添加班级信息
> 
> 2、获取新添加的班级的id
> 
> 3、为班级分配学生，即将某学的班级id修改为新添加的班级的id

/**
    * 添加用户信息
    * @param user
    * @return
    * useGeneratedKeys：设置使用自增的主键
    * keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中
    */
    int insertUser(User user);

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

@Test
    public void testInsertUser(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        SpecialSQLMapper mapper = sqlSession.getMapper(SpecialSQLMapper.class);
        User user = new User(null,"xiaoming","123456",15,"男","123@qq");
        //执行方法之前没有获取到主键，id为null
        //结果：执行方法之前：User{id=null, username='xiaoming', password='123456', age=15, gender='男', email='123@qq'}
        System.out.println("执行方法之前："+user);
        mapper.insertUser(user);
        //执行方法之后获取到了自增主键，并赋值到id上
        //结果：执行方法之后：User{id=11, username='xiaoming', password='123456', age=15, gender='男', email='123@qq'}
        System.out.println("执行方法之后："+user);
    }

## 8、自定义映射resultMap ##

创建实体类

public class Emp {
        private Integer empId;
        private String empName;
        private Integer age;
        private String gender;
    
        //员工对部门是多对一，对一对应的是对象，部门对员工是一对多，对多对应的是集合
        private Dept dept;
    }

public class Dept {
        private Integer deptId;
        private String deptName;
        
        //员工对部门是多对一，对一对应的是对象，部门对员工是一对多，对多对应的是集合
        private List<Emp> emps;
    }

### 8.1、resultMap处理字段和属性的映射关系 ###

> 若字段名和实体类中的属性名不一致，则可以通过resultMap设置自定义映射

<resultMap id="empResultMap" type="emp">
            <id column="emp_id" property="empId"></id>
            <result column="emp_name" property="empName"></result>
            <result column="age" property="age"></result>
            <result column="gender" property="gender"></result>
        </resultMap>
    
        
        <select id="getEmpByEmpId" resultMap="empResultMap">
            
            select * from t_emp where emp_id = #{empId}
        </select>

测试类：

//使用resultMap自定义映射处理字段名和属性名不一致
    @Test
    public void testGetEmpByEmpId(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        Emp emp = mapper.getEmpByEmpId(1);
        System.out.println(emp);
    }

> 若字段名和实体类中的属性名不一致，但是字段名符合数据库的规则（使用\_），实体类中的属性名符合Java的规则（使用驼峰）
> 
> 此时也可通过以下三种方式处理字段名和实体类中的属性的映射关系
> 
> a>可以通过为字段起别名的方式，保证和实体类中的属性名保持一致
> 
> b>通过resultMap自定义映射
> 
> c>可以在MyBatis的核心配置文件中设置一个全局配置信息mapUnderscoreToCamelCase，可以在查询表中数据时，自动将\_类型的字段名转换为驼峰
> 
> 例如：字段名user\_name，设置了mapUnderscoreToCamelCase，此时字段名就会转换为
> 
> userName
> 
>     <settings>
>     
>     <setting name="mapUnderscoreToCamelCase" value="true"/>
>     </settings>

### 8.2、多对一映射处理 ###

> 场景模拟：
> 
> 查询员工信息以及员工所对应的部门信息
> 
> 员工对部门是多对一，对一对应的是对象，部门对员工是一对多，对多对应的是集合
> 
>     public class Emp {
>      private Integer empId;
>      private String empName;
>      private Integer age;
>      private String gender;
>     
>      //员工对部门是多对一，对一对应的是对象，部门对员工是一对多，对多对应的是集合
>      private Dept dept;
>     }
> 
>     public class Dept {
>      private Integer deptId;
>      private String deptName;
>      
>      //员工对部门是多对一，对一对应的是对象，部门对员工是一对多，对多对应的是集合
>      private List<Emp> emps;
>     }

#### 8.2.1、级联方式处理映射关系 ####

#### 8.2.2、使用association处理映射关系 ####

<resultMap id="empAndDeptResultMap" type="emp">
            <id column="emp_id" property="empId"></id>
            <result column="emp_name" property="empName"></result>
            <result column="age" property="age"></result>
            <result column="gender" property="gender"></result>
         
            <association property="dept" javaType="Dept">
                <id column="dept_id" property="deptId"></id>
                <result column="dept_name" property="deptName"></result>
            </association>
        </resultMap>
        
        <select id="getEmpAndDeptByEmpId" resultMap="empAndDeptResultMap">
            select emp.*,dept.* from t_emp emp left join t_dept dept on emp.emp_id =dept.dept_id where emp.emp_id = #{empId}
        </select>

测试类

//多对一使用association和级联处理映射关系查询测试
    @Test
    public void testGetEmpAndDeptByEmpId(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        Emp empAndDeptByEmpId = mapper.getEmpAndDeptByEmpId(1);
        System.out.println(empAndDeptByEmpId);
    }

#### 8.2.3、分步查询 ####

①查询员工信息

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

<resultMap id="empAndDeptByStepResultMap" type="emp">
            <id column="emp_id" property="empId"></id>
            <result column="emp_name" property="empName"></result>
            <result column="age" property="age"></result>
            <result column="gender" property="gender"></result>
            
            <association fetchType="eager" property="dept" select="com.yka.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTow" column="dept_id"></association>
        </resultMap>
        
        <select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap">
            select * from t_emp where emp_id = #{empId}
        </select>

②根据员工所对应的部门id查询部门信息

/**
    * 通过分步查询查询员工以及对应的部门信息的第二步
    * @param did
    * @return
    */
     Dept getEmpAndDeptByStepTow(@Param("deptId") String deptId);

<select id="getEmpAndDeptByStepTow" resultType="dept">
            select * from t_dept where dept_id = #{deptId}
        </select>

测试类：

//多对一分步查询
    @Test
    public void testGetEmpAndDeptByStep(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        Emp empAndDeptByStepOne = mapper.getEmpAndDeptByStepOne(1);
        System.out.println(empAndDeptByStepOne);
    }

### 8.3、一对多映射处理 ###

#### 8.3.1、collection ####

/**
    * 查询部门以及部门中的员工信息
    * @param did
    * @return
    */
     Dept getDeptAndEmpByDeptId(@Param("deptId") Integer deptId);

<resultMap id="deptAndEmpResultMap" type="Dept">
            <id column="dept_id" property="deptId"></id>
            <result column="dept_name" property="deptName"></result>
            
            <collection property="emps" ofType="Emp">
                <id column="emp_id" property="empId"></id>
                <result column="emp_name" property="empName"></result>
                <result column="age" property="age"></result>
                <result column="gender" property="gender"></result>
            </collection>
        </resultMap>
        
        <select id="getDeptAndEmpByDeptId" resultMap="deptAndEmpResultMap">
            select * from t_dept dept LEFT JOIN t_emp emp on dept.dept_id = emp.dept_id where dept.dept_id = #{deptId};
        </select>

测试类：

//一对多使用association处理映射关系查询
    @Test
    public void testGetDeptAndEmpByDeptId(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
        Dept deptAndEmpByDeptId = mapper.getDeptAndEmpByDeptId(1);
        System.out.println(deptAndEmpByDeptId);
    }

#### 8.3.2、分步查询 ####

#### ①查询部门信息 ####

/**
    * 通过分步查询查询部门信息以及部门中的员工信息的第一步
    * @param did
    * @return
    */
    Dept getDeptAndEmpByStepOne(@Param("deptId") Integer deptId);

<resultMap id="deptAndEmpResultMapByStep"  type="dept">
            <id column="dept_id" property="deptId"></id>
            <result column="dept_name" property="deptName"></result>
            
            <collection property="emps"
                        select="com.yka.mybatis.mapper.EmpMapper.getDeptAndEmpByStepTwo"
                        column="dept_id"
                        ></collection>
        </resultMap>
    
        
        <select id="getDeptAndEmpByStepOne" resultMap="deptAndEmpResultMapByStep">
            select * from t_dept where dept_id = #{deptId}
        </select>

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

/**
    * 通过分步查询查询部门信息以及部门中的员工信息的第二步
    * @param did
    * @return
    */
    List<Emp> getDeptAndEmpByStepTwo(@Param("deptId") Integer deptId);

<select id="getDeptAndEmpByStepTwo" resultType="emp">
            select * from t_emp where dept_id = #{deptId}
        </select>

测试类：

//一对多分步查询
    @Test
    public void testGetDeptAndEmpByStep(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
        Dept deptAndEmpByStepOne = mapper.getDeptAndEmpByStepOne(1);
        System.out.println(deptAndEmpByStepOne);
    }

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

## 9、动态SQL ##

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

### 9.1、if ###

> if标签可通过test属性的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之
> 
> 标签中的内容不会执行 <if test="实体类属性">

<select id="getEmpByCondition" resultType="emp">
            select <include refid="empColumns"></include> from t_emp where 1=1
            <if test="empName != null and empName != ''">
                emp_name = #{empName}
            </if>
            <if test="age != null and age != ''">
                and age = #{age}
            </if>
            <if test="gender != null and gender != ''">
                and gender = #{gender}
            </if>
      </select>

### 9.2、where ###

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

<select id="getEmpByCondition" resultType="emp">
            select <include refid="empColumns"></include> 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="gender != null and gender != ''">
                    and gender = #{gender}
                </if>
            </where>
        </select>

### 9.3、trim ###

> trim用于去掉或添加标签中的内容
> 
> 常用属性：
> 
> prefix：在trim标签中的内容的前面添加某些内容
> 
> prefixOverrides：在trim标签中的内容的前面去掉某些内容
> 
> suffix：在trim标签中的内容的后面添加某些内容
> 
> suffixOverrides：在trim标签中的内容的后面去掉某些内容

<select id="getEmpByCondition" resultType="emp">
            select <include refid="empColumns"></include> from t_emp
            <trim prefix="where" suffixOverrides="and">
                <if test="empName != null and empName != ''">
                    emp_name = #{empName} and
                </if>
                <if test="age != null and age != ''">
                    age = #{age} and
                </if>
                <if test="gender != null and gender != ''">
                    gender = #{gender} and
                </if>
            </trim>
        </select>

以上三个标签的测试类

//if where trim 三个标签测试
    @Test
    public void testGetEmpByCondition(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
        Emp emp = new Emp(null, "", null, "男");
        List<Emp> empByCondition = mapper.getEmpByCondition(emp);
        System.out.println(empByCondition);
    }

### 9.4、choose、when、otherwise ###

> choose、when、 otherwise
> 
> 相当于if...else if..else 只要if成立就不会执行else if 和else
> 
> 如果第一个when标签成立就不会执行下面的标签，如果第一个when不成立就会判断下一个标签
> 
> when至少设置一个，otherwise最多设置一个
> 
> choose、when、otherwise：最多就执行一个条件，when 后面就跟一个条件

<select id="getEmpByChoose" resultType="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="gender != null and gender != ''">
                         gender = #{gender}
                    </when>
                    <otherwise>
                        
                    </otherwise>
                </choose>
            </where>
        </select>

测试类：

//choose、when、otherwise测试
    @Test
    public void testGetEmpByChoose(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
        Emp emp = new Emp(null, "", null, "男");
        List<Emp> empByCondition = mapper.getEmpByChoose(emp);
        System.out.println(empByCondition);
    }

### 9.5、foreach循环标签 ###

collection：设置当前要循环的是集合或数组，mybatis会把集合或数组放到map集合中，通过@Param("")的值为键去访问集合或数组。

item：用一个字符串来表示集合或数组中的每一条数据，每一项

separator：分隔符，每一次循环的数据之间的分隔符

open：当前循环之前所有内容以什么开始

close：当前循环结束所有内容以什么结束

<insert id="insertMoreEmp">
            insert into t_emp values
            <foreach collection="emps" item="emp" separator=",">
                (null,#{emp.empName},#{emp.age},#{emp.gender},null)
            </foreach>
        </insert>
    
    
        <delete id="deleteMoreEmp">
            delete from t_emp where 
            <foreach collection="empIds" item="empId" separator="or">
                
                emp_id = #{empId}
            </foreach>
        </delete>
        <delete id="deleteMoreEmpOne">
            delete from t_emp where emp_id in
            <foreach collection="empIds" item="empId" separator="," open="(" close=")">
                
                #{empId}
            </foreach>
        </delete>

测试类：

//批量添加
    @Test
    public void testInsertMoreEmp(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
        Emp emp1 = new Emp(null, "小明1", 20, "男");
        Emp emp2 = new Emp(null, "小明2", 20, "男");
        Emp emp3 = new Emp(null, "小明3", 20, "男");
        List<Emp> emps = Arrays.asList(emp1, emp2, emp3);
        mapper.insertMoreEmp(emps);
    }
    
    
    //批量删除
    @Test
    public void testDeleteMoreEmp(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
        Integer[] ids = new Integer[]{6,7};
        mapper.deleteMoreEmp(ids);
    }

### 9.6、SQL片段 ###

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

<sql id="empColumns">
        eid,ename,age,sex,did
    </sql>
    select <include refid="empColumns"></include> from t_emp

## 10、MyBatis的缓存 ##

### 10.1、MyBatis的一级缓存 ###

一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问

使一级缓存失效的四种情况：

1) 不同的SqlSession对应不同的一级缓存

2) 同一个SqlSession但是查询条件不同

3) 同一个SqlSession两次查询期间执行了任何一次增删改操作

4) 同一个SqlSession两次查询期间手动清空了缓存

//一级缓存
    @Test
    public void testGetEmpById(){
        SqlSession sqlSession1 = SqlSessionUtil.getSqlSession();
        CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
    
        Emp empById1 = mapper1.getEmpById(1);
        System.out.println(empById1);
        //sqlSession1.clearCache();清理缓存
    
        Emp empById2 = mapper1.getEmpById(1);
        System.out.println(empById2);

### 10.2、MyBatis的二级缓存 ###

二级缓存是SqlSessionFactory级别，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被

缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取

二级缓存开启的条件：

a>在核心配置文件中，设置全局配置属性cacheEnabled="true"，默认为true，不需要设置

b>在映射文件中设置标签<cache/>

c>二级缓存必须在SqlSession关闭或提交之后有效 sqlSession1.close();

d>查询的数据所转换的实体类类型必须实现序列化的接口 implements Serializable

使二级缓存失效的情况：

两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效

//二级缓存
    @Test
    public void testCache() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    
        SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
        CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
        Emp empById1 = mapper1.getEmpById(1);
        System.out.println(empById1);
        sqlSession1.close();
    
        SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
        CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
        Emp empById2 = mapper2.getEmpById(1);
        System.out.println(empById2);
        sqlSession1.close();
    }

### 10.3、二级缓存的相关配置 ###

在mapper配置文件中添加的cache标签可以设置一些属性：

①eviction属性：缓存回收策略，默认的是 LRU。

LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。

FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。

SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。

WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。

②flushInterval属性：刷新间隔，单位毫秒

默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新

③size属性：引用数目，正整数

代表缓存最多可以存储多少个对象，太大容易导致内存溢出

④readOnly属性：只读， true/false

true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了 很重要的性能优势。

false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是

false。

### 10.4、MyBatis缓存查询的顺序 ###

先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用。

如果二级缓存没有命中，再查询一级缓存

如果一级缓存也没有命中，则查询数据库

SqlSession关闭之后，一级缓存中的数据会写入二级缓存

### 10.5、整合第三方缓存EHCache ###

#### 10.5.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>

#### 10.5.2、各jar包功能 ####

<table> 
 <thead> 
  <tr> 
   <th><strong>jar包名称</strong></th> 
   <th><strong>作用</strong></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>

#### 10.5.3、创建EHCache的配置文件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:\atguigu\ehcache"/>
        <defaultCache
            maxElementsInMemory="1000"
            maxElementsOnDisk="10000000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
        </defaultCache>
    </ehcache>

#### 10.5.4、设置二级缓存的类型 ####

#### 10.5.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.yka.mybatis.mapper" level="DEBUG"/>
    </configuration>

#### 10.5.6、EHCache配置文件说明 ####

<table> 
 <thead> 
  <tr> 
   <th><strong>属性名</strong></th> 
   <th><strong>是否必须</strong></th> 
   <th><strong>作用</strong></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>

## 11、MyBatis的逆向工程 ##

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

### 11.1、创建逆向工程的步骤 ###

#### ①添加依赖和插件 ####

<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>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</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>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>8.0.16</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

#### ②创建MyBatis的核心配置文件 ####

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

> 文件名必须是：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="MyBatis3">
            
            <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                            connectionURL="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"
                            userId="root"
                            password="123456">
            </jdbcConnection>
            
            <javaModelGenerator targetPackage="com.yka.mybatis.pojo" targetProject=".\src\main\java">
                <property name="enableSubPackages" value="true" />
                <property name="trimStrings" value="true" />
            </javaModelGenerator>
            
            <sqlMapGenerator targetPackage="com.yka.mybatis.mapper" targetProject=".\src\main\resources">
                <property name="enableSubPackages" value="true" />
            </sqlMapGenerator>
            
            <javaClientGenerator type="XMLMAPPER" targetPackage="com.yka.mybatis.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>

#### ④执行MBG插件的generate目标 ####

![1ac61c028080473b80faa37dc12c9876.png][]

#### ⑤效果 ####

![88daf8f5977b4e8d8616e268b6060d08.png][]

### 11.2、QBC查询 ###

@Test
        public void testMBG(){
    
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
            //根据id查询数据
            /*Emp emp = mapper.selectByPrimaryKey(1);
            System.out.println(emp);*/
            //查询所有数据 条件为null就是查询所有
            /*List<Emp> list = mapper.selectByExample(null);
            list.forEach(System.out::println);*/
            //根据条件查询数据
            /*EmpExample example = new EmpExample();
            example.createCriteria().andEmpNameEqualTo("张三").andAgeGreaterThanOrEqualTo(20);
            example.or().andGenderEqualTo("男");
            List<Emp> list = mapper.selectByExample(example);
            list.forEach(System.out::println);*/
            Emp emp = new Emp(1, "小黑", null, "女");
            //测试普通修改功能其中一个属性为null 该字段也会更改
            //mapper.updateByPrimaryKey(emp);
            //测试选择性修改,其中一个属性为null 该字段不会更改
            mapper.updateByPrimaryKeySelective(emp);
    
        }

## 12、分页插件 ##

limit index,pageSize

pageSize：每页显示的条数

pageNum：当前页的页码

index：当前页的起始索引，index=(pageNum-1)\*pageSize

count：总记录数

totalPage：总页数

totalPage = count / pageSize;

if(count % pageSize != 0)\{

totalPage += 1;

pageSize=4，pageNum=1，index=0 limit 0,4

pageSize=4，pageNum=3，index=8 limit 8,4

pageSize=4，pageNum=6，index=20 limit 8,4

首页 上一页 2 3 4 5 6 下一页 末页

### 12.1、分页插件的使用步骤 ###

#### ①添加依赖 ####

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

#### ②配置分页插件 ####

在MyBatis的核心配置文件中配置插件

测试类

@Test
    public void testPage(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        //查询功能之前开启分页功能
        Page<Object> page = PageHelper.startPage(5, 4);
        List<Emp> list = mapper.selectByExample(null);
        //查询功能之后可以获取分页相关的所有数据
        PageInfo<Emp> pageInfo = new PageInfo<>(list, 5);
        list.forEach(System.out::println);
        System.out.println(pageInfo);
    }

### 12.2、分页插件的使用 ###

a>在查询功能之前使用PageHelper.startPage(int pageNum, int pageSize)开启分页功能

> pageNum：当前页的页码
> 
> pageSize：每页显示的条数

b>在查询获取list集合之后，使用PageInfo<T> pageInfo = new PageInfo<>(List<T> list, intnavigatePages)获取分页相关数据

> list：分页之后的数据
> 
> navigatePages：导航分页的页码数

c>分页相关数据

> PageInfo\{
> 
> pageNum=8, pageSize=4, size=2, startRow=29, endRow=30, total=30, pages=8,
> 
> list=Page\{count=true, pageNum=8, pageSize=4, startRow=28, endRow=32, total=30,
> 
> pages=8, reasonable=false, pageSizeZero=false\},
> 
> prePage=7, nextPage=0, isFirstPage=false, isLastPage=true, hasPreviousPage=true,
> 
> hasNextPage=false, navigatePages=5, navigateFirstPage4, navigateLastPage8,
> 
> navigatepageNums=\[4, 5, 6, 7, 8\]
> 
> \}
> 
> pageNum：当前页的页码
> 
> pageSize：每页显示的条数
> 
> size：当前页显示的真实条数
> 
> total：总记录数
> 
> pages：总页数
> 
> prePage：上一页的页码
> 
> nextPage：下一页的页码
> 
> isFirstPage/isLastPage：是否为第一页/最后一页
> 
> hasPreviousPage/hasNextPage：是否存在上一页/下一页
> 
> navigatePages：导航分页的页码数
> 
> navigatepageNums：导航分页的页码，\[1,2,3,4,5\]
> 
> PageInfo\{
> 
> pageNum=2, pageSize=4, size=4, startRow=5, endRow=8, total=56, pages=14,
> 
> list=Page\{count=true, pageNum=2, pageSize=4, startRow=4, endRow=8, total=56, pages=14, reasonable=false, pageSizeZero=false\}
> 
> \[Student\{stuId=10, stuName='a', age=1, gender='1', email='null'\}, Student\{stuId=11, stuName='a', age=null, gender='null', email='null'\}, Student\{stuId=12, stuName='a', age=null, gender='null', email='null'\}, Student\{stuId=13, stuName='a', age=null, gender='null', email='null'\}\],
> 
> prePage=1, nextPage=3, isFirstPage=false, isLastPage=false, hasPreviousPage=true, hasNextPage=true, navigatePages=5, navigateFirstPage=1, navigateLastPage=5, navigatepageNums=\[1, 2, 3, 4, 5\]
> 
> \}
> 
> PageInfo<T> pageInfo = new PageInfo<>(List<T> list, intnavigatePages)
> 
> pageInfo.list：打印后是：\[Student\{stuId=10, stuName='a', age=1, gender='1', email='null'\}, Student\{stuId=11, stuName='a', age=null, gender='null', email='null'\}, Student\{stuId=12, stuName='a', age=null, gender='null', email='null'\}, Student\{stuId=13, stuName='a', age=null, gender='null', email='null'\}\],

[GitHub - mybatis_mybatis-3_ MyBatis SQL mapper framework for Java]: https://github.com/mybatis/mybatis-3
[b3b85e0273a7496e92d6c2b6007a3294.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/f2b0bfb5eda44c7b83ffa19c3c837774.png
[58cfb4027dbd479e8a794d1e288899f3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/5b4c54528a16419a9b623e9f2457f275.png
[1ac61c028080473b80faa37dc12c9876.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/99602ef2ace842d39944d5964c3d325a.png
[88daf8f5977b4e8d8616e268b6060d08.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ab20b50307474d798c7cd100b081dddc.png