MyBatis

MyBatis笔记

Mybatis特性

  • Mybatis是支持定制化SQL、存储过程以及高级映射的优秀的持久层框架;
  • Mybatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集;
  • Mybatis可以使用简单的XML或注解用于配置和原始映射,将接口和Java的POJO(Plain Old Java Object 普通Java对象)映射称数据库中的记录;
  • Mybatis是一个半自动ORM(Object Relation Mapping)框架;

与其他持久层技术对比

JDBC
  • SQL夹杂在Java代码中,耦合度高,导致硬编码内伤;
  • 维护不易且实际开发需求中SQL变化,频繁修改的;
  • 代码冗长,开发效率低;
Hibernate 和 JPA
  • 操作简便,开发效率高;
  • 程序中的长难复杂SQL,需要绕过框架;
  • 内部自动生产的SQL,不容易做特殊优化;
  • 基于全映射的全自动框架,大量字段的POJO进行部分映射时比较困难;
  • 反射操作太多,导致数据库性能下降;
MyBatis
  • 轻量级,性能出色;
  • SQL和Java编码分开,功能边界清晰。Java代码专注业务、SQL语句专注数据;
  • 开发效率稍逊与Hibernate,但是完全能够接受;

引入依赖

    <dependencies>
        <!--Mybatis核心-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>
        
        <!--Mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.29</version>
        </dependency>
    </dependencies>

Mybatis核心配置文件

习惯明明为mybatis-config.xml,并无强制要求,整合Spring后,这个配置文件可以省略;

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

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

<?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>
    <!--设置链接数据库的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    
    <!--引入映射文件-->
    <mappers>
        <mapper resource="mappers/*.xml"/>
    </mappers>
</configuration>

创建Mybatis映射文件

Mybatis映射文件用于编写SQL,访问以及操作表中的数据;

Mybatis中可以面向接口操作数据,要保证两个一致:

  • mapper接口的全类名和映射文件的命名空间(namespace)保持一致;
  • mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致;
<?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.dou.mybatis.mapper.UserMapper">
    <insert id="insertUser" >
        insert into user values (null, '豆豆', '123456', 18, '男', '2865295144@qq.com')
    </insert>
</mapper>

调用测试

/**
	SqlSession默认不自动提交事务,需要手动提交,若需要自动提交事务
	可以使用SqlSessionFactory.openSession(true);
*/
	@Test
    public void test() throws IOException {
        //加载核心配置文件
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //获取SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //获取SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //获取SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取mapper接口对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.insertUser();
        //提交事务
        sqlSession.commit();
    }

Mybatis核心配置文件解析

environments
    <!--
        environments:配置多个链接数据库的环境
        属性:
            default:设置默认使用的环境的id
    -->
    <environments default="development">
        <!--
            environment:配置某个具体的环境
            属性:
                id:表示链接数据库的环境的唯一标识,不能重复
        -->
        <environment id="development">
            <!--
                transactionManager:设置事务管理方式
                属性:
                    type:"JDBC/MANAGED"
                        JDBC:表示当前环境中,执行SQL时,使用的是JDBC中原生的事务管理方式,事务的提交或回滚都需要手动处理
                        MANAGED:被管理,例如Spring
            -->
            <transactionManager type="JDBC"/>
            <!--
                dataSource:配置数据源
                属性:
                    type:"POOLED/UNPOOLED/JNDI"设置数据源类型
                        POOLED:表示使用数据库连接池缓存数据库链接
                        UNPOOLED:表示不适用数据库链接池
                        JNDI:表示使用上下文中的数据源
            -->
            <dataSource type="POOLED">
                <!--设置连接数据库的驱动-->
                <property name="driver" value="${db.driver}"/>
                <!--设置连接数据库的地址-->
                <property name="url" value="${db.url}"/>
                <!--设置连接数据库的用户名-->
                <property name="username" value="${db.username}"/>
                <!--设置连接数据库的密码-->
                <property name="password" value="${db.password}"/>
            </dataSource>
        </environment>
    </environments>
typeAliases
    <!--设置类型别名-->
    <typeAliases>
        <!--
            typeAlias:设置某个类型的别名
            属性:
                type:设置需要设置别名的类型
                alias:设置某个类型的别名,若不设置该属性,那么该属性拥有默认的别名,即类型,且不区分大小写
        -->
        <typeAlias type="com.dou.mybatis.pojo.User" alias="User"></typeAlias>
        <!--以包为单位,将包下所有的类型设置默认的类型别名,即类名,且不区分大小写-->
        <package name="com.dou.mybatis.pojo"/>
    </typeAliases>
    <select id="selectUser" resultType="User">
        select * from user
    </select>
mappers
<mappers>
    <mapper resource="mapper/UserMapper.xml"/>
    <!--
      以包为单位引入映射文件
      1.mapper接口所在的包要和映射文件所在包一致
      2.mapper接口和映射文件的名字一致
    -->
    <package name="com.dou.mybatis.mapper"/>
</mappers>

Mybatis获取参数的两种方式

mybatis获取参数的两种方式:${}和#{};

${}的本质就是字符串拼接,#{}的本质就是占位符赋值;

注意:${}使用字符串拼接的方式拼接SQL,若为字符串类型或日期类型的字段进行赋值时,需要手动加单引号;但是#{}使用占位符赋值的方式拼接SQL,此时为字符串类型或日期类型的字段进行赋值时,可以自动添加单引号。

单个字面量类型的参数

若mapper接口中的方法参数为单个的字面量类型;

此时可以使用${}和#{}以任意的名称获取参数的值;

//通过用户名查询信息
User selectUserByName(String userName);
<select id="selectUserByName" resultType="User">
    <!--select * from user where username = #{userName};-->
    select * from user where username = '${userName}';
</select>
多个字面量类型的参数

若mapper接口中的方法参数为多个时;

此时MyBatis会自动讲这些参数放在一个map集合中,以arg0,arg1…为键,以参数为值;或以param1,param2…为键,以参数为值;因此只需要通过${}和#{}访问map集合中的键就可以获取相对应的值;

//通过用户名密码查询信息
User selectUserByUserNameAndPassWord(String userName, String passWore);
<select id="selectUserByUserNameAndPassWord" resultType="User">
    <!--select * from user where username= #{param1} and password = #{param2};-->
    select * from user where username= '${arg0}' and password = '${arg1}';
</select>
map集合类型的参数

若mapper接口中的方法需要的参数为多个时,此时可以手动创建map集合,将这些数据放在map中,只需要通过${}和#{}访问map集合的键就可以获取相对应的值;

User selectUserByMap(Map params);
<select id="selectUserByMap" resultType="User">
    select * from user where username = #{userName} and password = #{passWord};
</select>
实体类类型的参数

若mapper接口中的方法参数为实体类对象时

此时可以使用${}和#{},通过访问实体类对象中属性名获取属性值;

int insertUserByUser(User user);
<insert id="insertUserByUser" parameterType="User">
    <!--insert into user values (null, #{username}, #{password}, #{age}, #{sex}, #{email});-->
    insert into user values(null, '${username}', '${password}', '${age}', '${sex}', '${email}');
</insert>
使用@Param标识参数

可以通过@Param注解标识mapper接口中的方法参数

此时,会将这些参数放在map集合中,以@Param注解的value属性值为键,以参数为值;以param1,param2…为键,以参数为值;只需要通过${}和#{}访问map集合的键就可以获取相对应的值;

User checkLogin(@Param("username") String username, @Param("password") String password);
<select id="checkLogin" resultType="User">
    <!--select * from user where username = #{username} and password = #{password};-->
    select * from user where username = '${param1}' and password = '${param2}';
</select>

Mybatis各种查询功能

查询一个实体类对象
//通过id查询用户信息
User selectById(@Param("id") int id);
<select id="selectById" resultType="User">
    select * from user where id = #{id};
</select>
查询一个List集合
//查询所有用户信息
List<User> selectAll();
<select id="selectAll" resultType="User">
    select * from user;
</select>
查询单个数据
//查询总记录数
int selectCount();
<select id="selectCount" resultType="int">
    select count(1) from user;
</select>
查询一条数据为map集合
//通过id查询用户信息,结果为一个map集合
Map<String, Object> selectUserByIdToMap(@Param("id") Integer id);
<select id="selectUserByIdToMap" resultType="map">
    select * from user where id = #{id};
</select>
查询多条数据为map集合

方式一:

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

方式二:

/**
* 查询所有用户信息为map集合
* 将表中的数据以map集合的方式查询,一条数据对应一个map;
* 若有多条数据,就会产生多个map集合,并且最终要以一个map的方式返回数据,此时需要通过@MapKey注解设置map集合的键,值是每条数据所对应的map集合
* @return
*/
@MapKey("id")
Map<String, Object> selectAllToMap2();
<select id="selectAllToMap2" resultType="map">
    select * from user;
</select>

特殊SQL的执行

模糊查询
//根据用户名模糊查询用户信息
List<User> selectUserByLike(@Param("username") String username);
<select id="selectUserByLike" resultType="User">
    <!--select * from user where username like '%${username}%';-->
    <!--select * from user where username like concat('%', #{username}, '%');-->
    select * from user where username like "%"#{username}"%";
</select>
批量删除
//根据id批量删除
int deleteMore(@Param("ids")String ids);
<delete id="deleteMore">
    delete from user where id in (${ids});
</delete>

**注意:**需要使用${}进行获取参数(#{}或拼接’'导致SQL错误)

动态设置表名
//通过传入表名查询数据
List<User> selectUserByTableName(@Param("tableName")String tableName);
<select id="selectUserByTableName" resultType="User">
    select * from ${tableName};
</select>

**注意:**需要使用${}进行获取参数(#{}或拼接’'导致SQL错误)

添加功能获取自增的主键
void insertUser(User user);
<!--
	useGeneratedKeys:设置当前标签中的SQL使用了自增的主键
	keyProperty:将自增的主键的值赋值给传输到映射文件中参数的某个属性
-->
<insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
    insert into user values(#{id}, #{username}, #{password}, #{age}, #{sex}, #{email});
</insert>

自定义映射resultMap

处理字段和属性的映射关系
  • 为字段起别名,保持和属性名一致;

    <select id="selectAll1" resultType="Emp">
        select eid, emp_name empName, age, sex, email from t_emp;
    </select>
    
  • 设置全局配置,将_自动映射为驼峰

    <!--设置mybatis全局配置-->
    <settings>
        <!--将_自动映射为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    
  • 通过resultMap设置自定义的映射关系

    <!--
       resultMap:设置自定义映射关系
           id:唯一标识,不能重复
           type:设置映射关系中的实体类类型
           字标签:
               id:设置主键的映射关系
               result:设置普通字段的映射关系
               属性:
                   property:设置映射关系中的属性名,必须是type属性所设置的实体类类型中的属性名
                   column:设置映射关系中的字段名,必须是SQL语句查询出的字段名
     -->
    <resultMap id="empResultMap" type="Emp">
        <id property="eid" column="eid"/>
        <result property="empName" column="emp_name"/>
        <result property="age" column="age"/>
        <result property="sex" column="sex"/>
        <result property="email" column="email"/>
    </resultMap>
    <select id="selectAll2" resultMap="empResultMap">
        select * from t_emp;
    </select>
    
多对一映射处理
  • 级联属性赋值

    <!--处理多对一映射关系方式一:级联属性赋值-->
    <resultMap id="empAndDeptResultMapOne" type="Emp">
        <id property="eid" column="eid"/>
        <result property="empName" column="emp_name"/>
        <result property="age" column="age"/>
        <result property="sex" column="sex"/>
        <result property="email" column="email"/>
        <result property="dept.did" column="did"/>
        <result property="dept.deptName" column="dept_name"/>
    </resultMap>
    <select id="selectEmpAndDept" resultMap="empAndDeptResultMapOne">
        select * from t_emp left join t_dept on t_emp.did = t_dept.did where t_emp.eid = #{eid};
    </select>
    
  • association

    <!--处理多对一映射关系方式二:association-->
    <resultMap id="empAndDeptResultMapTwo" type="Emp">
        <id property="eid" column="eid"/>
        <result property="empName" column="emp_name"/>
        <result property="age" column="age"/>
        <result property="sex" column="sex"/>
        <result property="email" column="email"/>
        <!--
           association:处理多对一的映射关系
           property:需要处理多对一映射关系的属性名
           javaType:该属性的类型
         -->
        <association property="dept" javaType="Dept">
            <id property="did" column="did"/>
            <result property="deptName" column="dept_name"/>
        </association>
    </resultMap>
    <select id="selectEmpAndDept" resultMap="empAndDeptResultMapTwo">
        select * from t_emp left join t_dept on t_emp.did = t_dept.did where t_emp.eid = #{eid};
    </select>
    
  • 分步查询

    <!--处理多对一映射关系三:分步查询-->
    <resultMap id="empAndDeptStepResultMap" type="Emp">
        <id property="eid" column="eid"/>
        <result property="empName" column="emp_name"/>
        <result property="age" column="age"/>
        <result property="sex" column="sex"/>
        <result property="email" column="email"/>
        <!--
           select:设置分步查询的SQL的唯一标识(namespace.SQLId或mapper接口的全类名.方法名)
           column:设置分步查询的条件
           fetchType:当开启了全局的延迟加载之后,可通过此属性手动控制延迟加载的效果
                     fetchType="lazy|eager":lazy表示延迟加载,eager表示立刻加载
         -->
        <association property="dept"
                     fetchType="lazy"
                     select="com.dou.mybatis.mapper.DeptMapper.selectById"
                     column="did"/>
    </resultMap>
    <select id="selectEmpAndDeptStep" resultMap="empAndDeptStepResultMap">
        select * from t_emp where eid = #{eid};
    </select>
    
    <select id="selectById" resultType="Dept">
        select * from t_dept where did = #{did};
    </select>
    
一对多映射处理
  • collection

    <resultMap id="deptAndEmpResultMap" type="Dept">
        <id property="did" column="did"/>
        <result property="deptName" column="dept_name"/>
        <!--
                collection:处理一对多的映射关系
                ofType:表示该属性所对应的集合中存储数据的类型
            -->
        <collection property="empList" ofType="Emp">
            <id property="eid" column="eid"/>
            <result property="empName" column="emp_name"/>
            <result property="age" column="age"/>
            <result property="sex" column="sex"/>
            <result property="email" column="email"/>
        </collection>
    </resultMap>
    <select id="selectDeptAndEmp" resultMap="deptAndEmpResultMap">
        select * from t_dept left join t_emp on t_dept.did = t_emp.did where t_dept.did = #{did};
    </select>
    
  • 分步查询

    <resultMap id="deptAndEmpStepResultMap" type="Dept">
        <id property="did" column="did"/>
        <result property="deptName" column="dept_name"/>
        <collection property="empList"
                    select="com.dou.mybatis.mapper.EmpMapper.selectEmpByDid"
                    column="did"
                    fetchType="lazy"/>
    </resultMap>
    <select id="selectDeptAndEmpStep" resultMap="deptAndEmpStepResultMap">
        select * from t_dept where did = #{did};
    </select>
    
    <select id="selectEmpByDid" resultType="Emp">
        select * from t_emp where did = #{did};
    </select>
    
分步查询

分步查询的优点:可以实现延迟加载,但是必须在核心配置文件中设置全局配置信息;

lazyLoadingEnabled:延迟加载的全局开关。当开启时,所有关联对象都会延迟加载,默认为false;

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

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

动态SQL

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

if

​ if标签可通过test属性的表达式进行判断,若表达式的结果为true,则标签中的内容会执行;反之标签中的内容不会执行;

<select id="selectEmpByConditionIf" resultType="Emp">
    select * from t_emp where 1=1
    <if test="empName != null and empName != ''">
        and emp_name = #{empName}
    </if>
    <if test="age != null and age != ''">
        and age = #{age}
    </if>
    <if test="sex != null and sex != ''">
        and sex = #{sex}
    </if>
    <if test="email != null and email!= ''">
        and email = #{email}
    </if>
</select>
where

当where标签中有内容时,会自动生成where关键字,并且将内容前多余的and或者or去掉;

当where标签中没有内容时,此时where标签没有任何效果

**注意:**where标签不能将其中内容后面多余的and或or去掉

<select id="selectEmpByConditionWhere" resultType="Emp">
    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>
        <if test="sex != null and sex != ''">
            and sex = #{sex}
        </if>
        <if test="email != null and email!= ''">
            and email = #{email}
        </if>
    </where>
</select>
trim

若标签中有内容时:

​ prefix/suffix:将trim标签中内容前面或后面添加指定内容;

​ prefixOverrides/suffixOverrides:将trim标签中内容前面或后面去掉指定内容;

若标签中没有内容时,trim标签也没有任何效果;

<select id="selectEmpByConditionTrim" resultType="Emp">
    select * from t_emp
    <trim prefix="where" suffixOverrides="and|or">
        <if test="empName != null and empName != ''">
            emp_name = #{empName} and
        </if>
        <if test="age != null and age != ''">
            age = #{age} and
        </if>
        <if test="sex != null and sex != ''">
            sex = #{sex} and
        </if>
        <if test="email != null and email!= ''">
            email = #{email} or
        </if>
    </trim>
</select>
choose、when、otherwise

**注意:**when至少要有一个,otherwise最多只能有一个

<select id="selectEmpByConditionChooseWhenOtherwise" 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="sex != null and sex != ''">
            sex = #{sex}
        </when>
        <when test="email != null and email != ''">
            email = #{email}
        </when>
        <otherwise>
            eid = 1
        </otherwise>
    </choose>
</select>
foreach

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

item:表示数组或集合中的每一个数据;

separator:循环体之间的分隔符;

open:foreach标签所循环的所有内容的开始符;

close:foreach标签所循环的所有内容的结束符

批量删除

<delete id="deleteMoreByArray1">
    delete from t_emp where eid in
    <foreach collection="eids" item="eid" separator="," open="(" close=")">
        #{eid}
    </foreach>
</delete>
<delete id="deleteMoreByArray2">
    delete from t_emp where
    <foreach collection="eids" item="eid" separator="or">
        eid = #{eid}
    </foreach>
</delete>

批量添加

<insert id="insertMoreByList">
    insert into t_emp values
    <foreach collection="emps" item="emp" separator=",">
        (null, #{emp.empName}, #{emp.age}, #{emp.sex}, #{emp.email}, null)
    </foreach>
</insert>
sql

设置SQL片段:XXX

引用SQL片段:

<sql id="empColumns">
    eid,emp_name,age,sex,email
</sql>
<select id="selectEmpByid" resultType="Emp">
    select <include refid="empColumns"/> from t_emp where eid = #{eid};
</select>

Mybatis缓存

mybatis的一级缓存

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

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

  • 不同的SqlSession对应不同的一级缓存;
  • 同一个SqlSession但是查询条件不同;
  • 同一个SqlSession两次查询期间执行了任何一次增删改操作;
  • 同一个SqlSession两次查询期间手动清空了缓存;
mybatis的二级缓存

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

二级缓存开启的条件:

  • 在核心配置文件中,设置全局配置属性cacheEnabled=“true”,默认为true,不需要设置;
  • 在映射文件中设置标签
  • 二级缓存必须在SqlSession关闭或提交之后有效;
  • 查询的数据所转化的实体类类型必须实现序列化接口;

使二级缓存失效的情况

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

二级缓存相关配置

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

  • eviction属性:缓存回收策略

    LRU(Least Recently Used)-最近最少使用的:移除最长时间不被使用的对象;

    FIFO(First in First out)-先进先出:按对象进入缓存的顺序来移除它们;

    SOFT:-软引用:移除基于垃圾回收期状态和软引用规则的对象;

    WEAK:-弱引用:更积极的移除基于垃圾收集器状态和弱引用规则的对象;

    默认是LRU

  • flushInterval属性:刷新间隔,单位毫秒;

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

  • size属性:引用数目,正整数

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

  • readOnly属性:只读,true/false

    true:只读缓存;会给所有调用者返回缓存对象的相同实例。因此这些对象不会被修改。这提供了很重要的性能优势。

    false:读写缓存;会返回缓存对象的拷贝(通过序列化)。这会慢一些,但是安全,因此默认是false。

mybatis缓存查询的顺序
  • 先查询二级缓存,因为二级缓存中可能会有其他程序已经查出来的数据,可以拿来直接使用;
  • 如果二级缓存中没有命中,再查询一级缓存;
  • 如果一级缓存也没有命中,则查询数据库;
  • SqlSession关闭之后,一级缓存中的数据会写入二级缓存;

分页插件

分页插件使用步骤
  • 添加依赖

    <dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper</artifactId>
        <version>5.3.0</version>
    </dependency>
    
  • 配置分页插件

    在Mybatis的核心配置文件中配置插件

    <plugins>
        <!--设置分页插件-->
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>
    
分页插件的使用
  • 在查询功能之前使用PageHelper.startPage(int pageNum, int pageSize)开启分页功能

    pageNum:当前页的页码

    pageSize:每页显示的条数

  • 在查询获取List集合之后,使用PageInfo pageInfo = new PageInfo<>(List list, int navigatePages)获取分页相关数据

    list:分页之后的数据

    navigatePages:导航分页的页码数

  • 常用数据

    字段含义
    pageNum当前页的页码
    pageSize每页显示的条数
    size当前页显示的真实条数
    total总记录数
    pages总页数
    prePage上一页的页码
    nextPage下一页的页码
    isFirstPage/isLastPage是否为第一页/最后一页
    hasPreviousPage/hasNextPage是否存在上一页/下一页
    navigatePages导航分页的页码数
    navigatepageNums导航分页的页码
@Test
public void test(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    PageHelper.startPage(1,2);
    List<User> users = mapper.selectAll();
    users.forEach(System.out::println);
    PageInfo pageInfo = new PageInfo(users, 3);
    System.out.println(pageInfo);
}

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值