mybatis标签及分页（PageHelper，PageInfo）

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);
        }
    }


}