Mybatis 学习笔记总结

1.概念

 

 

2.开发环境搭建

2.1 开发环境

 2.2 创建Maven工程

<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.11version>
    <scope>testscope>
dependency>

<dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatisartifactId>
    <version>3.5.7version>
dependency>

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>8.0.21version>
dependency>

 2.3 创建Mybatis的核心配置文件

习惯上命名为mybatis-configxml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。

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

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

2.4 创建mapper接口

 2.5 创建Mybatis的映射文件

 

 mapper接口和映射文件要保证两个一致:

1、mapper接口的全类名和映射文件的namespace一致

2、mapper接口中的方法的方法名要和映射文件中的sql的id保持一致

    
    
        insert into t_user values('4','admin','123456',23,'男','[email protected]')
    

2.6 创建测试方法

@Test
public void mybatisTest() {
    try {
        // 获取核心配置文件的输入流
        InputStream stream = Resources.getResourceAsStream("mybatis_config.xml");
        // 获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 获取SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(stream);
        // 获取sql的会话对象SqlSession（不会自动提交事务）,是Mybatis提供的操作数据的对象
        // SqlSession sqlSession = sqlSessionFactory.openSession();
        // 获取sql的会话对象SqlSession（会自动提交事务）
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        // 获取UserMapper的代理实现类,
        // 通过getMapper方法，重写接口方法：通过UserMapper的全类名来找到当前对象的映射文件，再通过要调用的方法找到要调用的sql语句

        /**
         * mapper接口和映射文件要保证两个一致:
         *         1，mapper接口的全类名和映射文件的namespace一致
         *         2、mapper接口中的方法的方法名要和映射文件中的sqL的id保持一致
         * */

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        // 执行sql方法
        int result = mapper.insertUser();

        // 接口重写的底层实现： 通过唯一标识找到sql并执行，唯一标识是namespace.sqlId
        // int result = sqlSession.insert("com.fd.mybatis.mapper.UserMapper.insertUser");

        System.out.println("结果：" + result);
        // 需要手动提交事务
        // sqlSession.commit();
        // 关闭会话
        sqlSession.close();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

2.7 加入log4j日志功能

1.添加依赖

    log4j
    log4j
    1.2.17

 2. 加入log4j的配置文件

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

日志的级别：从左到右打印的内容越来越详细

FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)

实现效果：

2.8 总结：

1. 创建Mybatis的核心配置文件
2. 创建mapper接口对象
3. 创建mapper接口映射文件（mapper接口的全类名和映射文件的namespace一致、mapper接口中的方法的方法名要和映射文件中的sql的id保持一致）
4. 创建测试方法

3.Mybatis核心配置文件讲解

3.1 引入properties文件

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

3.2 核心配置文件

3.3  代码框架结构

4.User对象数据库：增删改查

4.1 mapper接口对象

package com.fd.mybatis.mapper;

import com.fd.mybatis.pojo.User;

import java.util.List;

/**
 * @author 付东
 */
public interface UserMapper {

    /**
     * 新增用户
     *
     * @author lucky_fd
     * @return int
     **/
    int insertUser();

    /**
     * 修改用户
     *
     * @author lucky_fd
     * @return int
     **/
    int updateUser();

    /**
     * 删除用户
     *
     * @author lucky_fd
     * @return int
     **/
    int deleteUser();

    /**
     * 查询用户
     *
     * @author lucky_fd
     * @return com.fd.mybatis.pojo.User
     **/
    User getUserById();

    /**
     * 查询用户
     *
     * @author lucky_fd
     * @return java.util.List
     **/
    List selectUser();
}

4.2 mapper映射文件

    
    
        insert into t_user values('2','root','123456',23,'男','[email protected]')
    

    
        update t_user set password = 'qwer' where id = '1';
    

    
        delete from t_user where id = '1'
    

    
    
        select * from t_user where id = '1'
    

    
        select * from t_user
    

4.3 测试类

package com.fd.mybatis;

import static org.junit.Assert.assertTrue;

import com.fd.mybatis.mapper.UserMapper;
import com.fd.mybatis.pojo.User;
import com.fd.mybatis.utils.SqlSessionUtil;
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;

/**
 * Unit test for simple App.
 */
public class AppTest
{
    /**
     * Rigorous Test :-)
     */
    @Test
    public void shouldAnswerWithTrue()
    {
        assertTrue( true );
    }

    @Test
    public void mybatisAddTest() {
        try {
            // 获取核心配置文件的输入流
            InputStream stream = Resources.getResourceAsStream("mybatis_config.xml");
            // 获取SqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            // 获取SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(stream);
            // 获取sql的会话对象SqlSession（不会自动提交事务）,是Mybatis提供的操作数据的对象
            // SqlSession sqlSession = sqlSessionFactory.openSession();
            // 获取sql的会话对象SqlSession（会自动提交事务）
            SqlSession sqlSession = sqlSessionFactory.openSession(true);
            // 获取UserMapper的代理实现类,
            // 通过getMapper方法，重写接口方法：通过UserMapper的全类名来找到当前对象的映射文件，再通过要调用的方法找到要调用的sql语句

            /**
             * mapper接口和映射文件要保证两个一致:
             *         1，mapper接口的全类名和映射文件的namespace一致
             *         2、mapper接口中的方法的方法名要和映射文件中的sqL的d保持一致
             * */

            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            // 执行sql方法
            int result = mapper.insertUser();

            // 接口重写的底层实现： 通过唯一标识找到sql并执行，唯一标识是namespace.sqlId
            // int result = sqlSession.insert("com.fd.mybatis.mapper.UserMapper.insertUser");

            System.out.println("结果：" + result);
            // 需要手动提交事务
            // sqlSession.commit();
            // 关闭会话
            sqlSession.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    public void updateTest() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int result = mapper.updateUser();
        System.out.println("结果：" + result);
    }

    @Test
    public void deleteTest() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int result = mapper.deleteUser();
        System.out.println("结果：" + result);
    }

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

    @Test
    public void SelectAllUserTest() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List userList = mapper.selectUser();
        userList.forEach(user -> System.out.println(user.toString()));
    }
}

4.4 代码结构：

5.Mybatis获取参数值的方式

5.1 若mapper接口方法的参数为单个的字面量类型（推荐）

此时可以通过#{}和${}以任意的内容获取参数值，一定要注意${}的单引号问题

5.2 若mapper接口方法的参数为多个的字面量类型

此时MyBatis会将参数放在map集合中，以两种方式存储数据

a>以arg0,arg1...为键，以参数为值

b>以param1,param2..·为键，以参数为值

因此，只需要通过#{}和${}访map集合的键，就可以获取相对应的值，一定要注意${}的单引号问题

 5.3 若mapper接口方法的参数为map集合类型的参数

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

5.4 若mapper接口方法的参数为实体类类型的参数（推荐）

只需要通过#{}和${}访问实体类中的属性 就可以获取相对应的属性值，一定要注意${}的单引号问题

5.5 可以在mapper接口方法的参数上设置@Param注解（推荐）

此时MyBatis会将这些参数放在map中，以两种方式进行存储

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

b>以param1,param2...为键，以参数为值

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

6.Mybatis的查询功能

6.1 mapper接口对象

package com.fd.mybatis.mapper;

import com.fd.mybatis.pojo.User;
import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Param;

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

public interface SelectMapper {

    /*
    * 若sql语句查询的结果为多条时，一定不能以实体类类型作为方法的返回值,
    *       否则会抛出异常TooManyResultsException
    * 若sql语句查询的结果为1条时，此时可以使用实体类类型List集合类型作为方法的返回值
    *
    * */

    User getUserById(@Param("id") String id);

    List getAllUser();

    Integer getCount();

    Map getUserByIdToMap(String id);

    /**
     * 查询所有的用户为map集合
     *
     * 若查询的数据有多条时，并且要将每条数据转换为map集台
     * 此时有两种解决方案:
     *  1、将mapper接口方法的返回值设置为泛型是map的List集合
     *     List> getAllUserToMap();
     *  2、可以将每条数据转换的map集合放在一个大的map中，但是必须要通过@MapKey注解
     *      将查询的某个字段的值作为大的map的键
     *      @MapKey("id")
     *     Map getAllUserToMap();
     *
     * @author lucky_fd
     * @return java.util.Map
     **/
    @MapKey("id")
    Map getAllUserToMap(); // List> getAllUserToMap();

    /**
     * 通过用户名模糊查询
     *
     * @author lucky_fd
     * @param name 用户名
     * @return java.util.List
     **/
    List selectUserByLike(String name);
}

6.2 mapper映射文件

    
        select * from t_user where id = #{id}
    

    
        select * from t_user
    

    
    
        select count(*) from t_user
    

    
        select * from t_user where id = #{id}
    

    
        select * from t_user
    

    
    
        
        
        select * from t_user where name like "%"#{name}"%"
    

7.Mybatis 获取自增主键

7.1 接口对象方法

/**
 * 新增用户
 *
 * */
int insertUser(User user);

7.2 mapper映射文件

    insert into t_user values (null, #{name}, #{password}, #{age}, #{gender}, #{email})

7.3 测试方法

/**
 * 新增用户
 * 并返回自增主键
 * */
@Test
public void insertUserTest() {
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    User user = new User(null, "张三", "qesdf", 25, "男", "[email protected]");
    mapper.insertUser(user);
    // 返回自增ID
    System.out.println(user);
}

 测试结果：

​​​​​​​

8.resultMap自定义映射功能

8.1 实体类：

package com.fd.mybatis.pojo;

/**
 * SSM
 *
 * @author lucky_fd
 * @since 2023-05-22
 */

public class Dept {
    private String deptId;

    private String deptName;

    public Dept(String deptId, String deptName) {
        this.deptId = deptId;
        this.deptName = deptName;
    }

    public Dept() {
    }

    public String getDeptId() {
        return deptId;
    }

    public void setDeptId(String deptId) {
        this.deptId = deptId;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "deptId='" + deptId + '\'' +
                ", deptName='" + deptName + '\'' +
                '}';
    }
}


package com.fd.mybatis.pojo;

/**
 * SSM
 *
 * @author lucky_fd
 * @since 2023-05-22
 */

public class Emp {
    private String empId;

    private String name;

    private Integer age;

    private String gender;

    private Integer deptId;

    private Dept dept;

    public Emp() {
    }

    public Emp(String empId, String name, Integer age, String gender, Integer deptId) {
        this.empId = empId;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.deptId = deptId;
    }

    public String getEmpId() {
        return empId;
    }

    public void setEmpId(String empId) {
        this.empId = empId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Integer getDeptId() {
        return deptId;
    }

    public void setDeptId(Integer deptId) {
        this.deptId = deptId;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "empId='" + empId + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", deptId=" + deptId +
                ", dept=" + dept +
                '}';
    }

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
}

8.2 mapper接口对象

package com.fd.mybatis.mapper;

import com.fd.mybatis.pojo.Emp;

public interface EmpMapper {

    Emp getEmpById(String id);

    Emp getEmpAndDeptById(String id);
}



package com.fd.mybatis.mapper;

import com.fd.mybatis.pojo.Dept;

public interface DeptMapper {

    Dept getDeptById(String id);
}

 8.3 mapper配置文件

 8.4 mapper映射文件

    

    
    
        
        
        
        
        
    

    
    
        select * from t_emp where emp_id = #{id}
    

    
    
        
        
        
        
        
        
    

    
    
        
        
        
        
        
            
            
        
    

    
    
        
        
        
        
        
    

    
    
        select emp.*, d.* from t_emp emp left join t_dept d on emp.dept_id = d.dept_id where emp.emp_id = #{id}
    

    
    
        
        
        
            
            
            
            
        
    

    
        
        
        
    

    
        select * from t_dept where dept_id = #{id}
    

    
        select emp.*, d.* from t_emp emp right join t_dept d on emp.dept_id = d.dept_id where d.dept_id = #{id}
    

8.5 resultMap标签自定义映射

一个resultMap标签，就是对应着一个实体类。id就是他的名字，type就是他们的身体。实体类和对应表是一一对应的，实体类中每一个属性都对应着一个表中的字段。其中有个别属性上标明注解@TableField(exist = false)，其含义就是该属性在表中不存在，大多为引用的属性，引用的集合，或者是为了满足某种业务需求而声明的某种标志（比如sql多表查询时把某个表中的某个字段数据给另一个实体中某个属性赋值而起的别名）等等。

8.6 多对一映射处理方式

1.级联方式处理映射

2.association: 处理多对一得映射关系

3.分步查询

分步查询的优点:可以实现延迟加载

但是必须在核心配置文件中设置全局配置信息:

lazyLoadingEnabled: 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载

aggressiveLazyLoading: 当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载

此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sl。此时可通过assoiation和 collection中的fetchType属性设置当前的分步查询是否使用延迟加载，fetchType="lazy(延迟加载) || eager(立即加载)'

8.7 一对多映射处理方式

1.通过collection处理一对多映射

    
    
    
        
        
        
        
    



    select emp.*, d.* from t_emp emp right join t_dept d on emp.dept_id = d.dept_id where d.dept_id = #{id}

2.通过分步查询处理一对多映射

9.Mybatis动态SQL功能

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

9.1 if标签

通过test属性中的表达式判断标签中的内容是否有效(是否会拼接到sql中)

    and name = #{empName}

9.2 where标签

a.where标签中有条件成立，会自动生成where关健字

b.会自动将where标签中内容前多余的and去掉，但是其中内容后多余的and无法去掉

c.where标签中没有任何一个条件成立，则where没有任何功能

select * from t_emp

    
        and name = #{empName}
    
    
        and age = #{age}
    
    
        and gender = #{gender}
    

9.3 trim标签

prefix、suffix:在标签中内容前面或后面添加指定内容

prefixOverrides、suffixOverrides:在标签中内容前面或后面去掉指定内容

select * from t_emp

    
        name = #{empName} and
    
    
        age = #{age} and
    
    
        gender = #{gender} and
    

9.4 choose when otherwise 标签

相当于java中的if...else if...else，when至少设置一个，otherwise最多设置一个

select * from t_emp

    
        
            name = #{empName}
        
        
            age = #{age}
        
    

9.5 foreach标签

Mybatis中把list也是存在Map中，默认"list"是键名，list数据是值；Mybatis中数组也是存在Map中，默认"array"是键名，array数组数据是值。

collection:设置要循环的数组或集合

item:用一个字符串表示数组或集合中的每一个数据

separator:设置每次循环的数据之间的分隔符

open: 循环的所有内容以什么开始

close: 循环的所有内容以什么结束

    insert into t_emp values
    
        (null, #{emp.empName}, #{emp.age}, #(emp.gender}, null)
    



    delete from t emp where
    
        emp_id = #{empId]
    

9.6 sql片段标签

可以记录一段sql，在需要用的地方使用include标签进行引用

    emp_id, emp_name, age, gender, dept_id


select  from t_emp

10.Mybatis缓存

10.1 MyBatis的一级缓存

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

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

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

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

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

4)同一个SqlSession两次查询期间手动清空了缓存 sqlSession.clearCache();

案列演示：

@Test
public void getEmpByIdTest() {
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
    Emp emp = mapper.getEmpById("1");
    System.out.println(emp);
    Emp emp2 = mapper.getEmpById("1");
    System.out.println(emp2);
}

案列结果：

10.2  MyBatis的二级缓存

二级缓存是SqlSessionFactory级别，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取

二级缓存开启的条件:

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

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

c> 二级缓存必须在SqlSession关闭或提交之后有效

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

使二级缓存失效的情况:

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

案列演示：

@Test
public void cacheTest() throws IOException {
    InputStream io = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory sqlSessionFactory = builder.build(io);
    SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
    CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
    Emp emp = mapper1.getEmpById("1");
    System.out.println(emp);
    sqlSession1.close();
    SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
    CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
    Emp emp1 = mapper2.getEmpById("1");
    System.out.println(emp1);
    sqlSession2.close();
}

案列结果：

10.3 二级缓存的相关配置

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

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

• LRU(Least Recently Used) - 最近最少使用的: 移除最长时间不被使用的对象
• FIFO (First in First out) - 先进先出: 按对象进入缓存的顺序来移除它们。
• SOFT - 软引用: 移除基于垃圾回收器状态和软引用规则的对象
• WEAK - 弱引用: 更积极地移除基于垃圾收集器状态和弱引用规则的对象。

2.flushInterval属性: 刷新间隔，单位毫秒

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

3.size属性:引用数目，正整数

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

4.readOnly属性: 只读， true/false

• true: 只读缓存，会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
• false: 读写缓存;会返回缓存对象的拷贝 (通过序列化)。这会慢一些，但是安全，因此默认是 false.

10.4 MyBatis缓存查询的顺序

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

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

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

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

10.5 整合第三方缓存EHCache

1.添加依赖

  org.mybatis.caches
  mybatis-ehcache
  1.0.3



  ch.qos.logback
  logback-classic
  1.2.11

 2.各个jar包功能

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

4.Mapper配置文件设置二级缓存类型

5.加入logback日志

存在SLF4j时，作为简易日志的log4j将失效，此时我们需要借助SLF4j的具体实现logback来打印日志。创建logback的配置文件logback.xml

    
    
    
    
    
    
        UTF-8
        
        
            %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
        
    

    
    
        UTF-8
        
        ${LOG_HOME}/${appName}.log
        
        
            
            ${LOG_HOME}/${appName}-%d{yyyy-MM-dd}-%i.log
            
            
            30
            
            
                512MB
            
        
        
        
            %d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [%logger{50} : %line ] - %msg%n
        
    

    
    
    
    


    
    
        
        
    

 6.测试方法

@Test
public void cacheTest() throws IOException {
    InputStream io = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory sqlSessionFactory = builder.build(io);
    SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
    CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
    Emp emp = mapper1.getEmpById("1");
    System.out.println(emp);
    sqlSession1.close();
    SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
    CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
    Emp emp1 = mapper2.getEmpById("1");
    System.out.println(emp1);
    sqlSession2.close();
}

11.Mybatis分页功能实现

11.1 实现分页的方法

(1) MyBatis 使用 RowBounds 对象进行分页，它是针对 ResultSet 结果集执行的内存分页，而非物理分页；

(2) 可以在 sql 内直接书写带有物理分页的参数来完成物理分页功能，

(3) 也可以使用分页插件来完成物理分页。

11.2 RowBounds分页

@Test
public void pageByRowsBoundsTest() {
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();

    RowBounds rowBounds = new RowBounds(1, 2);
    List emps = sqlSession.selectList("com.fd.mybatis.mapper.EMPMapper.selectByExample", null, rowBounds);
    emps.forEach(System.out::println);
    sqlSession.close();

}

11.3 使用Limit分页

语法： select * from user limit startIndex,pageSize
select * from user limit 0,2;

 具体实现：

    select * from t_user limit #{startIndex},#{pageSize};

11.4 分页插件实现分页

1. 添加依赖

    com.github.pagehelper
    pagehelper
    5.3.0

 2. 配置分页插件

mybatis-config.xml配置文件添加分页插件

3. 分页插件的使用

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

pageNum:当前页的页码

pageSize:每页显示的条数

b.在查询获取list集合之后，使用Pagelnfo pagelnfo = new Pagelnfo<>(List list, int navigatePages)获取分页相关数据。

list:分页之后的数据

navigatePages: 导航分页的页码数

c.分页相关数据

Pagelnfo{

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]

4. 测试方法

@Test
public void pageTest() {
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    EMPMapper mapper = sqlSession.getMapper(EMPMapper.class);
    // 开启分页
    Page