MyBatis学习总结

一、MyBatis简介

官方文档连接

1. MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
2. Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回

二、MyBatis框架搭建

（一）、加载jar包（mybatis-3.2.7.jar和数据库驱动包）

（二）、创建接口

public interface IAreaDao {
    //如果参数为多个值时，需要用@Param进行映射
    String getName(@Param("id")String id);
}

（三）、创建测试类

public class Test {
    public static void main(String[] args) {
        //连接数据库测试
        //加载全局配置文件
        try{
            InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
            //SqlSession对象表示一次数据库连接
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            SqlSession sqlSession = sqlSessionFactory.openSession(true);//true,则自动提交事务；false，则需要手动commit进行提交事务
            //sqlSession获取接口的实现类对象,mybatis自动实现
            IAreaDao areaDao = sqlSession.getMapper(com.jd.area.IAreaDao.class);

            IPersonDao personDao = sqlSession.getMapper(com.jd.person.IPersonDao.class);
            String name = areaDao.getName("000f9a36-cdc1-4784-9ffc-fe1d8a4a0d15");
            System.out.println(name);
            /*
            //如果上面方法没有写true，手动提交事务
            sqlSession.commit();
            */
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

另一种方式：

public class main {
    public static void main(String[] args) throws IOException {

        //访问mybatis读取student数据

        //读取mybatis主配置文件的名称。
        InputStream in = Resources.getResourceAsStream("mybatis.xml");
        //创建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //创建SqlSessionFactory对象
        SqlSessionFactory factory = builder.build(in);
        //获取SqlSession对象，从SqlSessionFactory中获取SqlSession
        SqlSession sqlSession = factory.openSession();
        //指定要执行的sql语句表示。sql映射文件中的namespace+"."+标签的id值,***唯一标识***
        String sqlId = "org.example.dao.StudentDao.selectStudents";
        //执行sql语句，通过sqlId找到语句
        List<Student> studentList = sqlSession.selectList(sqlId);
        //输出结果
        System.out.println(studentList.size());
        studentList.forEach(student -> System.out.println(student));
        //关闭SqlSession对象
        sqlSession.close();
    }
}

 1 主要类的介绍
    1） Resources： mybatis中的一个类， 负责读取主配置文件
	  InputStream in = Resources.getResourceAsStream("mybatis.xml");

    2)SqlSessionFactoryBuilder : 创建SqlSessionFactory对象， 
	     SqlSessionFactoryBuilder builder  = new SqlSessionFactoryBuilder();
        //创建SqlSessionFactory对象
        SqlSessionFactory factory = builder.build(in);

    3）SqlSessionFactory ： 重量级对象， 程序创建一个对象耗时比较长，使用资源比较多。
        在整个项目中，有一个就够用了。

     SqlSessionFactory:接口  ， 接口实现类： DefaultSqlSessionFactory
	  SqlSessionFactory作用： 获取SqlSession对象。SqlSession sqlSession = factory.openSession();

	  openSession()方法说明：
	  1. openSession() ：无参数的， 获取是非自动提交事务的SqlSession对象
	  2. openSession(boolean): openSession(true)  获取自动提交事务的SqlSession. 
		                         openSession(false)  非自动提交事务的SqlSession对象

 
    4)SqlSession: 
    SqlSession接口 ：定义了操作数据的方法 例如 selectOne() ,selectList() ,insert(),update(), delete(), commit(), rollback()
    SqlSession接口的实现类DefaultSqlSession。

	使用要求： SqlSession对象不是线程安全的，需要在方法内部使用， 在执行sql语句之前，使用openSession()获取SqlSession对象。
	在执行完sql语句后，需要关闭它，执行SqlSession.close(). 这样能保证他的使用是线程安全的。

（四）、配置全局配置文件（mybatis-config.xml）

<?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>

    <!--全局配置文件-->

    <!--了解内容-->
    <settings>
        <!--开启驼峰式命名法-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

    <typeAliases>
        <!--为某个类起别名-->
        <typeAlias type="java.lang.String" alias="kaa"></typeAlias>
    </typeAliases>
    
    <environments default="dev"><!--指定当前的默认连接配置-->
        <!--配置数据库连接信息，可以配置多个信息，使用哪一个取决于id的指定-->
        <environment id="dev">
        	<!--
                transactionManager:mybatis的事务类型
                type：JDBC表示使用jdbc中的Connection对象的commit，rollback做事务处理
            -->
            <transactionManager type="JDBC"></transactionManager>
            <!--
                dataSource：表示数据源，连接数据库的
                type：表示数据源的类型，POOLED表示连接池的
            -->
            <dataSource type="POOLED">
                <property name="username" value="root"/>
                <property name="password" value="root"/>
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/test?serverTimezone=UTC"/>
                <!--数据库驱动包版本过高需要加上该句指定时区?serverTimezone=UTC-->
            </dataSource>
        </environment>

        <environment id="test">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="username" value="root"/>
                <property name="password" value="root"/>
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/test?serverTimezone=UTC"/>
            </dataSource>
        </environment>
    </environments>
    
    <mappers>
        <!--指定映射文件的位置-->
        <mapper resource="area.xml"></mapper>
        <mapper resource="person.xml"></mapper>
    </mappers>

</configuration>

（五）、配置映射文件

<?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">
<!--
1.指定约束文件
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
mybatis-3-mapper.dtd是约束文件的名称，扩展名是dtd的
2.约束文件作用：限制，检查在当前文件中出现的标签，属性必须符合mybatis的要求-->
<mapper namespace="com.jd.area.IAreaDao">
    <select id="getName" resultType="java.lang.String">
<!-- id的值是类中的方法名;parameterType:是传入方法的参数类型;
resultType:方法的返回值类型(注意:如果方法返回值是 list,在 resultType 中写 List 的泛型,
如果泛型为类,必须写类的全路径(包名+类名)因为 mybatis是对 jdbc 封装,一行一行读取数据) -->
        <!-- #{id}：从传递过来的参数中取出id值 -->
        select name from area where id = #{id}
    </select>
</mapper>

三、mybatis动态代理机制（待写）

四、Mybatis是封装的jdbc操作

<?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.jd.dao.StudentDao">
    <!--
       使用#{}之后， mybatis执行sql是使用的jdbc中的PreparedStatement对象
       由mybatis执行下面的代码：
        1. mybatis创建Connection ， PreparedStatement对象
           String sql="select id,name, email,age from student where id=?";
           PreparedStatement pst = conn.preparedStatement(sql);
           pst.setInt(1,1001);

        2. 执行sql封装为resultType="com.bjpowernode.domain.Student"这个对象
           ResultSet rs = ps.executeQuery();
           Student student = null;
           while(rs.next()){
              //从数据库取表的一行数据， 存到一个java对象属性中
              student = new Student();
              student.setId(rs.getInt("id));
              student.setName(rs.getString("name"));
              student.setEmail(rs.getString("email"));
              student.setAge(rs.getInt("age"));
           }

          return student;  //给了dao方法调用的返回值
   -->
    <select id="selectStudentById" parameterType="java.lang.Integer" resultType="com.jd.domain.Student">
        select id,name,email,age from student where id = #{id};
    </select>
</mapper>

五、mybatis参数

（一）、一个参数

public interface StudentDao {
    /**
     *一个简单类型参数：
     * 简单类型：mybatis吧java的基本数据类型和String都叫做简单类型
     * 在mapper文件获取简单类型的一个参数的值，使用#{任意字符}
     * 使用#{}之后，mybatis执行sql是使用的jdbc中的PreparedStatement对象
     */
    public Student selectStudentById(Integer id);
}

<select id="selectStudentById" parameterType="java.lang.Integer" resultType="com.jd.domain.Student">
        select id,name,email,age from student where id = #{id}; 
        <--此处#{id}中的id可以是任意的-->
</select>

（二）、 多个参数，使用@Param命名参数（推荐）

public interface StudentDao {
    List<Student> selectMultiParam(@Param("myname") String name,@Param("myage") Integer age);
}

<!--多个参数，使用@Param命名-->
<select id="selectMultiParam" resultType="com.jd.domain.Student">
	select id,name,email,age from student where name=#{myname} or age = #{myage};
</select>

（三）、多个参数，使用java对象

创建一个用于查询的java对象

public class QueryParam {
    private String paramName;
    private Integer paramAge;
    
    public void setParamName(String paramName) {
        this.paramName = paramName;
    }
    public void setParamAge(Integer paramAge) {
        this.paramAge = paramAge;
    }
}

public interface StudentDao {
    List<Student> selectMultiObject(QueryParam param);
}

<!--多个参数， 使用java对象的属性值，作为参数实际值
        使用对象语法： #{属性名,javaType=类型名称,jdbcType=数据类型} 很少用。
                    javaType:指java中的属性数据类型。
                    jdbcType:在数据库中的数据类型。
                    例如： #{paramName,javaType=java.lang.String,jdbcType=VARCHAR}

        我们使用的简化方式： #{属性名}  ，javaType, jdbcType的值mybatis反射能获取。不用提供
 -->
<select id="selectMultiObject" resultType="com.jd.domain.Student">
	select id,name,email,age from Student where name = #{paramName} or age = #{paramAge};
</select>

（四）、多个参数——按位置

public interface StudentDao {
    /**
     * 多个参数-简单类型的，按位置传值，
     * mybatis.3.4之前，使用 #{0} ，#{1}
     * mybatis。3.4之后 ，使用 #{arg0} ,#{arg1}
     */
    List<Student> selectMultiPosition(String name,Integer age);
}

<select id="selectMultiPosition" resultType="com.jd.domain.Student">
    select id,name,email,age from Student where name = #{arg0} or age = #{arg1};
</select>

（五）、多个参数，使用Map

public interface StudentDao {
    /**
     * 多个参数，使用Map存放多个值
     */
    List<Student> selectMultiByMap(Map<String,Object> map);
}

测试代码：

@org.junit.Test
public void testselectMultiByMap(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    StudentDao dao = sqlSession.getMapper(StudentDao.class);
    Map<String,Object> data = new HashMap<String,Object>();
    data.put("myname","张三");
    data.put("myage",18);
    List<Student> students = dao.selectMultiByMap(data);
    for(Student stu : students){
        System.out.println(stu);
    }
}

六、# 和 $区别

  1. #使用 ？在sql语句中做站位的， 使用PreparedStatement执行sql，效率高
  2. #能够避免sql注入，更安全。
  3. $不使用占位符，是字符串连接方式，使用Statement对象执行sql，效率低
  4. $有sql注入的风险，缺乏安全性。
  5. $:可以替换表名或者列名

$用于替换列名排序：

public interface StudentDao {
    //name表示用于排序的列名
    List<Student> selectUse$Order(@Param("name")String name);
}

<!--替换列名-->
<select id="selectMultiByMap" resultType="com.jd.domain.Student">
    select id,name,email,age from Student order by ${name};
</select>

测试代码：

@org.junit.Test
public void testselectUse$Order(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    StudentDao dao = sqlSession.getMapper(StudentDao.class);
    List<Student> students = dao.selectUse$Order("name");
    for(Student stu : students){
        System.out.println(stu);
    }
}

七、Mybatis输出结果

（一）、resultType结果类型

sql语句执行完毕后， 数据转为的java对象， java类型是任意的。
resultType结果类型的值 1. 类型的全限定名称 2. 类型的别名
例如 java.lang.Integer别名是int

处理方式：

1. mybatis执行sql语句， 然后mybatis调用类的无参数构造方法，创建对象。
2. mybatis把ResultSet指定列值付给同名的属性。

例：

• 简单类型

public int selectCountStudent();

<select id="selectCountStudent" resultType="int">
	select count(*) from student;
</select>

• 对象类型

public Student selectStudentById(Integer id);

<select id="selectStudentById" resultType="com.jd.domain.Student">
	select id,name,email,age from student where id = #{id};
</select>

Mybatis框架的处理：

• map类型：

//定义方法返回Map
Map<Object,Object>  selectMapById(Integer id);

<!--返回Map
1.列名是map的key，列值是map的value
2.最多只能返回一行记录，多余一行是错误的
-->
<select id="selectMapById" resultType="HashMap">
    select id,name,email,age from student where id = #{id};
</select>

测试代码：

@org.junit.Test
public void testselectMapById(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    StudentDao dao = sqlSession.getMapper(StudentDao.class);
    Map<Object,Object> map = dao.selectMapById(10001);
    System.out.println(map);
}

运行结果：

（二）、 定义自定义类型的别名的两种方式

• 方法一：使用typeAlias进行定义

在主配置文件中定义：

<typeAliases>
   <!--
        第一种方式：
        可以指定一个类型一个自定义别名
        type:自定义类型的全限定名称
        alias:别名（短小，容易记忆的）
    -->
    <typeAlias type="com.jd.domain.Student" alias="stu"/>
</typeAliases>

<select id="selectMultiParam" resultType="stu">
	select id,name,email,age from student where name=#{myname} or age = #{myage};
</select>

• 方法二：用package将该包下的所有类名定义别名，类名就是别名
  在主配置文件中定义：

<typeAliases>
   <!--
     第二种方式
     <package> name是包名， 这个包中的所有类，类名就是别名（类名不区分大小写）
   -->
    <package name="com.jd.domain"/>
</typeAliases>

<!--类名就是别名-->
<select id="selectMultiParam" resultType="Student">
   select id,name,email,age from student where name=#{myname} or age = #{myage};
</select>

注意：如果不同包中有相同的类名，并且都使用了该种定义的别名，则mabatis将不知道加载哪个类。

八、实体类属性名和列名不同

（一）、resultMap

• resultMap 可以自定义 sql 的结果和 java 对象属性的映射关系。更灵活的把列值赋值给指定属性。
• 常用在列名和 java 对象属性名不一样的情况
  注意：
  例：resultMap和resultType不要一起用，二选一

MyStudent类：

public class MyStudent {
    private int stuId;
    private String stuName;
    private String stuEmail;
    private int stuAge;
    public void setStuId(int stuId) {
        this.stuId = stuId;
    }
    @Override
    public String toString() {
        return "MyStudent{" +
                "stuId=" + stuId +
                ", stuName='" + stuName + '\'' +
                ", stuEmail='" + stuEmail + '\'' +
                ", stuAge=" + stuAge +
                '}';
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
    public void setStuEmail(String stuEmail) {
        this.stuEmail = stuEmail;
    }
    public void setStuAge(int stuAge) {
        this.stuAge = stuAge;
    }
}

接口方法：

List<MyStudent> selectAllMyStudents();

<!--使用resultMap
1.先定义resultMap
2.在select标签，使用resultMap来引用1定义的
-->
<!--定义resultMap
    id:自定义名称，表示你定义的这个resultMap
    type:java类型的全限定类名
-->
<resultMap id="studentMap" type="com.jd.domain.MyStudent">
    <!--列名和java属性的关系-->
    <!--主键列，使用id标签
        column:列名
        property:java类型的属性名
    -->
    <id column="id" property="stuId"/>
    <!--非主键列,使用result-->
    <result column="name" property="stuName"/>
    <result column="email" property="stuEmail"/>
    <result column="age" property="stuAge"/>
</resultMap>
<select id="selectAllMyStudents" resultMap="studentMap">
    select id,name,email,age from student;
</select>

（二）、例别名

当列名和属性名不一样的另一种解决办法：

<!--列名和属性名不一样，第二种方法
        resultType的默认原则是 同名的列值赋值给同名的属性，使用列别名(java对象的属性名)
    -->
<select id="selectAllMyStudents" resultType="com.jd.domain.MyStudent">
    select id as stuId,name as stuName,email as stuEmail,age as stuAge from student;
</select>

九、模糊查询的两种方式

以查询姓名中有李的为例：

（一）、在 java 代码中给查询数据加上“%”（推荐）

/*在java代码指定like的内容*/
List<Student> selectLikeOne(String name);

<!--第一种：java代码指定like的内容-->
<select id="selectLikeOne" resultType="com.jd.domain.Student">
    select id,name,email,age from student where name like #{name};
</select>

测试代码：

@org.junit.Test
public void testSelectLikeOne(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    StudentDao dao = sqlSession.getMapper(StudentDao.class);
    List<Student> students = dao.selectLikeOne("%李%");
    for(Student stu: students){
        System.out.println(stu);
    }
}

（二）、在 mapper 文件 sql 语句的条件位置加上“%”

/*name是李，在mapper中拼接like*/
List<Student> selectLikeTwo(String name);

<!--第二种：在mapper文件中拼接like的内容-->
<select id="selectLikeTwo" resultType="com.jd.domain.Student">
    select id,name,email,age from student where name like "%" #{name} "%";
</select>

测试代码：

@org.junit.Test
public void testSelectLikeTwo(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    StudentDao dao = sqlSession.getMapper(StudentDao.class);
    List<Student> students = dao.selectLikeTwo("李");
    for(Student stu: students){
        System.out.println(stu);
    }
}

十、动态sql

动态 SQL，主要用于解决查询条件不确定的情况：在程序运行期间，根据用户提交的查询条件进行查询。提交的查询条件不同，执行的 SQL 语句不同。

（一）、if

//动态sql，使用java对象作为参数
List<Student> selectStudentIf(Student student);

<!--if
  <if:test="条件">
        sql语句的部分
    </if>
-->
<select id="selectStudentIf" resultType="com.jd.domain.Student">
    select id,name,email,age from student where 1 = 1
    <if test="name != null and name !=''">
        and name = #{name}
    </if>
    <if test="age>0">
        and age > #{age}
    </if>
</select>

（二）、where

使用<where/>标签，在有查询条件时，可以自动添加上 where 子句；没有查询条件时，
不会添加where 子句。需要注意的是，第一个<if/>标签中的 SQL 片断，可以不包含 and。
不过，写上 and 也不错，系统会将多出的 and 去掉。但其它<if/>中 SQL 片断的 and，
必须要求写上。否则 SQL 语句将拼接出错
<where> 用来包含 多个<if>的， 当多个if有一个成立的， <where>会自动增加
一个where关键字，并去掉 if中多余的 and ，or等

（三）、foreach

1.遍历 List<简单类型>

<!--foreach使用:遍历 List<简单类型>
collection:表示接口中的方法参数的类型， 如果是数组使用array , 如果是list集合使用list
item:自定义的，表示数组和集合成员的变量
open:循环开始是的字符
close:循环结束时的字符
separator:集合成员之间的分隔符
-->
<select id="selectForeachOne" resultType="com.jd.domain.Student">
   select id,name,email,age from student
   <if test="list != null and list.size()>0">
       where id in
       <foreach collection="list" open="(" close=")" item="id" separator=",">
           #{id}
       </foreach>
   </if>
</select>

2.遍历List<对象类型>

<!--遍历 List<对象类型>-->
<select id="selectForeachTwo" resultType="com.jd.domain.Student">
    select id,name,email,age from student
    <if test="list != null and list.size()>0">
        where id in
        <foreach collection="list" open="(" close=")" item="stu" separator=",">
            #{stu.id}
        </foreach>
    </if>
</select>

（四）、代码片段

<sql/>标签用于定义 SQL 片断，以便其它 SQL 标签复用。而其它标签使用该 SQL 片断，
需要使用<include/>子标签。该<sql/>标签可以定义 SQL 语句中的任何部分，
所以<include/>子标签可以放在动态 SQL的任何位置

<!--定义代码片段-->
<sql id = "studentSql">
    select id,name,age,email from student
</sql>
<select id="selectStudentWhere" resultType="com.jd.domain.Student">
	/*引用代码片段*/
    <include refid="studentSql"/>/*效果等同于select id,name,email,age from student*/
    <where>
        <if test="name != null and name !=''">
            and name = #{name}
        </if>
        <if test="age>0">
            and age > #{age}
        </if>
    </where>
</select>

十一、Mybatis配置文件

（一）、数据库的属性配置文件：

作用：把数据库连接信息放到一个单独的文件中。 和mybatis主配置文件分开。 目的是便于修改，保存，处理多个数据库的信息。

1. 在resources目录中定义一个属性配置文件， xxxx.properties ,例如 jdbc.properties
   在属性配置文件中， 定义数据，格式是 key=value
   key： 一般使用 . 做多级目录的。
   例如：

     jdbc.driver=com.mysql.jdbc.Driver
     jdbc.url=jdbc:mysql//.....
     jdbc.username=root
     jdbc.password=123456
   

2. 在mybatis的主配置文件，使用< property>指定文件的位置在需要使用值的地方， ${key}

<?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文件的位置，从类路径根开始找文件-->
    <properties resource="jdbc.properties"/>
    <!--settings控制mybatis全局行为-->
    <settings>
        <!--设置mybatis输出日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <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.user}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--sql mapper(映射文件)的位置-->
    <mappers>
        <mapper resource="com/jd/dao/StudentDao.xml"/>
    </mappers>
</configuration>

（二）、mapper文件，使用package指定路径

<mappers>
	<!--第一种方式：一次指定一个mapper文件-->
	<mapper resource="com/jd/dao/StudentDao.xml"/>
	
	<!--第二种方式:使用包名
	name:xml文件(mapper文件)所在的包，这个包中所有xml文件一次都能加载给mybatis
	使用package的要求：
	    1. mapper文件名称需要和接口名称一样， 区分大小写的一样
	    2. mapper文件和dao接口需要在同一目录
	-->
	<package name="com.jd.domain"/>
</mappers>

（三）、配置日志功能

mybatis.xml 文件加入日志配置，可以在控制台输出执行的 sql 语句和参数

<settings>
<setting name="logImpl" value="STDOUT_LOGGING" />
</settings>

十二、PageHelper

步骤：

1. 加入maven依赖

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

2. 加入 plugin 配置插件（ 在environments 之前加入）

   <plugins>
   	<plugin interceptor="com.github.pagehelper.PageInterceptor" />
   </plugins>
   

   

3. 查询之前调用

   @Override
   public PageInfo<Admin> getPageInfo(String keyword, Integer pageNum, Integer pageSize) {
       // 1.调用PageHelper的静态方法开启分页功能
       // pageNum：第几页，从1开始
       // pageSize：一页中有多少行数据
       PageHelper.startPage(pageNum,pageSize);
       // 2.执行查询
       List<Admin> list = adminMapper.selectAdminListByKeyword(keyword); //返回的是Page类型的对象
       // 3.封装到PageInfo对象中
       return new PageInfo<>(list);//将其转换为PageInfo类型对象，添加pageNum、pageSize、Total等属性
   }