mybatis中pagehepler插件分页以及sql标签（附数据表“游戏王”）

关于插件分页在上面几个test，就是引入相关依赖，然后写一个select all，在创建个page对象，设置好查找第几页，一页多少条数据就行了，md我当初咋就不知道这个简单，当初毕设就自己前后端硬敲，悔死我了。
分页中pageinfo里面的属性更加方便，当前第几页，一共多少页等等足够用了

//当前页
private int pageNum; 

//每页的数量 
private int pageSize; 

//当前页的数量    
private int size; 

//当前页面第一个元素在数据库中的行号
private int startRow;

//当前页面最后一个元素在数据库中的行号 
private int endRow; 

//总记录数
private long total; 

//总页数    
private int pages; 

//结果集(每页显示的数据)
List<T> list;

//第一页    
int firstPage;

//前一页    
int prePage;

//是否为第一页  
boolean isFirstPage;

//是否为最后一页    
boolean isLastPage; 

//是否有前一页   
boolean hasPreviousPage; 

//是否有下一页   
boolean hasNextPage; 

//导航页码数 
int navigatePages; 

//所有导航页号 
int[] navigatepageNums; 

测试类如下：

package com.zm.test;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.github.pagehelper.PageInterceptor;
import com.zm.entity.Hero;
import com.zm.mappers.HeroMapper;
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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

public class MybatisTest {
    private SqlSession sqlSession;
    private InputStream in;
    private HeroMapper heroMapper;


    @Before
    public void init() throws IOException {
        //1.读取配置文件，生成字节输入流
        in= Resources.getResourceAsStream("mybatis.xml");
        //2.获取SqlSessionFactory\
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession=factory.openSession(true);//事务自动提交
        //4.获取代理对象
        heroMapper=sqlSession.getMapper(HeroMapper.class);
    }
    @After
    public void  destroy() throws IOException {
        sqlSession.close();
        in.close();
    }

    @Test
    public void findAllHero(){
        List<Hero> heroes=heroMapper.findAllHero();
        for (Hero hero : heroes) {
            System.out.println(hero);
        }
    }

    /**
     * 分页测试
     */
    @Test
    public void pageHelperTest01(){
        Page page = PageHelper.startPage(1, 5, true);
        List<Hero> heroes=heroMapper.findAllHero();
        for (Hero hero : heroes) {
            System.out.println(hero);
        }
        System.out.println("第几页："+page.getPageNum());
        System.out.println("共几页："+page.getPages());
    }

    /**
     * 扩展PageInfo
     */
    @Test
    public void pageHelperTest02(){
        Page page = PageHelper.startPage(1, 5, true);
        List<Hero> heroes=heroMapper.findAllHero();
        //navigatePages属性表示连续显示多少页
        PageInfo<Hero> info= new PageInfo<>(heroes);
        for (Hero hero : heroes) {
            System.out.println(hero);
        }
        System.out.println("第几页："+info.getPageNum());
        System.out.println("共几页："+info.getPages());
    }

    /**
     * 测试  IF  WHERE  这个组合，满足一个就拼接一个，满足多个，就拼接多个
     * 满足两个，执行的sql：select * from hero WHERE name=? and id =?
     *
     * <select id="findByWhereIf" resultType="Hero">
     *         select * from hero
     *         <where>
     *             <if test="name!=null and name != ''">
     *                 and name=#{name}
     *             </if>
     *             <if test="id != null and id != ''">
     *                 and id =#{id}
     *             </if>
     *         </where>
     *     </select>
     *
     *     最终执行的sql语句为：select * from hero where name=? and id =?
     */
    @Test
    public void findByWhereIf(){
       Hero hero=new Hero();
       hero.setName("好大乖");
       hero.setId(13);

        System.out.println(heroMapper.findByWhereIf(hero));
    }
    /**
     * 测试  Choose when otherwise
     * 根据sql内部的when标签的顺序优先选择搜寻条件
     *         比如：name属性的when在最上面，但有多个属性都满足，此时只拼接第一个name属性，下面的忽略
     * 如果条件都不满足，则拼接otherwise
     *
     * choose标签外面也可以使用where标签，避免使用where 1=1 来解决拼接中when语句中写and导致sql语句拼接报error
     *
     *   <select id="findByChooseWhenOtherwise" resultType="Hero">
     *         select * from hero
     *         <where>
     *             <choose>
     *                 <when test="name != null and name != ''">
     *                      name=#{name }
     *                 </when>
     *                 <when test="id != null and id != ''">
     *                      id=#{id }
     *                 </when>
     *                 <when test="type != null and type != ''">
     *                      type=#{type }
     *                 </when>
     *                 <otherwise>
     *                       type='暗'
     *                 </otherwise>
     *             </choose>
     *         </where>
     *
     *     </select>
     *
     *     最终执行的sql语句为：select * from hero WHERE name=?
     */
    @Test
    public void findByChooseWhenOtherwise(){
       Hero hero=new Hero();
       hero.setName("你大爸");
       hero.setId(12);
       hero.setType("鬼");
       System.out.println(heroMapper.findByChooseWhenOtherwise(hero));
    }

    /**
     * 解决where 1=1 的问题
     * 不只where标签一个，还有trim标签，可以定制此功能
     * 示例： <trim prefix="where" prefixOverrides="and">
     * 效果：select * from hero where name=? and id =?
     * prefix：代表语句的前缀
     * prefixOverrides：需要去除的特殊字符
     *
     * 原语句：
     *   <if test="name!=null and name != ''">
     *            and name=#{name}
     *   </if>
     *   <if test="id != null and id != ''">
     *            and id =#{id}
     *   </if>
     *  去除其中”多余“的“and”
     *  不然就会拼接成 select * from hero where and name=? and id =?
     *
     *  共四个标签
     *  前缀
     *  prefix
     *  prefixOverrides
     *  后缀（前缀功能类推）
     *  suffix
     *  suffixOverrides
     */


    /**
     * 有时我们需要对数据库某条记录的信息进行修改，但是又不一定修改哪条或哪几条信息
     * 这时我们可以使用set
     *
     * 最终执行的sql语句为：update hero SET money =? where id = ?
     */
    @Test
    public void update(){
        Hero hero=new Hero();
        hero.setId(13);
        hero.setMoney(88888);
        System.out.println(heroMapper.update(hero));
        //因为此处的hero有两个条件，使用where if会出现找不到满足两个条件的情况，所以使用choose  when
        //但实际上并不会出现，因为被update修改了，这两个条件可以找到那个唯一的记录，所以不会出现问题
        //但这里只是为了回顾一下，这两种用法各自的特性
        System.out.println(heroMapper.findByChooseWhenOtherwise(hero));
    }

    /**
     * foreach
     *  <select id="findMany" parameterType="List" resultType="Hero">
     *         select * from hero where id in
     *         <foreach collection="list" item="id" index="index" open="(" close=")" separator=",">
     *             #{id}
     *         </foreach>
     *     </select>
     *     item:是循环中当前的元素
     *     index:是元素在集合中的位置下标
     *     collection:是传递过来的参数类型，可以是list，array，map，pojo包装类中数组或者集合的属性名
     *     open，close，separator:代表该语句拼接部分以什么开头，以什么结尾，以什么分割中间的各个元素。
     *                  本例来说，拼接的是in后面的范围，形式是  （ arg0 , arg02 , .....）
     *                  以  （   开头  ， 以   ）   结尾 ，各个元素之间使用 逗号  ，  分割
     *
     *     本例最终执行的sql语句为：select * from hero where id in ( ? , ? , ? )
     */
    @Test
    public void findMany(){
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        List<Hero> heroList=heroMapper.findMany(list);
        for (Hero hero : heroList) {
            System.out.println(hero);
        }
    }

    /**
     * bind
     * sql形式：<bind name="type" value="'%'+type+'%'"/>
     * name是你自定义的名字  value是你自定义的名为name（这里是type）的的bind的值
     * 就像spring中的bean，他的id相当于这里的name，他的class相当于这里的value
     * 你的name叫张三，张三对应的这个value（人）是你
     *
     * <select id="findLike" resultType="Hero" parameterType="Hero">
     *     <bind name="name" value="'%'+name+'%'"/>
     *         select * from hero where name like #{name}
     * </select>
     * 先绑定name和value，放到sql语句中才能知道传入的值是什么
     *
     * 在结合一下所学，where if
     * <select id="findLike" resultType="Hero" parameterType="Hero">
     *         select * from hero
     *         <where>
     *             <if test="name!=null and name != ''">
     *                 <bind name="name" value="'%'+name+'%'"/>
     *                 name like #{name}
     *             </if>
     *             <if test="type != null and type != ''">
     *                 <bind name="type" value="'%'+type+'%'"/>
     *                 type like #{type}
     *             </if>
     *         </where>
     *     </select>
     *  这里注意一下了，我学的时候自己试了试结合where if但是失败了，原因在我把bind统一写在了语句上面
     *  但这个要写在if里面，不然会空指针Can't add values % , null
     */
    @Test
    public void findLike(){
        Hero hero=new Hero();
       // hero.setName("爸");
        hero.setType("风");
        List<Hero> heroes=heroMapper.findLike(hero);
        for (Hero hero1 : heroes) {
            System.out.println(hero1);
        }
    }

}

mapper接口：

    List<Hero> findAllHero();

    Hero findByWhereIf(Hero hero);

    Hero findByChooseWhenOtherwise(Hero hero);

    boolean update(Hero hero);

    List<Hero> findMany(List<Integer> list);

数据库：hero.sql

```sql
/*
Navicat MySQL Data Transfer

Source Server         : root
Source Server Version : 50728
Source Host           : localhost:3306
Source Database       : newdb

Target Server Type    : MYSQL
Target Server Version : 50728
File Encoding         : 65001

Date: 2021-09-02 09:53:37
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for hero
-- ----------------------------
DROP TABLE IF EXISTS `hero`;
CREATE TABLE `hero` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  `type` varchar(10) DEFAULT NULL,
  `money` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `name` (`name`)
) ENGINE=InnoDB AUTO_INCREMENT=14 DEFAULT CHARSET=utf8mb4;

-- ----------------------------
-- Records of hero
-- ----------------------------
INSERT INTO `hero` VALUES ('1', '★E・HERO 羽翼人', '风', '1000');
INSERT INTO `hero` VALUES ('2', '★E・HERO 爆热女郎', '炎', '1200');
INSERT INTO `hero` VALUES ('3', '★E・HERO 黏土人', '地', '800');
INSERT INTO `hero` VALUES ('4', '★E・HERO 电光人', '光', '1600');
INSERT INTO `hero` VALUES ('5', '★E・HERO 水泡人', '水', '800');
INSERT INTO `hero` VALUES ('6', '★E・HERO 荒野人', '地', '1500');
INSERT INTO `hero` VALUES ('7', '★E・HERO 刀锋侠', '地', '2600');
INSERT INTO `hero` VALUES ('8', '★E・HERO 死灵侠', '暗', '1600');
INSERT INTO `hero` VALUES ('9', '★E・HERO 新水泡人', '水', '800');
INSERT INTO `hero` VALUES ('10', '★E・HERO 火焰翼人', '风', '1000');
INSERT INTO `hero` VALUES ('12', '你大爸', '鬼', '99999');
INSERT INTO `hero` VALUES ('13', '好大乖', '神', '88888');