MyBatis基础

MyBatis概述

（1）MyBatis 是一款优秀的持久层框架，内部对 JDBC 代码进行了封装，使开发者只需要关注 SQL 语句本身，不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程

（2）MyBatis可以使用XML或注解，来配置SQL语句和参数映射关系，将POJO映射为数据库中的记录，避免了JDBC代码和手动设置参数以及获取结果集

ORM思想

ORM（Object Relational Mapping）是一种编程思想，它的主要目标是将关系数据库中的数据表映射到面向对象编程语言的类和对象上

Java概念数据库概念
类表
类中属性字段/列
类的对象记录/行

持久化层技术对比

持久化层技术简介
JDBC代码冗长，开发效率低，耦合度高，不易维护，硬编码，操作繁琐
Hibernate 和 JPA操作简便，开发效率高，内部自动生产的 SQL，不容易做特殊优化，反射操作太多，导致数据库性能下降
MyBatis轻量级，性能出色，开发效率稍逊于HIbernate，但是完全能够接受

MyBatis核心配置文件

核心配置文件中的标签，必须按照固定的顺序：properties—>settings—>typeAliases—>typeHandlers—>objectFactory—>objectWrapperFactory—>refl ectorFactory—>plugins—>environments—>databaseIdProvider—>mappers

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
<?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>

    <!--
        MyBatis核心配置文件中，标签的顺序：
        properties?,settings?,typeAliases?,typeHandlers?,
        objectFactory?,objectWrapperFactory?,reflectorFactory?,
        plugins?,environments?,databaseIdProvider?,mapper?
    -->

    <!-- ======================================引入properties文件====================================-->
    <!-- 引入后可以在文件中使用${key}的方式，访问properties文件中的value -->
    <properties resource="jdbc.properties"/>

  <!-- ===================================全局配置信息 ================================== -->
  <settings>
    <!-- 自动将下划线映射为驼峰 -->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
    <!-- 开启延迟加载-->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!-- 按需加载-->
    <setting name="aggressiveLazyLoading" value="false"/>
  </settings>
    <!-- ======================================设置类型别名===================================-->
    <typeAliases>
        <!-- typeAlias标签：设置某个类型的别名 -->
        <!-- type属性：设置需要设置别名的类型 -->
        <!-- alias属性：设置某个类型的别名，若不设置alias属性，那么当前类型拥有默认的别名，即类名且不区分大小写 -->
        <!-- <typeAlias type="pojo.User"></typeAlias> -->

        <!-- package标签：以包为单位，将包下所有的类型设置默认的类型别名，即类名且不区分大小写-->
        <package name="pojo"/>
    </typeAliases>

    <!-- ======配置多个连接数据库的环境，可以配置多个environment，通过default属性切换不同的environment===== -->
    <!-- default属性：设置默认使用的环境的id-->
    <environments default="development">
        <!-- environment标签：配置某个具体的环境 -->
        <!-- id属性：表示连接数据库的环境的唯一标识，不能重复-->
        <environment id="development">
            <!-- transactionManager标签：设置事务管理方式 -->
            <!-- type属性：type="JDBC|MANAGED"-->
            <!-- type="JDBC"：表示当前环境中，执行SQL时，使用的是JDBC中原生的事务管理方式，事务的提交或回滚需要手动处理-->
            <!-- type="MANAGED"：被管理，例如被Spring管理 -->
            <transactionManager type="JDBC"/>

            <!-- dataSource标签：配置数据源-->
            <!-- type="POOLED|UNPOOLED|JNDI"：设置数据源的类型-->
            <!-- type="POOLED"：表示使用数据库连接池缓存数据库连接-->
            <!-- type="UNPOOLED"：表示不使用数据库连接池-->
            <!-- type="JNDI"：表示使用上下文中的数据源-->
            <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.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="mapper/UserMapper.xml"/>-->

        <!-- 以包为单位引入映射文件 -->
        <!--要求1：mapper接口所在的包，要和映射文件所在的包一致-->
        <!--要求2：mapper接口的名字，要和映射文件的名字一致-->
        <package name="mapper"/>
    </mappers>
</configuration>

MyBatis获取参数值

MyBatis获取参数值的两种方式

方式简介
#{参数名}本质是占位符赋值（?），
#{}使用占位符赋值的方式拼接sql，为字符串类型或日期类型的字段进行赋值时，自动添加单引号；
${参数名}本质是字符串拼接，
${}使用字符串拼接的方式拼接sql，为字符串类型或日期类型的字段进行赋值时，手动添加单引号；

使用@Param注解标识参数

实体类类型的参数不使用@Param、其他参数可使用@Param标识参数

（1）通过@Param注解标识mapper接口中的方法参数，MyBatis以两种方式，自动将这些参数放在一个map集合中存储数据，只需要通过${}和#{}访问map集合的键就可以获取相对应的值（注意${}需要手动加单引号）

方式简介
方式一以@Param注解的value属性值为键，以参数为值
方式二以param1,param2…为键，以参数为值

（2）使用 @Param(“参数名称”) 标记每一个参数

1
User checkloginByParam(@Param("username") String username, @Param("password") String password);

（3）在映射配置文件中就需要使用 #{参数名称} 进行占位

1
2
3
<select id="checkloginByParam" resultType="User">
    select * from t_user where username = #{username} and password = #{password}
</select>

MyBatis的各种功能

查询一个实体类对象

（1）接口中的方法

1
2
// 根据用户id查询用户信息
User getUserById(@Param("id") int id);

（2）对应的映射文件

1
2
3
4
<!--User getUserById(@Param("id") int id);-->
<select id="getUserById" resultType="User">
	select * from t_user where id = #{id}
</select>

（3）测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
public void getUserById() {
    // 调用工具类SqlSessionUtil中的静态方法静态方法getSqlSession()，获取MyBatis提供的操作数据库的会话对象SqlSession
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    // 获取UserMapper的代理实现类对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    // 使用实现类对象，调用Mapper接口的方法
    User userById = mapper.getUserById(1);
    System.out.println(userById);

    // 关闭sqlSession对象
    sqlSession.close();
}

查询一个List集合

（1）接口中的方法

1
2
// 查询所有用户信息
List<User> getUserList();

（2）对应的映射文件

1
2
3
4
<!--List<User> getUserList();-->
<select id="getUserList" resultType="User">
	select * from t_user
</select>

（3）测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void getUserList() {
    // 调用工具类SqlSessionUtil中的静态方法静态方法getSqlSession()，获取MyBatis提供的操作数据库的会话对象SqlSession
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    // 获取UserMapper的代理实现类对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    // 使用实现类对象，调用Mapper接口的方法
    List<User> userList = mapper.getUserList();
    System.out.println(userList);
    userList.forEach(System.out::println);

    // 关闭sqlSession对象
    sqlSession.close();
}

查询单个数据

（1）接口中的方法

1
2
// 查询用户的总记录数
int getCount();

（2）对应的映射文件

1
2
3
4
<!--int getCount();-->
<select id="getCount" resultType="_integer">
	select count(id) from t_user
</select>

（3）测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
public void getCount() {
    // 调用工具类SqlSessionUtil中的静态方法静态方法getSqlSession()，获取MyBatis提供的操作数据库的会话对象SqlSession
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    // 获取UserMapper的代理实现类对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    // 使用实现类对象，调用Mapper接口的方法
    int count = mapper.getCount();
    System.out.println(count);

    // 关闭sqlSession对象
    sqlSession.close();
}

查询一条数据为map集合

（1）接口中的方法

1
2
// 根据用户id查询用户信息为map集合
Map<String, Object> getUserToMap(@Param("id") int id);xxxxxxxxxx // 根据用户id查询用户信息为map集合Map<String, Object> getUserToMap(@Param("id") int id);// 查询用户的总记录数int getCount();

（2）对应的映射文件

1
2
3
4
<!--Map<String, Object> getUserToMap(@Param("id") int id);-->
<select id="getUserToMap" resultType="map">
	select * from t_user where id = #{id}
</select>

（3）测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void getUserToMap() {
    // 调用工具类SqlSessionUtil中的静态方法静态方法getSqlSession()，获取MyBatis提供的操作数据库的会话对象SqlSession
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    // 获取UserMapper的代理实现类对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    // 使用实现类对象，调用Mapper接口的方法
    Map<String, Object> userToMap = mapper.getUserToMap(1);
    System.out.println(userToMap);
    // {password=123456, gender=男, id=1, age=18, email=123@qq.com, username=张三}
    
    // 关闭sqlSession对象
    sqlSession.close();
}

查询多条数据为map集合

（1）接口中的方法

1
2
3
4
5
// 方法一：
List<Map<String, Object>> getAllUserToMap_1();
// 方法二：
@MapKey("id")
Map<String, Object> getAllUserToMap_2();

（2）对应的映射文件

1
2
3
4
5
6
7
8
<!-- List<Map<String, Object>> getAllUserToMap_1(); -->
<select id="getAllUserToMap_1" resultType="map">
	select * from t_user
</select>
<!-- Map<String, Object> getAllUserToMap_2(); -->
<select id="getAllUserToMap_2" resultType="map">
	select * from t_user
</select>

（3）测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Test
public void getAllUserToMap() {
    // 调用工具类SqlSessionUtil中的静态方法静态方法getSqlSession()，获取MyBatis提供的操作数据库的会话对象SqlSession
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    // 获取UserMapper的代理实现类对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    // 使用实现类对象，调用Mapper接口的方法
    // 查询所有用户信息为map集合方式一
    List<Map<String, Object>> allUserToMap_1 = mapper.getAllUserToMap_1();
    System.out.println(allUserToMap_1);
    
    // 查询所有用户信息为map集合方式二
    Map<String, Object> allUserToMap_2 = mapper.getAllUserToMap_2();
    System.out.println(allUserToMap_2);

    // 关闭sqlSession对象
    sqlSession.close();
}

模糊查询

（1）接口中的方法

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

（2）对应的映射文件

1
2
3
4
5
6
7
8
9
<!--List<User> getUserByLike(@Param("mohu") String mohu);-->
<select id="getUserByLike" resultType="User">
    <!-- 方式一：利用${} -->
    <!-- select * from t_user where username like '%${mohu}%' -->
    <!-- 方式二：利用mysql函数concat()字符串拼接-->
    <!-- select * from t_user where username like concat('%',#{mohu},'%') -->
    <!-- 方式三（最常用的）-->
    select * from t_user where username like "%"#{mohu}"%"
</select>

（3）测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void getUserByLike() {
    // 调用工具类SqlSessionUtil中的静态方法静态方法getSqlSession()，获取MyBatis提供的操作数据库的会话对象SqlSession
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    // 获取UserMapper的代理实现类对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    // 使用实现类对象，调用Mapper接口的方法
    List<User> listroot = mapper.getUserByLike("root");
    System.out.println(listroot);
    listroot.forEach(System.out::println);

    // 关闭sqlSession对象
    sqlSession.close();
}

批量删除

（1）接口中的方法

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

（2）对应的映射文件

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

（3）测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//测试类
@Test
public void deleteMore() {
    // 调用工具类SqlSessionUtil中的静态方法静态方法getSqlSession()，获取MyBatis提供的操作数据库的会话对象SqlSession
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    // 获取UserMapper的代理实现类对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    // 使用实现类对象，调用Mapper接口的方法
    int result = mapper.deleteMore("1,2,3,8");
    System.out.println(result);

    // 关闭sqlSession对象
    sqlSession.close();
}

动态查询指定表名

（1）接口中的方法

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

（2）对应的映射文件

1
2
3
4
5
<!--List<User> getUserByTable(@Param("tableName") String tableName);-->
<!-- 只能使用${}，因为表名不能加单引号 -->
<select id="getUserByTable" resultType="User">
	select * from ${tableName}
</select>

（3）测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void getUserByLike() {
    // 调用工具类SqlSessionUtil中的静态方法静态方法getSqlSession()，获取MyBatis提供的操作数据库的会话对象SqlSession
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    // 获取UserMapper的代理实现类对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    // // 使用实现类对象，调用Mapper接口的方法
    List<User> t_user = mapper.getUserByTable("t_user");
    System.out.println(t_user);
    t_user.forEach(System.out::println);

    // 关闭sqlSession对象
    sqlSession.close();
}

添加功能获取自增的主键

需要先在mapper.xml中设置两个属性

属性简介
useGeneratedKeys设置使用自增的主键
keyProperty因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中

（1）接口中的方法

1
2
// 添加用户信息，获取自增的主键（默认的添加返回值是）
void insertUser(User user);

（2）对应的映射文件

1
2
3
4
5
6
<!--void insertUser(User user);-->
<!-- useGeneratedKeys：设置使用自增的主键-->
<!-- keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中-->
<insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
	insert into t_user values(null,#{username},#{password},#{gender},#{age},#{email})
</insert>

（3）测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void insertUser() {
    // 调用工具类SqlSessionUtil中的静态方法静态方法getSqlSession()，获取MyBatis提供的操作数据库的会话对象SqlSession
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    // 获取UserMapper的代理实现类对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    User user = new User(null, "tom", "123", "男", 18, "123@321.com");
    mapper.insertUser(user);
    System.out.println(user);
    // 输出：User{id=3, username='tom', password='123', gender='男', age=18, email='123@321.com'}
    // 作用：如果不设置，需要再次与数据库交互，查询数据库才能得知用户id
    // 关闭sqlSession对象
    sqlSession.close();
}

MyBatis映射关系处理

什么是映射关系？

Java概念数据库概念
类表
属性字段/列
对象记录/行

如果数据库中的字段名和实体类中的属性名不一致，如何解决映射？

方案简介
方案一查询时为字段起别名，保证与实体类中的属性名保持一致
方案二使用MyBatis的核心配置文件设置全局配置，自动将下划线映射为驼峰
方案三使用resultMap自定义映射关系

别名或全局配置方式处理

（1）数据库中的字段，符合Mysql的命名规范使用下划线（_）

（2）实体类中的属性，符合java驼峰命名规范

1
2
3
4
5
6
public class Emp {
    private Integer empId;
    private String empName;
    private Integer age;
    private String gender;
}

（3）此时可以使用MyBatis的核心配置文件设置全局配置，自动将下划线映射为驼峰

1
2
3
<settings>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

（4）接口中的方法

1
2
// 根据id查询员工信息（不含部门dept）
Emp getEmpByEmpId_1(@Param("empId") Integer empId);

（5）对应的映射文件

1
2
3
4
5
6
<select id="getEmpByEmpId_1" resultType="Emp">
     <!-- 数据库字段名和实体类中的属性名不一致，使用别名解决 -->
     <!-- select emp_id as empId,emp_name as empName,age,gender from t_emp where emp_id = #{empId} -->
     <!-- 数据库字段名和实体类中的属性名不一致，使用配置文件映射解决 -->
     select * from t_emp where emp_id = #{empId}
</select>

（6）测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
public void getEmpByEmpId(){
    // 调用工具类SqlSessionUtil中的静态方法静态方法getSqlSession()，获取MyBatis提供的操作数据库的会话对象SqlSession
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    // 获取UserMapper的代理实现类对象
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);

    // 使用实现类对象，调用Mapper接口的方法
    Emp empByEmpId_1 = mapper.getEmpByEmpId_1(1);
    System.out.println(empByEmpId_1);

    // 关闭sqlSession对象
    sqlSession.close();
}

resultMap自定义映射关系

（1）接口中的方法

1
2
// 根据id查询员工信息（不含部门dept）
Emp getEmpByEmpId_2(@Param("empId") Integer empId);

（2）对应的映射文件，使用resultMap标签设置自定义映射关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<!-- resultMap标签：设置自定义映射-->
<!-- id属性：表示自定义映射的唯一标识，不能重复-->
<!-- type属性：查询的数据要映射的实体类的类型-->
<resultMap id="EmpByEmpId_2" type="Emp">
     <!-- id标签：设置主键的映射关系  -->
     <!-- result标签：设置普通字段的映射关系 -->
     <!-- column属性：设置映射关系中表中的字段名-->
     <!-- property属性：设置映射关系中实体类中的属性名-->
     <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>

<!-- List<Emp> getAllEmp(); -->
<select id="getEmpByEmpId_2" resultMap="EmpByEmpId_2">
	select * from t_emp where emp_id = #{empId}
</select>

（3）测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
public void getEmpByEmpId(){
    // 调用工具类SqlSessionUtil中的静态方法静态方法getSqlSession()，获取MyBatis提供的操作数据库的会话对象SqlSession
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    // 获取UserMapper的代理实现类对象
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);

    // 使用实现类对象，调用Mapper接口的方法
    Emp empByEmpId_2 = mapper.getEmpByEmpId_2(1);
    System.out.println(empByEmpId_2);

    // 关闭sqlSession对象
    sqlSession.close();
}

MyBatis动态SQL

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

if、where

1
2
3
4
5
6
7
8
9
<select id="getEmpByCondition_where" resultType="Emp">
    select * from t_emp
    <where>
        <!-- 如果员工名不为null且不为空字符串-->
        <if test="empName != null and empName !=''">
            emp_name=#{empName}
        </if>
    </where>
</select>

trim

1
2
3
4
5
6
7
8
9
10
11
12
13
<select id="getEmpByCondition_trim" resultType="Emp">
    select * from t_emp
    <trim prefix="where" prefixOverrides="and">
        <!-- 如果员工名不为null且不为空字符串-->
        <if test="empName != null and empName !=''">
            emp_name=#{empName}
        </if>
        <!-- 如果员工年龄不为null且不为空字符串-->
        <if test="age != null and age !=''">
            and age=#{age}
        </if>
    </trim>
</select>

choose、when、otherwise

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<select id="getEmpBychoose_cwo" 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>

foreach

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<!--批量添加-->
<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="deleteMoreEmpByArray">
    delete from t_emp where emp_id in
    <foreach collection="empIds" item="eid" separator="," open="(" close=")">
        #{eid}
    </foreach>
</delete>

<!--批量删除方式二-->
<delete id="deleteMoreEmpByArray">
    delete from t_emp where
    <foreach collection="empIds" item="eid" separator="or">
    emp_id = #{eid}
    </foreach>
</delete>

sql片段

1
2
3
4
5
6
7
8
<!--定义公共sql片段-->
<sql id="testsql">
    emp_id,emp_name,age,gender,dept_id
</sql>
<!--使用公共sql片段-->
<select id="selectAllEmp" resultType="Emp">
    select <include refid="testsql"></include> from t_emp
</select>

分页插件

常用数据

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

使用前提

（1）在pom文件中，添加分页插件依赖

1
2
3
4
5
6
<!-- 分页依赖 -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.2.0</version>
</dependency>

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

1
2
3
4
<!-- ========================设置分页插件============================= -->
<plugins>
    <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

分页插件的使用

（1）测试使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Test
public void Test() {
    // 调用工具类SqlSessionUtil中的静态方法静态方法getSqlSession()，获取MyBatis提供的操作数据库的会话对象SqlSession
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    // 获取UserMapper的代理实现类对象
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);

    // 在查询功能之前开启分页（当前页2，每页5条数据）
    Page<Object> objects = PageHelper.startPage(2, 5);

    // 查询所有数据
    List<Emp> emps = mapper.selectByExample(null);
    emps.forEach(System.out::println);

    // 查询功能之后，可以获得分页相关的所有数据
    PageInfo<Emp> empPageInfo = new PageInfo<>(emps, 5);
    System.out.println(empPageInfo);

    // 关闭sqlSession对象
    sqlSession.close();
}

（2）使用案例

1
2
3
4
5
6
7
8
9
10
// 根据当前页码获取分页相关数据
public PageInfo<Emp> getEmpPage(Integer pageNum) {
    // 在查询功能之前开启分页（当前页码，每页5条数据）
    PageHelper.startPage(pageNum, 5);
    // 查询所有数据
    List<Emp> list = empMapper.getAll();
    // 查询功能之后，可以获得分页相关的所有数据
    PageInfo<Emp> page = new PageInfo<>(list, 5);
    return page;
}

MyBatis注解开发

（1）注解是用来替换映射配置文件方式配置的，使用注解开发会比配置文件开发更加方便，但对应复杂开发需要使用配置文件

（2）注解完成简单功能（增删改查），配置文件完成复杂功能（动态SQL），针对 CURD 操作都提供了对应的注解

操作注解
查询@Select(value = “sql语句”)
添加@Insert(value = “sql语句”)
修改@Update(value = “sql语句”)
删除@Delete(value = “sql语句”)

（3）@Select注解使用案例，其他注解类似

1
2
@Select(value = "select * from tb_user where id = #{id}")
public User select(int id);