springboot+mybatis笔记学习

最新推荐文章于 2024-10-31 12:02:50 发布

微风qin

最新推荐文章于 2024-10-31 12:02:50 发布

阅读量429

点赞数

分类专栏： SSM 文章标签： mybatis spring boot 笔记

本文链接：https://blog.csdn.net/m0_63941306/article/details/131355918

版权

SSM 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

1.环境搭建

1.引入pom依赖

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.2</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.16</version>
</dependency>

2.yml文件配置

#配置环境源
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
url: jdbc:mysql://localhost:3306/ssm
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver

#配置mybatis映射文件和实体类包
mybatis:
mapper-locations: classpath:com.weifengqin.mapper/*.xml
type-aliases-package: com.weifengqin.pojo
configuration:
#配置日志级别
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

3.其他注意事项

mapper接口要加上@Mapper注解
mapper.xml文件的namespace要对应具体的mapper文件

4.最终项目结构图

2.mapper.xml获取参数

MyBatis获取参数值的两种符号：${}和#{}

#{}: 解析为SQL时，会将形参变量的值取出，并自动给其添加引号。

${}: 解析为SQL时，将形参变量的值直接取出(去掉"")，直接拼接显示在SQL中

总结获取参数的几种方式:

①单个和多个参数都通过注解（@param）获取

②多个参数 -->在参数声明位置将多个参数存入map集合中，通过key-value形式获取

③多个参数–>将参数存入实体类对象中，通过key-value形式获取

多个参数

public User selectByIdAndNameByParame(@Param("id") Integer id,@Param("name") String username);

<select id="selectByIdAndNameByParame" resultType="com.weifengqin.pojo.User">
    select * from t_user where id = #{id} and username = #{name}
</select>

map集合

这里需要注意的是在xml中#{值}，要与向map集合中存的键一一对应

public User selectByIdAndName(Map map);

<select id="selectByIdAndName" resultType="com.weifengqin.pojo.User">
    select * from t_user where id = #{id} and username = #{username}
</select>

实体类对象，同map集合

3.基础查询功能

查询结果封装为list集合
查询结果为基本数据类型
查询一条结果封装为map
查询多条结果封装为map集合

查询结果封装为list集合

mapper.xml返回值类型仍然为实体类对象，只不过在接口接收的时候用list集合结构，因为返回值有多条数据
```
List<User> getUserList();
```
```
<select id="getUserList" resultType="User">
	select * from t_user
</select>
```

查询结果为基本数据类型

mapper.xml返回值类型要设置为基本数据类型

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

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

查询一条结果封装为map集合

Map<String, Object> getUserToMap(@Param("id") int id);

<select id="getUserToMap" resultType="java.util.Map">
    select * from t_user where id = #{id}
</select>

//查询结果为封装为map集合
Map<String, Object> map = mapper3.getUserToMap(1);
System.out.println(map);

查询多条结果封装为map集合

有两种封装方式，这两种封装方式中都把查询结果map看成一个实体类对象就容易理解了

掌握第一种即可

mapper接口中接收类型为List集合

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

<!--Map<String, Object> getAllUserToMap();-->
<select id="getAllUserToMap" resultType="map"> //返回值为map
	select * from t_user
</select>

//查询多条结果封装为map  result1
List<Map<String, Object>> mapList = mapper3.getAllUserToMap();
for (Map<String, Object> map : mapList) {
    System.out.println(map);
}
//打印结果
//{balance=20, id=1, username=admin}
//{balance=30, id=2, username=admin3}

将查询出来的数据封装为一个指定的大Map，大Map键可以指定小map里面字段，值为小map，小map为一条条数据

@MapKey指明设置大map的键，可以用查询出来的小map集合的键充当

/**
* 查询所有用户信息为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>

//查询多条结果封装为map  Map
Map<String, Object> map = mapper3.getAllUserToMap();
System.out.println(map);
//打印结果
//{1={balance=20, id=1, username=admin}, 2={balance=30, id=2, username=admin3}}

4.特殊SQL

模糊查询
批量删除
添加功能获取自增的主键

模糊查询

要用到concat拼接函数，#{}会自动给取出来的值自动加上单引号

List<User> testMohu(@Param("mohu") String mohu);

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

批量删除

${}无论传过来的是什么类型，如果最外层有引号，那么会自动去除

因此这里传String类型，会自动去掉外层的引号

int deleteMore(@Param("ids") String ids);

<delete id="deleteMore">
    //${}无论传过来是啥，都是去掉最外侧''的值
    //#{}会自动加单引号
	delete from t_user where id in (${ids})
</delete>

//2.批量删除
int affectRows = mapper4.deleteMore("3,4");
System.out.println(affectRows);
//输出结果
//2

添加功能获取自增的主键

mapper.xml``insert标签两个特殊的属性

useGeneratedKeys：表示当前添加功能使用数据库表自增的主键，将使用自增主键的属性设置为null
keyProperty：

因为insertjava方法返回值固定为返回行数

因此用这个属性指定将自增主键回显给实体类的哪个属性

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

<!--
 useGeneratedKeys:表示当前添加功能使用自增的主键
 keyProperty：表示回显的主键赋值给实体类的哪个属性
-->
<insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
    insert into t_user values(null,#{username},#{password},#{age},#{sex})
</insert>

//3.使用自增主键插入数据
User user = new User(2,"adminAuto",300);
int affectRows = mapper4.insertUserByAutoGenerate(user);
System.out.println("影响行数：" + affectRows + ",自增主键id：" + user.getId());
//输出结果
//影响行数：1,自增主键id：7

5.自定义结果映射✏️

sql表中字段和java实体类属性名字不一致用resultMap
一对多和多对一这种java实体类对象属性是一个集合或者实体类时
分步查询

1.sql表中字段和java实体类属性名字不一致

解决办法：

可以通过为在sql语句中为字段起别名的方式，保证和实体类中的属性名保持一致
可以在MyBatis的核心配置文件中设置一个全局配置信息mapUnderscoreToCamelCase，可以在查询表中数据时，自动将_类型的字段名转换为驼峰

例如：字段名user_name，设置了mapUnderscoreToCamelCase，此时字段名就会转换为userName

通过在mybatis配置文件中设置resultMap解决

<!--
    resultMap：设置自定义映射
    属性：
    id：表示自定义映射的唯一标识
    type：查询的数据要映射的实体类的类型

    子标签：
    id：设置主键的映射关系
    result：设置普通字段的映射关系
    association：设置多对一的映射关系
    collection：设置一对多的映射关系

    子标签属性：
    property：设置映射关系中实体类中的属性名
    column：设置映射关系中表中的字段名
-->

<resultMap id="userMap" type="User">
    <id property="id" column="id"></id>
    <result property="userName" column="user_name"></result>
    <result property="password" column="password"></result>
    <result property="age" column="age"></result>
    <result property="sex" column="sex"></result>
</resultMap>
<!--List<User> testMohu(@Param("mohu") String mohu);-->
<select id="testMohu" resultMap="userMap">
select id,user_name,password,age,sex from t_user where user_name like concat('%',#{mohu},'%')
</select>

2.多对一

多对一就是要映射的对象有一个属性关联到单独的对象

如一个emp中有一个dept属性

多对一，一个记录只能查询出来一条信息，封装简单

resultMap映射原理：

先根据参数值组织sql语句去数据库表中查询
再根据查询结果将resultMap中column和proprety一一对应，其中column对应SQL中查询出来的字段，property对应java属性

级联方式

给实体类对象的引用数据类型赋值

<resultMap id="empDeptMap" type="Emp">
    <id column="eid" property="eid"></id>
    <result column="ename" property="ename"></result>
    <result column="age" property="age"></result>
    <result column="sex" property="sex"></result>
    <result column="did" property="dept.did"></result>//与dept属性中的deptId映射
    <result column="dname" property="dept.dname"></result>
</resultMap>
<!--Emp getEmpAndDeptByEid(@Param("eid") int eid);-->
<select id="getEmpAndDeptByEid" resultMap="empDeptMap">
	select emp.*,dept.* from t_emp emp left join t_dept dept on emp.did =dept.did where emp.eid = #{eid}
</select>

使用association处理映射关系（用来处理实体类的属性)⭐️

association：专门用来处理多对一的映射关系，意思是关联

属性property：用来关联java属性对象，如emp中的dept属性

属性javaType：用来指明java属性对象类型，如emp中的dept属性属于Dept类型

<resultMap id="empDeptMap" type="Emp">
    <id column="eid" property="eid"></id>
    <result column="ename" property="ename"></result>
    <result column="age" property="age"></result>
    <result column="sex" property="sex"></result>
    <!--直接深入dept对象的属性  -->
    <association property="dept" javaType="Dept">
        <id column="did" property="did"></id>
        <result column="dname" property="dname"></result>
	</association>
</resultMap>
<!--Emp getEmpAndDeptByEid(@Param("eid") int eid);-->
<select id="getEmpAndDeptByEid" resultMap="empDeptMap">
	select emp.*,dept.* from t_emp emp left join t_dept dept on emp.did =dept.did where emp.eid = #{eid}
</select>

3.一对多

一对多的意思是一个实体类对象中有一个集合属性

如dept中有一个List属性

一对多的话，一条sql可能查出许多结果，这样将多余结果都映射到一个属性的collection集合中

如根据id查询一个部门和部门员工，查询出来可能得到一个部门和许多员工的信息，因此这样封装到一个dept中。一个dept有一个集合属性专门承载员工信息

用标签解决

属性property：指明了要处理的属性名，如dept中List

属性ofType：指明了要处理的属性名的类型，如dept中List类型为Emp

/**
* 根据部门id查询部门以及部门中的员工信息
* @param did
* @return
*/
Dept getDeptEmpByDid(@Param("did") int did);

<resultMap id="deptEmpMap" type="Dept">
    <id property="did" column="did"></id>
    <result property="dname" column="dname"></result>
    <!--
		ofType：设置collection标签所处理的集合属性中存储数据的类型
	-->
	<collection property="emps" ofType="Emp">
        <id property="eid" column="eid"></id>
        <result property="ename" column="ename"></result>
        <result property="age" column="age"></result>
        <result property="sex" column="sex"></result>
	</collection>
</resultMap>

<select id="getDeptEmpByDid" resultMap="deptEmpMap">
	select dept.*,emp.* from t_dept dept left join t_emp emp on dept.did = emp.did where dept.did = #{did}
</select>

4.分步查询

一对多的分步查询

主要通过标签作为中间桥梁进行实现>

select属性用于指明分步查询借助的中间方法
column用于将第一步查询出来的sql字段作为条件传入下一步
property属性用于得到中间方法的返回值属性
**流程：**使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性

步骤：

①在emp查询中，只查询emp表，然后得到的dept_id字段可以为下一张表查询提供条件

②再设置一个DeptMapper接口，上面实现传参实现查询方法

③中间桥梁通过emp查询中association标签，调用另一个查询，分步得到进一步结果值再赋值给emp对象属性

这里代码有一个问题，不知道为什么第二步查询的结果不能给dept属性赋值

第二步查询字段与java属性一定要在第二步返回的时候设置resultMap处理，不要在第一步association中处理

①查询员工信息

/**
     * 通过分步查询查询员工信息
     * @param eid
     * @return
     */
Emp getEmpByStepOne(@Param("eid") int eid);

<resultMap id="empDeptStepMap" type="emp">
    <id column="emp_id" property="id"></id>
    <result column="emp_name" property="empName"></result>
    <result column="age" property="age"></result>
    <result column="sex" property="gender"></result>
    <!--
            select：设置分步查询，查询某个属性的值的sql的标识（namespace.sqlId）
            column：将sql以及查询结果中的某个字段设置为分步查询的条件
     -->
    <!--这里将select查询结果赋值给dept属性，select查询结果要先用resltMap提前处理好，要与dept中的属性对应上 -->
    <association property="dept" fetchType="eager" select="com.weifengqin.mapper.deptResultMapMapper5.getEmpDeptByStepTwo" column="emp_id">
    </association>
</resultMap>

<!--分步查询 多对一-->
<select id="getEmpByStepOne" resultMap="empDeptStepMap">
    select * from t_emp where emp_id = #{eid}
</select>

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

/**
     * 分步查询的第二步： 根据员工所对应的did查询部门信息
     * @param did
     * @return
     */
Dept getEmpDeptByStepTwo(@Param("did") int did);

<!--分步查询第二步映射-->
<!--第二步查询字段与java属性一定要在第二步返回的时候设置resultMap处理，不要在第一步association中处理-->
<resultMap id="deptMap" type="dept">
    <result column="dept_id" property="deptId"></result>
    <result column="dept_name" property="deptName"></result>
</resultMap>

<select id="getEmpDeptByStepTwo" resultMap="deptMap">
    select * from t_dept where dept_id = #{did}
</select>

一对多查询

通过collection标签去实现，实现属性和association中的一样

唯一不同之处是，一对多第二步查询返回数据为一个集合

①查询部门信息

/**
     * 分步查询部门和部门中的员工
     * @param did
     * @return
     */
Dept getDeptByStepOne(@Param("did") int did);

<resultMap id="deptEmpStep" type="Dept">
    <id property="deptId" column="dept_id"></id>
    <result property="deptName" column="dept_name"></result>

    <collection property="emps" fetchType="eager" select="com.weifengqin.mapper.employeeResultMapMapper5.getEmpListByDidTwo" column="dept_id">
    </collection>
</resultMap>

<select id="getDeptByStepOne" resultMap="deptEmpStep">
    select * from t_dept where dept_id = #{did}
</select>

②查询员工集合

//返回list集合
/**
     * 根据部门id查询员工信息
     * @param did
     * @return
     */
List<Emp> getEmpListByDidTwo(@Param("did") int did);

<!--分步查询第二步映射empMap-->
<resultMap id="empMap" type="emp">
    <id property="id" column="emp_id"></id>
    <result property="empName" column="emp_name"></result>
    <result property="age" column="age"></result>
    <result property="gender" column="sex"></result>
</resultMap>

<!--分步查询 一对多-->
<select id="getEmpListByDidTwo" resultMap="empMap">
    select * from t_emp where emp_id = #{did}
</select>

懒加载
- 懒加载介绍：
  
  懒加载针对分步查询来设置，实现懒加载后如果在java代码中要查询的数据用不到第二步查询结果，那么底层会只执行第一步查询，不会执行第二步。
  
  如在查询部门信息及员工信息一对多的情况下，如果java代码只调用getDeptId方法，那么底层不会去查询员工信息
- 懒加载设置：
  
  ①全局设置：
  
  **lazyLoadingEnabled：**延迟加载的全局开关。当开启时，所有关联对象都会延迟加载
  
  **aggressiveLazyLoading：**当开启时，任何方法的调用都会加载该对象的所有属性。（优先级高于第一个配置）否则，每个属性会按需加载
  
  ②个性化设置：在开启懒加载后，如果只想某一些方法不开启懒加载，那么需要在association和collection中的分步查询标签上fetchType属性设置当前的分步查询是否使用延迟加载
- 懒加载作用：
  
  懒加载真正做到了按需加载，这样可以减少一些不必要的查询

6.动态SQL

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

关于前端传递过来的数据为null还是为空字符串的情况

这个字段前端没有传，那就是null。前端传的空的，那就是""
下面这些标签里面表达式里的变量都是java实体类的属性，即参数

不是表里面的参数

1.if标签

List<Emp> getEmpListByCondition(Emp emp);

<!--1.if标签-->
<select id="getEmpListByCondition" resultMap="com.weifengqin.mapper.employeeResultMapMapper5.empMap">
    select * from t_emp where 1 = 1
    <if test="empName != null and empName !=''">
        and emp_name = #{empName}
    </if>
</select>

2.where

where和if一般结合使用：

a>若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字

b>若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的and去掉

注意：where标签不能去掉条件最后多余的and

//where标签
List<Emp> getEmpListByWhere(Emp emp);

<!--2.where标签-->
<select id="getEmpListByWhere" resultMap="com.weifengqin.mapper.employeeResultMapMapper5.empMap">
    select * 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>
    </where>
</select>

3.trim

trim用于动态地去掉或添加标签中的内容，其中动态去掉东西用的比较多。

应用：where标签只能前面有and，而不能后面加上and，否则无法去除

trim标签可以规避这一问题

常用属性：

prefix：在trim标签中的内容的前面添加某些内容

prefixOverrides：在trim标签中的内容的前面去掉某些内容

suffix：在trim标签中的内容的后面添加某些内容

suffixOverrides：在trim标签中的内容的后面去掉某些内容

//trim标签
List<Emp> getEmpListByTrim(Emp emp);

<!--3.trim标签-->
<select id="getEmpListByTrim" resultMap="com.weifengqin.mapper.employeeResultMapMapper5.empMap">
    select * 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}
        </if>
    </trim>
</select>

4.choose、when、otherwise 多路选择

相当于Switch，只能选择一路

//choose when otherwise多路选择标签
List<Emp> getEmpListByChoose(Emp emp);

<select id="getEmpListByChoose" resultMap="com.weifengqin.mapper.employeeResultMapMapper5.empMap">
    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>
            <otherwise>
                <if test="gender != null and gender != ''">
                    sex = #{gender}
                </if>
            </otherwise>
        </choose>
    </where>
</select>

5.foreach:适用于集合，数组✏️

用于批量插入或删除数据

collection属性指明集合参数

item属性表示遍历的元素

separator属性表示每一条SQL语句的分隔符

批量插入

int insertMoreEmp(@Param("emps") List<Emp> emps);

<insert id="insertMoreEmp">
    insert into t_emp values

    <foreach collection="emps" item="emp" separator=",">
        <!--这里要用emp.属性，不能直接用属性，直接用属性是参数为实体类对象的时可以-->
        (null,#{emp.empName},#{emp.age},#{emp.gender},null)
    </foreach>
</insert>

批量删除

int deleteMoreByArray(@Param("ids") int[] ids);

<!--或者是用or也行-->
<!--for each标签-->
<delete id="deleteMoreByArray">
    delete from t_emp
    where emp_id in
    <foreach collection="ids" item="id" separator="," open="(" close=")">
        #{id}
    </foreach>
</delete>

<!--int deleteMoreByArray(int[] eids);-->
<delete id="deleteMoreByArray">
	delete from t_emp where
	<foreach collection="eids" item="eid" separator="or">
		eid = #{eid}
	</foreach>
</delete>

6.SQL片段

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

//sql片段
List<Emp> getEmpListBySQL(Emp emp);

<!--sql片段-->
<sql id="columnEmp">
    emp_id,emp_name,age,sex,email
</sql>

<select id="getEmpListBySQL" resultMap="com.weifengqin.mapper.employeeResultMapMapper5.empMap">
    select <include refid="columnEmp"></include> from t_emp;
</select>

7.mybatis缓存机制

日后再补这一块内容

8.mybatis分页插件

分页插件失效参考链接

导入依赖

导入pagehelper和springboot整合的插件，为了便于跟 SpringBoot 融合，自动配置，减少使用负担。

<!--分页插件-->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.3.0</version>
</dependency>

pageHelper常用配置

pagehelper:
  # 设置方言，此处指定 MySQL 数据库
  helper-dialect: mysql
  # 是否启动合理化，默认是 false。
  # 启用合理化时，如果pageNum<1会查询第一页，如果pageNum>pages（最大页数）会查询最后一页。
  # 禁用合理化时，如果pageNum<1或pageNum>pages会返回空数据
  reasonable: true
  # 是否支持接口参数来传递分页参数，默认false
  support-methods-arguments: true
  # 为了支持startPage(Object params)方法，增加了该参数来配置参数映射，用于从对象中根据属性名取值
  params: count=countSql
  # 默认值为 false，当该参数设置为 true 时，如果 pageSize=0 或者 RowBounds.limit = 0 就会查询出全部的结果（相当于没有执行分页查询，但是返回结果仍然是 Page 类型）
  page-size-zero: true

pageHelper拦截器配置（整合进springboot后一般不需要配置，如果pagehelper失效可以试试配置一下）

@Configuration
public class PageHelperConfigure {
 
    @Bean
    public Interceptor[] plugins() {
        return new Interceptor[]{new PageInterceptor()};
    }
}

pageHelper的使用

在查询功能之前使用PageHelper.startPage(int pageNum, int pageSize)开启分页功能（在开启之后，中间不能做与分页无关的查询了）

pageNum：当前页的页码

pageSize：每页显示的条数
在查询获取list集合之后，使用PageInfo pageInfo = new PageInfo<>(List list, int navigatePages)获取分页相关数据

pageInfo中封装着list集合分页好的数据

list：分页之后的数据

navigatePages：导航分页的页码数

举例使用：

@Test
public void testPageHelpMapper7(){
    //1.开启分页
    PageHelper.startPage(1,2);

    //2.一次查询数据
    List<Emp> list = mapper8.selectAllEmps();

    //3.将查询的数据封装进pageInfo对象
    PageInfo<Emp> pageInfo = new PageInfo<>(list,1);

    System.out.println(pageInfo);

    System.out.println("获取总数据条数: "+pageInfo.getTotal());//获取总数据条数
    System.out.println("得到分页总数: " + pageInfo.getPages());//得到分页总数
    System.out.println("当前页数：" + pageInfo.getPageNum());//得到当前页数

    System.out.println(pageInfo.getList());//获取分页结果集
    System.out.println("分页数据如下：");
    for (Emp emp : pageInfo.getList()) {
        System.out.println(emp);
    }
    //        Emp(id=2, empName=a, age=16, gender=女, dept=null)
    //        Emp(id=3, empName=a, age=16, gender=男, dept=null)
}

pageInfo对象其他属性

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]

// Emp(id=2, empName=a, age=16, gender=女, dept=null)
// Emp(id=3, empName=a, age=16, gender=男, dept=null)
}
```

pageInfo对象其他属性

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]