Mybatis入门---超详细

目录

Mybatis------>ORM框架

1. 什么是ORM？

2. 怎么使用Mybatis？

3. 链表查询---多对一链表查询

4. 链表查询 --->  一对多链表查询

5.动态SQL语句

6. 模糊查询  like关键字

7. 分页插件--PageHelper

---

Mybatis------>ORM框架

        MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录。

        mybatis就是封装与数据库交互的半成品。

1. 什么是ORM？

        ORM，即Object-Relational Mapping（对象关系映射），它的作用是在关系型数据库和业务实体对象之间作一个映射，这样，我们在具体的操作业务对象的时候，就不需要再去和复杂的SQL语句打交道，只需简单的操作对象的属性和方法.。

2. 怎么使用Mybatis？

        ①创建一个mavenJava工程:

        

 

 

 创建完成后的样子:

         ②:引入mybatis的jar包 和 MySQL的jar包:

    <dependencies>
        <!--mysql驱动依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
        <!--mybatis的依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <!--简化实体类中的set和get方法以及tostring方法和构造方法。-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
    </dependencies>

 1.2.1在本地虚拟机mysql上创建一个库,并在里面创建一个staff员工表,并在里面填写数据

 1.2.2创建一个员工实体类Staff 和员工的Dao类

package com.zhl.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @program: HellowMybatis
 * @description:
 * @author: 张会理
 * @create: 2021-12-03 14:51
 **/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Staff {

    private Integer staffid;//员工的id

    private String staffname;//员工的姓名

    private String staffsex;//员工的性别

    private Integer deptid;//员工的部门编号

    public Staff(String staffname, String staffsex, Integer deptid) {
        this.staffname = staffname;
        this.staffsex = staffsex;
        this.deptid = deptid;
    }
}

package com.zhl.dao;

import com.zhl.entity.Staff;

import java.util.List;

public interface StaffDao {
    int insertstaff(Staff staff);//添加员工
    int deletestaff(int staffid);//删除员工
    int updatestaff(int staffid);//修改员工信息
    List<Staff> selectallstaff();//查找所有员工
    List<Staff> selectonestaff(int staffid);//根据id查找一个员工
}

 1.2.3 编写数据源properties文件

jdbc.url=jdbc:mysql://localhost:3306/zhl?serverTimezone=Asia/Shanghai
jdbc.driverName=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=

 1.2.4 在resources中创建一个mapper文件夹并在里面存放mapper映射文件(编写SQL)

<?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">
<!--namespace:命名空间:它的值现在可以随便写。
以后必须和dao接口对应。
-->
<!--namespace:读取所写的Dao路径-->
<mapper namespace="com.zhl.dao.StaffDao">
    <!--type: 类型 表与哪个实体类的映射
        autoMapping=true   表示自动映射。默认为true
    -->
    <resultMap id="Map01" type="com.zhl.entity.Staff" autoMapping="true">
        <!--id 唯一标识 主键的映射关系 必须写！！！
            property="属性名"===实体类自己写的列名
            column="列名"===数据库列名
            result 普通字段
        -->
        <id property="staffid" column="staff_id"/>
        <result property="staffname" column="staff_name"/>
        <result property="staffsex" column="staff_sex"/>
        <result property="deptid" column="dept_id"/>
    </resultMap>
    <!--添加员工-->
    <!--这里的id必须和Dao中的方法名一致-->
    <insert id="insertstaff">
        insert into staff values(null,#{staffname},#{staffsex},#{deptid})
    </insert>
    <!--删除员工-->
    <!--这里的id必须和Dao中的方法名一致-->
    <delete id="deletestaff">
        delete from staff where staff_id=#{staffid}
    </delete>
    <!--修改员工-->
    <!--这里的id必须和Dao中的方法名一致-->
    <update id="updatestaff">
        update staff set staff_name=#{staffname},staff_sex=#{staffsex},dept_id=#{deptid} where dept_id=#{deptid}
    </update>
    <!--查询所有员工-->
    <!--这里的id必须和Dao中的方法名一致-->
    <select id="selectallstaff" resultMap="Map01">
        select * from staff
    </select>
    <!--根据员工id查询员工-->
    <!--这里的id必须和Dao中的方法名一致-->
    <select id="selectonestaff" resultMap="Map01">
        select * from staff where staff_id=#{staffid}
    </select>
</mapper>

1.2.5 配置mybatis的配置文件---mybatis会读取该文件的内容完成连接数据库的功能。 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--配置文件信息-->
    <properties resource="mysqllogin.properties"/>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <!--从配置文件中加载属性-->
                <property name="driver" value="${jdbc.driverName}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--这里是加载编写的SQL语句文件路径-->
    <mappers>
        <mapper resource="mapper/StaffMapper.xml"/>
    </mappers>
</configuration>

1.2.6测试:

package StaffTest;

import com.zhl.dao.StaffDao;
import com.zhl.entity.Staff;
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.Before;
import org.junit.Test;

import java.io.Reader;
import java.util.List;

/**
 * @program: HellowMybatis
 * @description:
 * @author: 张会理
 * @create: 2021-12-03 15:17
 **/
public class staffTest {
    SqlSession session;
    @Before
    public void bf() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(reader);
        session = build.openSession();
    }
    //添加员工
    @Test
    public void insertstaff(){
        StaffDao mapper = session.getMapper(StaffDao.class);
        Staff staff = new Staff("添加的","男",2);
        mapper.insertstaff(staff);
        session.commit();
    }
    //删除员工
    @Test
    public void deletestaff(){
        StaffDao mapper = session.getMapper(StaffDao.class);
        mapper.deletestaff(6);
        session.commit();
    }
    //修改员工
    @Test
    public void updatestaff(){
        StaffDao mapper = session.getMapper(StaffDao.class);
        Staff staff = new Staff(7, "修改的", "女", 2);
        mapper.updatestaff(staff);
        session.commit();
    }
    //查询所有员工
    @Test
    public void selectallstaff(){
        StaffDao mapper = session.getMapper(StaffDao.class);
        List<Staff> selectallstaff = mapper.selectallstaff();
        System.out.println(selectallstaff);
    }
    //查询一个员工
    @Test
    public void selectonestaff(){
        StaffDao mapper = session.getMapper(StaffDao.class);
        List<Staff> selectonestaff = mapper.selectonestaff(6);
        System.out.println(selectonestaff);
    }
}

3. 链表查询---多对一链表查询

例子 : 根据员工id查询员工信息以及员工所属部门信息

在mysql创建dept部门表

 第一种多对一方法: 通过链表查询:

1.创建部门实体类

package com.zhl.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @program: HellowMybatis
 * @description:
 * @author: 张会理
 * @create: 2021-12-03 16:07
 **/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Dept {
    private Integer deptid;
    private String deptname;

    public Dept(String deptname) {
        this.deptname = deptname;
    }
}

2.在员工Staff实体类添加 Dept部门属性对象

package com.zhl.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @program: HellowMybatis
 * @description:
 * @author: 张会理
 * @create: 2021-12-03 14:51
 **/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Staff {

    private Integer staffid;//员工的id

    private String staffname;//员工的姓名

    private String staffsex;//员工的性别

    private Integer deptid;//员工的部门编号

    private Dept dept;//Dept部门属性对象

    public Staff(String staffname, String staffsex, Integer deptid) {
        this.staffname = staffname;
        this.staffsex = staffsex;
        this.deptid = deptid;
    }
}

3.编写mapper映射文件

<resultMap id="Map02" type="com.zhl.entity.Staff" autoMapping="true">
        <!--id 唯一标识 主键的映射关系 必须写！！！
            property="属性名"===实体类自己写的列名
            column="列名"===数据库列名
            result 普通字段
        -->
        <id property="staffid" column="staff_id"/>
        <result property="staffname" column="staff_name"/>
        <result property="staffsex" column="staff_sex"/>
        <result property="deptid" column="dept_id"/>
        <!--association:表示多对一
            property:表示在Staff实体类中写的Dept对象属性名
            javaType:表示该对象所属的实体类类型
            autoMapping:表示自动映射
        -->
        <association property="dept" javaType="com.zhl.entity.Dept" autoMapping="true">
            <id property="deptid" column="dept_id"/>
            <result property="deptname" column="dept_name"/>
        </association>
    </resultMap>

    <select id="selectSD" resultMap="Map02">
        select * from staff s join dept d on s.dept_id=d.dept_id where s.staff_id=#{staffid}
    </select>

4.测试:

//根据员工id查询员工信息和员工所属部门信息
    @Test
    public void selectSD(){
        StaffDao mapper = session.getMapper(StaffDao.class);
        Staff staff = mapper.selectSD(5);
        System.out.println(staff);
    }

第二种多对一方法: 通过嵌套查询。----两次查询。

1.编写部门Dao类

package com.zhl.dao;

import com.zhl.entity.Dept;

public interface DeptDao {
    Dept selectById(int deptid);
}

2.编写员工Dao类方法

package com.zhl.dao;

import com.zhl.entity.Staff;

import java.util.List;

public interface StaffDao {

    int insertstaff(Staff staff);//添加员工

    int deletestaff(int staffid);//删除员工

    int updatestaff(Staff staff);//修改员工信息

    List<Staff> selectallstaff();//查找所有员工

    List<Staff> selectonestaff(int staffid);//根据id查找一个员工

    Staff selectSD(int staffid);//查询员工和部门信息--多对一链表查询 第一种方法

    Staff selectSD2(int staffid);//查询员工和部门信息--多对一链表查询 第二种方法
}

3.编写mapper映射文件----两个 这个是员工映射文件

<resultMap id="Map03" type="com.zhl.entity.Staff" autoMapping="true">
        <!--id 唯一标识 主键的映射关系 必须写！！！
            property="属性名"===实体类自己写的列名
            column="列名"===数据库列名
            result 普通字段
        -->
        <id property="staffid" column="staff_id"/>
        <result property="staffname" column="staff_name"/>
        <result property="staffsex" column="staff_sex"/>
        <result property="deptid" column="dept_id"/>
        <!--column:数据库列名  select='要调用另一个表的查询的方法名'-->
        <association property="dept" javaType="com.zhl.entity.Dept" column="dept_id" select="com.zhl.dao.DeptDao.selectById">

        </association>
    </resultMap>
    <select id="selectSD2" resultMap="Map03">
        select * from staff where staff_id=#{staffid}
    </select>

4.编写mapper映射文件----两个 这个是部门映射文件

<?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">
<!--namespace:命名空间:它的值现在可以随便写。
以后必须和dao接口对应。
-->
<mapper namespace="com.zhl.dao.DeptDao">
    <resultMap id="Map04" type="com.zhl.entity.Dept">
        <id property="deptid" column="dept_id"/>
        <result property="deptname" column="dept_name"/>
    </resultMap>
    <select id="selectById" resultMap="Map04">
        select * from dept where dept_id=#{deptid}
    </select>
</mapper>

5.测试

//根据员工id查询员工信息和员工所属部门信息 第二种方法
    @Test
    public void selectSD2(){
        StaffDao mapper = session.getMapper(StaffDao.class);
        Staff staff = mapper.selectSD2(5);
        System.out.println(staff);
    }

4. 链表查询 --->  一对多链表查询

例：根据部门id查询部门信息以及该部门的所有员工

1.在部门实体类里添加员工数组属性

package com.zhl.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

/**
 * @program: HellowMybatis
 * @description:
 * @author: 张会理
 * @create: 2021-12-03 16:07
 **/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Dept {
    private Integer deptid;
    private String deptname;
    private List<Staff> staff;//因为查询的可能是多个员工  所以定为数组返回


    public Dept(String deptname) {
        this.deptname = deptname;
    }
}

2.在部门Dao方法里添加 查询方法

Dept selectByStaff(int deptid);

3.编写mapper映射文件

<resultMap id="Map05" type="com.zhl.entity.Dept">
        <id property="deptid" column="dept_id"/>
        <result property="deptname" column="dept_name"/>
        <!--
            collection: 集合的意思  是很多的意思 emm
                property: 集合对象名
                ofType: 集合的泛型
        -->
        <collection property="staff" ofType="com.zhl.entity.Staff" autoMapping="true">
            <id property="staffid" column="staff_id"/>
            <result property="staffname" column="staff_name"/>
            <result property="staffsex" column="staff_sex"/>
            <result property="deptid" column="dept_id"/>
        </collection>
    </resultMap>
    <!--这里的id必须和Dao中的方法名一致-->
    <select id="selectByStaff" resultMap="Map05">
        select * from dept d join staff s on d.dept_id=s.dept_id where d.dept_id=#{deptid}
    </select>

4.测试

//一对多链表查询
    @Test
    public void selectByStaff(){
        DeptDao deptDao = session.getMapper(DeptDao.class);
        Dept dept = deptDao.selectByStaff(1);
        System.out.println(dept);
    }

5.动态SQL语句

动态SQL语句:  sql语句根据条件而发生改变。

准备: 在本地虚拟机mysql上创建一个book_info图书信息表:

 1.编写图书信息实体类

package com.zhl.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @program: HellowMybatis
 * @description:
 * @author: 张会理
 * @create: 2021-12-03 19:13
 **/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Book_info {
    private Integer bookid;//图书id
    private String bookname;//图书名字
    private String bookauthor;//图书作者
    private Integer bookprice;//图书价格
    private String bookpub;//图书出版社
}

2.动态SQL语句 if和where一起使用

2.1编写Dao方法

package com.zhl.dao;

import com.zhl.entity.Book_info;

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

/**
 * @program: HellowMybatis
 * @description:
 * @author: 张会理
 * @create: 2021-12-03 19:13
 **/
public interface Book_infoDao {
    List<Book_info> findByCondition(Map<String,Object> map);//if 和 where 一起使用  按条件查询
}

2.2编写BookMapper映射文件

<?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">
<!--namespace:命名空间:它的值现在可以随便写。
以后必须和dao接口对应。
-->
<mapper namespace="com.zhl.dao.Book_infoDao">
    <resultMap id="Map06" type="com.zhl.entity.Book_info">
        <id property="bookid" column="book_id"/>
        <result property="bookname" column="book_name"/>
        <result property="bookauthor" column="book_author"/>
        <result property="bookprice" column="book_price"/>
        <result property="bookpub" column="book_pub"/>
    </resultMap>

    <!--if和where一起用-->
    <select id="findByCondition" resultMap="Map06">
        /*where: 可以帮你添加where关键 并且把第一个的and | or 去除
            if:判断要查找的内容是否为空或者空字符
        */
        select * from book_info
        <where>
            <if test="bookname!=null and bookname!=''">
                and book_name=#{bookname}
            </if>
            <if test="bookauthor!=null and bookauthor!=''">
                and book_author=#{bookauthor}
            </if>
        </where>
    </select>
</mapper>

3.动态SQL语句 [choose , when , otherwise] 和 where 一起使用

3.1 编写Dao方法

package com.zhl.dao;

import com.zhl.entity.Book_info;

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

/**
 * @program: HellowMybatis
 * @description:
 * @author: 张会理
 * @create: 2021-12-03 19:13
 **/
public interface Book_infoDao {
    List<Book_info> findByCondition(Map<String,Object> map);//if 和 where 一起使用  按条件查询

    List<Book_info> findByCondition1(Map<String,Object> map);//[choose , when , otherwise] 和 where 一起使用
}

3.2编写BookMapper映射文件

    <!--[choose , when , otherwise] 和 where 一起使用-->
    <select id="findByCondition1" resultMap="Map06">
        /*choose + where
            when: 当条件满足时不会执行下面的when和other  都不满足则执行otherwise
            otherwise: 当when所有条件都不满足时执行
        */
        select * from book_info
        <where>
            <choose>
                <when test="bookname!=null and bookname!=''">
                    and book_name=#{bookname}
                </when>
                <when test="bookauthor!=null and bookauthor!=''">
                    and book_author=#{bookauthor}
                </when>
                <otherwise>

                </otherwise>
            </choose>
        </where>
    </select>

3.3测试

/*[choose , when , otherwise] 和 where 一起使用*/
    @Test
    public void findByCondition1(){
        Book_infoDao mapper = session.getMapper(Book_infoDao.class);
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("bookname","");
        map.put("bookauthor","");
        List<Book_info> list = mapper.findByCondition1(map);
        System.out.println(list);
    }

4.动态SQL语句 set标签 修改部分字段。和if一起使用

4.1 编写Dao方法

package com.zhl.dao;

import com.zhl.entity.Book_info;

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

/**
 * @program: HellowMybatis
 * @description:
 * @author: 张会理
 * @create: 2021-12-03 19:13
 **/
public interface Book_infoDao {
    List<Book_info> findByCondition(Map<String,Object> map);//if 和 where 一起使用  按条件查询

    List<Book_info> findByCondition1(Map<String,Object> map);//[choose , when , otherwise] 和 where 一起使用

    void updatebook(Book_info bookInfo);//set标签 修改部分字段。和if一起使用
}

4.2 编写BookMapper映射文件

<!--set标签 修改部分字段。和if一起使用-->
    <update id="updatebook">
        /*set 可以帮你添加set关键字  并且去除最后的逗号*/
        update book_info
        <set>
            <if test="bookname!=null and bookname!=''">
                book_name=#{bookname},
            </if>
            <if test="bookauthor!=null and bookauthor!=''">
                book_author=#{bookauthor},
            </if>
            <if test="bookprice!=null and bookprice!=''">
                book_price=#{bookprice},
            </if>
            <if test="bookpub!=null and bookpub!=''">
                book_pub=#{bookpub},
            </if>
        </set>
        where book_id=#{bookid}
    </update>

4.3测试

    /*set标签 修改部分字段。和if一起使用*/
    @Test
    public void updatebook(){
        Book_infoDao mapper = session.getMapper(Book_infoDao.class);
        Book_info bookInfo = new Book_info();
        bookInfo.setBookid(1006);
        bookInfo.setBookname("完美世界");
        bookInfo.setBookauthor("辰东");
        bookInfo.setBookprice(23);
        //可以不写值 并且原来的内容不会被空字符或者别的什么修改掉
        bookInfo.setBookpub("");
        mapper.updatebook(bookInfo);
        session.commit();
    }

5.动态SQL语句 foreach 批量删除。

5.1 编写Dao方法

package com.zhl.dao;

import com.zhl.entity.Book_info;
import org.apache.ibatis.annotations.Param;

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

/**
 * @program: HellowMybatis
 * @description:
 * @author: 张会理
 * @create: 2021-12-03 19:13
 **/
public interface Book_infoDao {
    List<Book_info> findByCondition(Map<String,Object> map);//if 和 where 一起使用  按条件查询

    List<Book_info> findByCondition1(Map<String,Object> map);//[choose , when , otherwise] 和 where 一起使用

    void updatebook(Book_info bookInfo);//set标签 修改部分字段。和if一起使用

    void batchdeletebook(@Param("bookid01") int[] bookid01);//foreach 批量删除
}

5.2 编写BookMapper映射文件

    <!--foreach 批量删除-->
    <!--
    这个语句相当于SQL语句中的===>   delete from book_info where book_id in (值1,值2,值3.........);

    foreach:
    collection: 要遍历的集合和数组名
    item: 每次遍历时赋值的元素变量名
    open: 以什么开始  这里以 ( 开始
    close: 以什么结束  这里以 ) 结束
    separator:  以什么作为分隔符  一般都为  ,
    -->
    <delete id="batchdeletebook">
        delete from book_info where book_id in
        <foreach collection="bookid01" item="bookid" open="(" close=")" separator=",">
            #{bookid}
        </foreach>
    </delete>

5.3 测试

    /*foreach 批量删除*/
    @Test
    public void batchdeletebook(){
        Book_infoDao mapper = session.getMapper(Book_infoDao.class);
        int[] bookid={1004,1005,1006};
        mapper.batchdeletebook(bookid);
        session.commit();
    }

6. 模糊查询  like关键字

1.例子:查询以 姓张 的员工

2.编写员工Dao方法

package com.zhl.dao;

import com.zhl.entity.Staff;

import java.util.List;

public interface StaffDao {

    //int insertstaff(Staff staff);//添加员工

    //int deletestaff(int staffid);//删除员工

    //int updatestaff(Staff staff);//修改员工信息

    //List<Staff> selectallstaff();//查找所有员工

    //List<Staff> selectonestaff(int staffid);//根据id查找一个员工

    //Staff selectSD(int staffid);//查询员工和部门信息--多对一链表查询 第一种方法

    //Staff selectSD2(int staffid);//查询员工和部门信息--多对一链表查询 第二种方法

    List<Staff> selectallstaff1(String staffname);//模糊查询
}

3.编写BookMapper映射文件

    <!--模糊查询-->
    <select id="selectallstaff1" resultMap="Map01">
        select * from staff s join dept d on s.dept_id=d.dept_id
        <where>
            <if test="staffname!=null and staffname!=''">
                s.staff_name like concat(#{staffname},'%')
            </if>
        </where>
    </select>

4.测试

    //模糊查询
    @Test
    public void selectallstaff1(){
        StaffDao mapper = session.getMapper(StaffDao.class);
        List<Staff> list = mapper.selectallstaff1("赵");
        System.out.println(list);
    }

7. 分页插件--PageHelper

例子:查询王姓员工的所有信息 , 分页查询 , 每页查询5个.

1.分页查询的SQL语句:   select * from 表名  limit (page-1)*pageSize,pageSize;

                                        page: 当前要显示的页码

                                        pageSize: 每页显示的条数

2.引入相关的pageHelper依赖

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

3.加入拦截  -----在mybatis的配置文件中加入

    <!--
        plugins在此处的位置必须符合要求，否则会报错  顺序如下:
        properties? , settings?,
        typeAliases? , typeHandlers?,
        objectFactory?, objectWrapperFactory?,
        pligins?,
        environments?, databaseIdProvider?, mappers?
    -->
    <plugins>
        <!--com.github.pagehelper.PageInterceptor 为PageHelper类所在包名-->
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <!--使用下面的而方式配置参数，后面会有所有的参数介绍-->
            <property name="param1" value="value1"/>
        </plugin>
    </plugins>

4.编写Dao方法

package com.zhl.dao;

import com.zhl.entity.Staff;

import java.util.List;

public interface StaffDao {

    /*int insertstaff(Staff staff);//添加员工

    int deletestaff(int staffid);//删除员工

    int updatestaff(Staff staff);//修改员工信息

    List<Staff> selectallstaff();//查找所有员工

    List<Staff> selectonestaff(int staffid);//根据id查找一个员工

    Staff selectSD(int staffid);//查询员工和部门信息--多对一链表查询 第一种方法

    Staff selectSD2(int staffid);//查询员工和部门信息--多对一链表查询 第二种方法

    List<Staff> selectallstaff1(String staffname);//模糊查询*/

    List<Staff> selectallstaff2(String staffname);//分页查询
}

5.编写BookMapper映射文件

    <!--分页查询-->
    <select id="selectallstaff2" resultMap="Map01">
        select * from staff s join dept d on s.dept_id=d.dept_id
        <where>
            <if test="staffname!=null and staffname!=''">
                s.staff_name like concat(#{staffname},'%')
            </if>
        </where>
    </select>

6.测试

    //分页查询
    @Test
    public void selectallstaff2(){
        StaffDao mapper = session.getMapper(StaffDao.class);
        PageHelper.startPage(0,5);//pageNum: 从哪里开始   pageSize: 显示的个数有多少个
        List<Staff> list = mapper.selectallstaff2("王");
        System.out.println(list);
    }

7. 可以把查询到的结果封装到PageInfo类中 包含你想要的任何信息  代码如下:

    //分页查询
    @Test
    public void selectallstaff2(){
        StaffDao mapper = session.getMapper(StaffDao.class);
        PageHelper.startPage(0,5);//pageNum: 从哪里开始   pageSize: 显示的个数有多少个
        List<Staff> list = mapper.selectallstaff2("王");
        //可以把查询到的结果封装到PageInfo类中  包含你想要的任何信息
        PageInfo<Staff> pageInfo = new PageInfo<Staff>(list);
        System.out.println("总条数为:"+pageInfo.getTotal());
        System.out.println("当前页码的数据:"+pageInfo.getList());
    }