MyBatis 单表的增删改查

在这里插入图片描述

✅作者简介：2022年博客新星第八。热爱国学的Java后端开发者，修心和技术同步精进。
🍎个人主页：Java Fans的博客
🍊个人信条：不迁怒，不贰过。小知识，大智慧。
💞当前专栏：SSM 框架从入门到精通
✨特色专栏：国学周更-心性养成之路
🥭本文内容：MyBatis 单表的增删改查

本文目录

- 结果映射 ResultMap
- 使用 selectOne 方法查询单条记录
- 使用 insert 方法添加记录
- - 主键非自增长
  - 主键值由数据库自增长
- 使用 delete 方法删除记录
- 使用 update 方法修改记录
- 模糊查询
- 动态查询
- - if 标签
  - where 标签
  - set 标签
  - trim 标签
  - 使用 Map 封装查询条件
  - choose 标签
  - foreach 标签
  - sql 标签
- mybatis分页插件
- getMapper 面向接口编程
- 多参数查询

在这里插入图片描述

通过上一篇文章的学习可了解到，MyBatis 可以方便的对数据库进行操作，而数据库表可能是一个相对独立的表（这里谓之单表），也可能两个或多个有密切联系的表（这里谓之多表），本文先来学习单表的增删改查操作，下一篇文章我们再来学习多表关联查询。

先来认识一下 SqlSession 的若干方法，这些方法被用来执行定义在 mapper 映射文件中的 SELECT、INSERT、UPDATE 和 DELETE 语句。以下是一些常用的方法。

<T> T selectOne(String statement, Object parameter) 查询单条记录
<E> List selectList(String statement, Object parameter) 查询记录集合
<K,V> Map<K,V> selectMap(String statement, Object parameter, String mapKey) 查询记录封装成 Map 集合
int insert(String statement, Object parameter) 插入一条记录
int update(String statement, Object parameter) 修改一条记录
int delete(String statement, Object parameter) 删除一条记录

上述方法中的第一个参数 statement 通常使用 namespace + id 的字符串，namespace 定位到唯一的 mapper 映射文件，id 定位到这个 mapper 映射文件指定的 SQL 语句。

第二个参数可以是原生类型（自动装箱或包装类）、JavaBean、POLO 或 Map，用于限定查询条件等。

其中 selectOne 和 selectList 的不同之处是 selectOne 必须返回一个对象，如果有多个对象，或者没有返回（或返回了 null），那么就会抛出异常。如果不确定返回了多少对象，就使用 selectList。

以上方法可以重载，第二个参数不是必要的,重载方法如下。

<T> T selectOne(String statement)
<E> List<E> selectList(String statement)
<K,V> Map<K,V> selectMap(String statement, String mapKey)
int insert(String statement)
int update(String statement)
int delete(String statement)

结果映射 ResultMap

所谓结果映射就是让数据表的字段名称（即列名）与 Java 实体类的属性名称一一进行关联匹配的一种机制，以便 MyBatis 查完数据库后能将关系型查询结果正确地封装为 Java 对象。如果数据库的字段名称跟相应的类的属性名称不一样，不作处理的话，mybatis 运行后相应的字段处的查询结果就为空。

在映射文件 UserMapper.xml 中，如果 SQL 查询语句使用别名了，则 <select> 节点中的 SQL 查询语句修改如下：

    <select id="list" resultType="user">
        select * from user
    </select>

然后运行 UserMapperTest.java 测试类中的 testList 方法：

    @Test
    public void testList() {
        SqlSession sqlSession = factory.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> list = mapper.list();
        for (User user : list) {
            System.out.println("user = " + user);
        }
    }

运行结果如下：

在这里插入图片描述
可以发现查出来的数据为 null，这是因为数据表 user 的字段与对象 User 的属性名称不一致造成的。数据库查出来的数据无法封装到对应的对象属性中去。

解决办法有两个：

方法一：在 SQL 语句中使用别名，让查询结果字段与对象属性一致
方法二：利用结果映射 ResultMap

在 UserMapper.xml 中配置结果映射 ResultMap，代码如下：

    <!--定义映射规则-->
    <resultMap id="userMap" type="user">
        <id column="u_id" property="id"></id>
        <result column="u_name" property="userName"></result>
        <result column="u_password" property="password"></result>
    </resultMap>
    <select id="list" resultMap="userMap">
        select * from user
    </select>

上面代码中，将原先的 resultType=“user” 改为了 resultMap=“userMap”，其中，userMap为结果映射 resultMap 中的 id。

运行原有的测试类，效果如下：

在这里插入图片描述
可以正常输出了，没有出现 null 的情况，证明了结果映射成功。

使用 selectOne 方法查询单条记录

实现步骤：

【1】在 UserMapper.java 接口中新增一个方法：

User getById(Integer id);

【2】在映射文件 UserMapper.xml 中新增一段 select 语句：

    <select id="getById" parameterType="int" resultMap="userMap">
        select * from user where u_id=#{id}
    </select>

其中，parameterType=“int” 表示参数的类型为整型，也可省略不用，MyBatis 会自动识别传进来的参数类型。此外仍然使用结果映射 resultMap。

<select> 标签中的 id 属性用于唯一标识该 SQL 语句，要与接口中方法名称一致。SQL语句中的 #{ }：对指定参数类型属性值的引用。

【3】在测试类 UserMapperTest.java 中添加 testGetById 方法，代码如下：

    @Test
    public void testGetById() {
        SqlSession sqlSession = factory.openSession(true);
        User user = sqlSession.selectOne("cn.kgc.mybatis.mapper.UserMapper.getById", 1);
        System.out.println(user);
    }

sqlSession.selectOne 方法，用于查询单条数据，其中第一个参数是 UserMapper.java 接口中 getById 方法的全限定名，第二个参数是 id 值。

运行结果如下：

在这里插入图片描述

使用 insert 方法添加记录

主键非自增长

实现步骤：

【1】检查数据库 user 表，将主键 u_id 改为非自增长，然后在 UserMapper.java 接口中新增一个方法。

	int insertUser(User user);

【2】在映射文件 UserMapper.xml 中新增一段 insert 语句。

    <!--添加一个用户-->
    <insert id="insertUser" parameterType="user">
        insert into user (u_id,u_name,u_password) values (#{id},#{userName},#{password})
    </insert>

parameterType=“user” 也可不加，MyBatis 会自动判断传进来的参数类型。#{id} 是占位符，传进来的值是参数类型 User 对应的同名属性值，即 User 对象的 id 属性的值，其他类推。

【3】在测试类 UserMapperTest.java 中添加 testGetById 方法，代码如下：

    @Test
    public void testInsertUser(){
        SqlSession sqlSession = factory.openSession(true);
        User user=new User();
        user.setId(4);
        user.setUserName("武松");
        user.setPassword("12345");
        int count = sqlSession.insert("cn.kgc.mybatis.mapper.UserMapper.insertUser", user);
        sqlSession.commit();
        System.out.println(count);
    }

这里用到 insert 方法，用于添加记录，返回受影响的行数。运行效果如下：

在这里插入图片描述

注意： 如果数据库中没有发现这条新纪录，可能是因为你没有使用 sqlSession.commit() 方法来实现事务提交。

主键值由数据库自增长

MySQL 数据库表的主键值在设置为自动增长的情况下，程序只需要添加除主键外的其他字段即可。但一般情况下程序中添加一个 User 对象后无法马上获得该对象的 id 属性值，需要一定的配置才行，具体步骤如下：

【1】修改 MySQL 数据库，设置 user 表的主键 u_id 自动增长。

在这里插入图片描述

注意：这里用的 MySQL 客户端是 SQLyog。

【2】在 UserMapper.java 接口中新增一个方法。

	int insertUserAutoIncrement(User user);

【3】在映射文件 UserMapper.xml 中新增一段 insert 语句。

    <!--添加一个用户,u_id自增-->
    <insert id="insertUserAutoIncrement">
        insert into user (u_name,u_password) values (#{userName},#{password})
    </insert>

【4】在测试类 UserMapperTest.java 中添加 testInsertUserAuto 方法，代码如下：

	@Test
    public void testInsertUserAuto(){
        SqlSession sqlSession = factory.openSession(true);
        User user=new User();
        user.setUserName("武松");
        user.setPassword("12345");
        int count = sqlSession.insert("cn.kgc.mybatis.mapper.UserMapper.insertUserAutoIncrement", user);
        sqlSession.commit();
        if(count>0){
            System.out.println("添加成功！");
            System.out.println("新添加的学生编号是："+user.getId());
        }
    }

运行结果如下：

在这里插入图片描述

可见添加时成功的，但添加后学生编号为0，即无法在添加完数据后立即回去主键的值，如何在数据添加成功后获取这个自增长的主键值呢？请看下一个步骤。

【5】修改映射文件，代码如下：

    <!--添加一个用户,u_id自增-->
    <insert id="insertUserAutoIncrement" parameterType="user"
    keyProperty="id" useGeneratedKeys="true">
        insert into user (u_name,u_password) values (#{userName},#{password})
    </insert>

关键代码是 keyProperty=“id” useGeneratedKeys=“true”，其中，keyProperty 指的是实体类的某个属性接受接受主键返回的值，useGeneratedKeys 指的是使用自动生成的主键。

【6】二次测试，代码如下：

    @Test
    public void testInsertUserAuto(){
        SqlSession sqlSession = factory.openSession(true);
        User user=new User();
        user.setUserName("苏东坡");
        user.setPassword("32154");
        int count = sqlSession.insert("cn.kgc.mybatis.mapper.UserMapper.insertUserAutoIncrement", user);
        sqlSession.commit();
        if(count>0){
            System.out.println("添加成功！");
            System.out.println("新添加的用户编号是："+user.getId());
        }
    }

二次测试结果如下：

在这里插入图片描述

可以发现，已经获取到新添加的用户的主键值。

使用 delete 方法删除记录

实现步骤：

【1】在 UserMapper.java 接口中新增一个方法 deleteUserById 如下：

    int deleteUserById(Integer id);

【2】在映射文件 UserMapper.xml 中新增一段 delete 语句如下：

    <!--删除一个用户-->
    <delete id="deleteUserById">
        delete from user where u_id=#{id}
    </delete>

【3】在测试类 UserMapperTest.java 中添加 testDeleteUserById 方法，代码如下：

    @Test
    public void testDeleteUserById(){
        SqlSession sqlSession = factory.openSession(true);
        int count = sqlSession.delete("cn.kgc.mybatis.mapper.UserMapper.deleteUserById", 4);
        sqlSession.commit();
        if(count>0){
            System.out.println("删除成功！");
        }else{
            System.out.println("用户不存在！");
        }
    }

运行效果如下：

在这里插入图片描述

使用 update 方法修改记录

实现步骤：

【1】在 UserMapper.java 接口中新增一个方法 updateUserById 如下：

    int updateUserById(User user);

【2】在映射文件 UserMapper.xml 中新增一段 update 语句如下：

    <!--更新用户信息-->
    <update id="updateUserById">
        update user set u_name=#{userName},u_password=#{password} where u_id=#{id}
    </update>

【3】在测试类 UserMapperTest.java 中添加 updateUserById 方法，代码如下：

    @Test
    public void testUpdateUserById(){
        SqlSession sqlSession = factory.openSession(true);
        User user=new User();
        user.setUserName("苏东");
        user.setPassword("123456");
        user.setId(7);
        int count = sqlSession.update("cn.kgc.mybatis.mapper.UserMapper.updateUserById", user);
        sqlSession.commit();
        if(count>0){
            System.out.println("更新成功！");
        }else{
            System.out.println("用户不存在！");
        }
    }

运行效果如下：

在这里插入图片描述

模糊查询

实现步骤：

【1】在 UserMapper.java 接口中新增一个方法 findUserByName 如下：

    List<User> findUserByName(String userName);

【2】在映射文件 UserMapper.xml 中新增一段 select 语句如下：

    <!--根据姓名模糊查询-->
    <select id="findUserByName" resultType="cn.kgc.mybatis.entity.User" resultMap="userMap">
        select * from user where u_name like '%' #{userName} '%'
    </select>

【3】在测试类 UserMapperTest.java 中添加 testFindUserByName 方法，代码如下：

    @Test
    public void testFindUserByName(){
        SqlSession sqlSession = factory.openSession(true);
        List<User> list = sqlSession.selectList("cn.kgc.mybatis.mapper.UserMapper.findUserByName", "张");
        for (User user : list) {
            System.out.println("user = " + user);
        }
    }

运行效果如下：

在这里插入图片描述

动态查询

在大家熟悉的网购中，筛选商品是一个非常重要的功能。筛选条件有很多，每个人选的条件都不一样，这里就用到了动态查询。前台页面把某个用户的筛选条件传到后台服务器，后台服务器根据筛选条件动态生成 SQL 语句，再从数据库中查找到合适商品。

动态 SQL 多用于解决查询条件不确定的情况，在程序运行期间，根据运行期间，根据用户提交的多种可能的查询条件进行查询，提交的查询条件不同，动态生成和执行的 SQL 语句也不同。动态 SQL 通过 MyBatis 提供的各种标签对条件做出判断以实现动态拼接 SQL 语句。

常用的动态 SQL 标签有 <if>、<where>、<set>、<choose/>、<foreach> 等。

映射文件 UserMapper.xml 中定义映射规则，代码如下：

    <!--定义映射规则-->
    <resultMap id="userMap" type="user">
        <id column="u_id" property="id"></id>
        <result column="u_name" property="userName"></result>
        <result column="u_password" property="password"></result>
        <result column="u_state" property="state"></result>
    </resultMap>

if 标签

对于该标签的执行，当 test 的值为 true 时，会将其包含的 SQL 片段拼接到其所在的 SQL 语句中。

实现步骤：

【1】在接口 UserMapper.java 中添加方法 selectUserIf 如下：

	List<User> selectUserIf(@Param("userName") String userName, @Param("state") int state);

【2】在映射文件 UserMapper.xml 中添加一条 select 语句，代码如下：

    <select id="selectUserIf" resultMap="userMap">
        select * from user where 1=1
        <if test="userName!=null">
            and u_name like '%' #{userName} '%'
        </if>
        <if test="state!=null">
            and u_state=#{state}
        </if>
    </select>

【3】在测试类 UserMapperTest.java 中添加 testSelectUserIf 方法，代码如下：

    @Test
    public void testSelectUserIf() {
        SqlSession sqlSession = factory.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.selectUserIf("张", 1);
        for (User user : users) {
            System.out.println("user = " + user);
        }
    }

查询姓名中含有“张”字，并且 state 状态为1的记录，结果如下：

在这里插入图片描述

where 标签

<if/>标签的中存在一个比较麻烦的地方，需要在 where 后手工添加 “1=1” 的子句。因为，若 where 后的所有<if/>条件均为 false，where 后没有 1=1 子句的话，则 SQL 中就会只剩下一个空的 where，SQL 出错。可以使用<where>标签实现同样的效果，而无须 “1=1” 这个看起来额外的东西。

实现步骤：

【1】在接口 UserMapper.java 中添加方法 selectUserWhere 如下：

	List<User> selectUserWhere(@Param("userName") String userName, @Param("state") int state);

【2】在映射文件 UserMapper.xml 中添加一条 select 语句，代码如下：

    <select id="selectUserWhere" resultMap="userMap">
        select * from user
        <where>
            <if test="userName!=null">
                and u_name like '%' #{userName} '%'
            </if>
            <if test="state!=null">
                and u_state=#{state}
            </if>
        </where>
    </select>

【3】在测试类 UserMapperTest.java 中添加 testSelectUserIf 方法，代码如下：

    @Test
    public void testSelectUserWhere() {
        SqlSession sqlSession = factory.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.selectUserIf("张", 1);
        for (User user : users) {
            System.out.println("user = " + user);
        }
    }

查询姓名中含有“张”字，并且 state 状态为1的记录，结果如下：

在这里插入图片描述

set 标签

<set>标签用于更新操作的 update 语句中

实现步骤：

【1】在接口 UserMapper.java 中添加方法 updateUserSet 如下：

	Integer updateUserSet(User user);

【2】在映射文件 UserMapper.xml 中添加一条 **update ** 语句，代码如下：

    <update id="updateUserSet">
        update user
        <set>
            <if test="userName!=null">
                u_name = #{userName}
            </if>
            <if test="password!=null">
                ,u_password=#{password}
            </if>
            <if test="state!=null">
                ,u_state = #{state}
            </if>
        </set>
        where u_id = #{id}
    </update>

【3】在测试类 UserMapperTest.java 中添加 testUpdateUserSet 方法，代码如下：

    @Test
    public void testUpdateUserSet() {
        SqlSession sqlSession = factory.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setPassword("888888");
        user.setState(1);
        user.setUserName("李清照");
        user.setId(2);
        Integer integer = mapper.updateUserSet(user);
        System.out.println("line = " + integer);
    }

运行效果：

在这里插入图片描述

trim 标签

trim标记是一个格式化的标记，可以完成set或者是where标记的功能

用 trim 改写上面的 if+where 语句

    <select id="selectUserWhere" resultMap="userMap">
        select *  from user
        <trim prefix="where" prefixOverrides="">
            <if test="userName!=null">
                 and u_name like '%' #{userName} '%'
             </if>
            <if test="state!=null">
               and u_state=#{state}
            </if>
        </trim>
    </select>

prefix：前缀
prefixoverride：去掉第一个and或者是or

用 trim 改写上面的 if+set 语句

    <update id="updateUserSet">
        update user
        <trim prefix="set" suffixOverrides=",">
            <if test="userName!=null">
                u_name = #{userName}
            </if>
            <if test="password!=null">
                ,u_password=#{password}
            </if>
            <if test="state!=null">
                ,u_state = #{state}
            </if>
        </trim>
        where u_id = #{id}
    </update>

suffix：后缀
suffixoverride：去掉最后一个逗号（也可以是其他的标记，就像是上面前缀中的and一样）

使用 Map 封装查询条件

上面几个案例中，多个查询条件都封装到一个 User 对象的属性中去了，但实际开发中，可能有些条件无法封装到同一个对象中去，这时可以采用 Map 类型进行封装和传递参数。

实现步骤：

【1】在接口 UserMapper.java 中添加方法 searchUsersMap 如下：

	List<User> searchUsersMap(Map map);

【2】在映射文件 UserMapper.xml 中添加一条 select 语句，代码如下：

    <select id="searchUsersMap" resultMap="userMap">
        select * from user
        <where>
            <if test="userName!=null">
                and u_name like '%' #{userName} '%'
            </if>
            <if test="state!=null">
                and u_state=#{state}
            </if>
        </where>
    </select>

【3】在测试类 UserMapperTest.java 中添加 testUpdateUserSet 方法，代码如下：

    @Test
    public void testSearchUsersMap() {
        SqlSession sqlSession = factory.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String, Object> map = new HashMap<>();
        map.put("userName", "张");
        map.put("state", 1);
        List<User> users = mapper.searchUsersMap(map);
        for (User user : users) {
            System.out.println("user = " + user);
        }
    }

运行效果：

在这里插入图片描述

choose 标签

该标签里面包含 <when/> <otherwise/> 两个子标签，可以包含多个 <when/> 与一个 <otherwise/>。它们联合使用，完成类似 Java 中的开关语句 switch…case 功能。

实现步骤：

【1】在接口 UserMapper.java 中添加方法 searchUsersMap 如下：

	List<User> searchUsersChoose(User user);

【2】在映射文件 UserMapper.xml 中添加一条 select 语句，代码如下：

    <select id="searchUsersChoose" resultMap="userMap">
        select * from user
        <where>
            <choose>
                <when test="userName!=null">
                    and u_name like '%' #{userName} '%'
                </when>
                <when test="state!=null">
                    and u_state=#{state}
                </when>
                <otherwise>
                    and 1!=1
                </otherwise>
            </choose>
        </where>
    </select>

<choose/> 标签会从第一个 <when/> 开始，逐个向后进行条件判断。若出现 <when/> 中 test 属性值为 true 的情况，就直接结束 <choose/> 标签，不再向后进行判断查找。若所以 <when/> 的 test 判断结果均为 false，则最后会执行 <otherwise/> 标签。这种功能类似于 switch，实现了分支选择。

【3】在测试类 UserMapperTest.java 中添加 testUpdateUserSet 方法，代码如下：

    @Test
    public void testSearchUsersChoose() {
        SqlSession sqlSession = factory.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User usr=new User();
        usr.setUserName("张");
        usr.setState(1);
        List<User> users = mapper.searchUsersChoose(usr);
        for (User user : users) {
            System.out.println("user = " + user);
        }
    }

运行效果：

在这里插入图片描述

foreach 标签

<foreach/>标签用于实现对数组与集合类型的输入参数的遍历。其 collection 属性表示要遍历的集合类型，如果是数组，其值就用 array。open、close、separator 这些属性用于对遍历内容进行 SQL 拼接。

需求：我们需要查询 user 表中 id 分别为1,2,3的用户，sql 语句：

	select * from user where id=1 or id=2 or id=3

	select * from user where id in (1,2,3)

用 foreach 来改写 select * from user where id=1 or id=2 or id=3

<select id="selectUserByListId" parameterType="com.ys.vo.UserVo" resultType="com.ys.po.User">
    select * from user
    <where>
        <!--
            collection:指定输入对象中的集合属性
            item:每次遍历生成的对象
            open:开始遍历时的拼接字符串
            close:结束时拼接的字符串
            separator:遍历对象之间需要拼接的字符串
            select * from user where 1=1 and (id=1 or id=2 or id=3)
          -->
        <foreach collection="ids" item="id" separator="or">
            id=#{id}
        </foreach>
    </where>
</select>

用 foreach 来改写 select * from user where id in (1,2,3)

<select id="selectUserByListId" parameterType="com.ys.vo.UserVo" resultType="com.ys.po.User">
        select * from user 
        <where>
            <!--
                collection:指定输入对象中的集合属性
                item:每次遍历生成的对象
                open:开始遍历时的拼接字符串
                close:结束时拼接的字符串
                separator:遍历对象之间需要拼接的字符串
                select * from user where1=1 and id in (1,2,3)
              -->
            <foreach collection="ids" item="id" open="id in ("separator="," close=") " >
                #{id}
            </foreach>
        </where>
 </select>

sql 标签

有时候可能某个 sql 语句我们用的特别多，为了增加代码的重用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用。

假如我们需要经常根据用户名和性别来进行联合查询，那么我们就把这个代码抽取出来，如下：

<sql id="selectUserByUserNameAndSexSQL">
    <if test="username != null and username != ''">
        AND username = #{username}
    </if>    
    <if test="sex != null and sex != ''">
        AND sex = #{sex}
    </if>
</sql>

<select id="selectUserByUsernameAndSex" resultType="user" parameterType="com.ys.po.User">
    select * from user
    <trim prefix="where" prefixOverrides="and | or">
        <!-- 引用 sql 片段，如果refid 指定的不在本文件中，那么需要在前面加上 namespace -->
        <include refid="selectUserByUserNameAndSexSQL"></include>
        <!-- 在这里还可以引用其他的 sql 片段 -->
    </trim>
</select>

注意：

①、最好基于单表来定义 sql 片段，提高片段的可重用性
②、在 sql 片段中最好不要包括 where

mybatis分页插件

	<!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
	<dependency>
	    <groupId>com.github.pagehelper</groupId>
	    <artifactId>pagehelper</artifactId>
	    <version>5.2.1</version>
	</dependency>

	<!--在mybatis配置文件中 配置mybatis插件 -->
	<plugins>
		<plugin interceptor="com.github.pagehelper.PageInterceptor">
			<!-- 配置mysql方言 -->
			<property name="helperDialect" value="mysql" />
			<!-- 设置为true时，如果pageSize=0就会查询出全部的结果 -->
			<property name="pageSizeZero" value="true" />
			<!-- 3.3.0版本可用，分页参数合理化，默认false禁用 -->
			<!-- 启用合理化时，如果pageNum<1会查询第一页，如果pageNum>pages会查询最后一页 -->
			<!-- 禁用合理化时，如果pageNum<1或pageNum>pages会返回空数据 -->
			<property name="reasonable" value="true" />
		</plugin>
	</plugins>

实例

 	// 测试分页插件的使用
    @Test
    public void  test06(){
        SqlSession session = factory.openSession(true);
        StudentDao mapper = session.getMapper(StudentDao.class);
        PageHelper.startPage(5, 3);
        List<Student> all = mapper.findAll();
        PageInfo<Student> pageInfo = new PageInfo<>(all);

        //获取分页的相关数据
        System.out.println(pageInfo);
        //获取总条数
        long total = pageInfo.getTotal();
        System.out.println(total);
        //获取当前页的显示数据
        List<Student> list = pageInfo.getList();
        list.forEach(student-> System.out.println(student));

    }

getMapper 面向接口编程

之前我们自定义 Dao 层接口实现类时发现一个问题：Dao 层的实现类其实并没有干什么实质性的工作，它仅仅就是通过 SqlSession 的相关 API 定位到映射文件 mapper 中相应 id 的 SQL 语句，真正对数据进行操作的工作其实是由框架通过映射文件 mapper 中的 SQL 完成的。

那么，MyBatis 框架可以抛开 Dao 的实现类，直接定位到映射文件 mapper 中的相应 SQL 语句，对数据库进行操作吗？答案是肯定的。可以通过Mapper的动态代理方式实现

实现步骤如下图目录结构所示：

在这里插入图片描述

注意：
- 确保映射文件 UserMapper.xml 的 namespace 与接口类的全路径名称一致；
- 在 resources 中创建目录时，注意目录间用 / 分割，如创建 cn.kgc.mybatis04.mapper ，创建 Directory 时，写法为：cn/kgc/mybatis04/mapper，这样就可以准确创建目录结构。

多参数查询

上面的案例中要传多个参数，把这些参数都巧妙的封装成一个对象或一个 Map，表面上还是一个参数。有时想直接传递多个参数，而不想封装，如何实现？

实现步骤：

【1】在接口 UserMapper.java 中添加方法 selectUserWhere 如下：

	List<User> selectUserWhere(@Param("userName") String userName, @Param("state") int state);

这里用到了 @Param 注解。映射文件的 SQL 语句中的输入参数应与注解里面的参数一致。

【2】在映射文件 UserMapper.xml 中添加一条 select 语句，代码如下：

	<!--多参数查询-->
    <select id="selectUserWhere" resultMap="userMap">
        select * from user where u_name like '%' #{userName} '%' and u_state=#{state}
    </select>