MyBatis总结

最新推荐文章于 2024-05-31 10:46:10 发布

aoshenbin6061

最新推荐文章于 2024-05-31 10:46:10 发布

阅读量85

点赞数

文章标签： java 数据库测试

原文链接：http://www.cnblogs.com/jingmochen/p/11441119.html

版权

Mybatis

大纲

介绍mybatis
基于mybatis的开发过程
查询的条件不在实体类中时
几个优化的地方
使用接口结合xml文件
解决字段与属性不匹配
关联查询
$和#的区别
添加对象时如何把生成的id返回
动态sql语句
逆向工程(generator)
分页助手(pagehelper)

1. 介绍mybatis

mybatis支持普通sql语句查询、存储过程和高级映射的持久层框架。

持久化：即把Java对象保存到数据库中

特点：

消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的封装

使用xml文件进行配置和映射

2. 基于mybatis的开发过程

1) 新建Java工程

2) 导入mybatis的jar包以及数据库驱动（放入工程目录下的lib文件夹中，需要Build Path）

3) 创建数据库和表格

4) 添加实体类和构造函数

5) 添加mybatis的配置文件conf.xml(加载数据库驱动、连接到数据库、数据库的用户名和密码)

*在resource文件夹下添加

*conf.xml中是配置数据源的信息：即数据库的信息

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 3 "http://mybatis.org/dtd/mybatis-3-config.dtd">
 4 <configuration>
 5     <environments default="development">
 6         <environment id="development">
 7             <transactionManager type="JDBC" />
 8             <dataSource type="POOLED">
 9                 <property name="driver" value="com.mysql.jdbc.Driver" />
10                 <property name="url"
11                     value="jdbc:mysql://localhost:3306/mybatis" />
12                 <property name="username" value="root" />
13                 <property name="password" value="root" />
14             </dataSource>
15         </environment>
16     </environments>
17 </configuration>

6) 定义操作user表的sql映射文件userMapper.xml(以user表为例，映射文件即在实体类、表、sql语句之间映射关系)

*在src目录下新建mapper的包，再在该包下新建userMapper.xml文件

*id：标识该标签

*parameterType：参数的数据类型

*resultType：返回值的数据类型

*mapper：即映射

*namespace:表示命名空间，现在的目的是区分id的

*mybatis中的占位符用#{ }

#{id}:类似于EL表达式解析id

1 <?xml version="1.0" encoding="UTF-8" ?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
3 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
4 <mapper namespace="com.zhiyou.clg.mapper.UserMapper">
5     <select id="selectUser" parameterType="int"
6         resultType="com.zhiyou.clg.bean.User">
7         select * from user where id=#{id}
8     </select>
9 </mapper>

7) 在conf.xml文件中注册user Mapper.xml文件(即把映射文件引入到配置文件中)

*在mappers标签中使用mapper标签（属性：resource）

1         <mappers>
2         <mapper resource="com/zhiyou/clg/mapper/UserMapper.xml"/>
3     </mappers>

　　8) 进行单元测试

//解析配置文件conf.xml

Reader reader = Resources.getResourceAsReader(“conf.xml”);

//获取SessionFactory对象

SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);

//获取Session对象。这里表示jdbc中Connection.是操作数据库的

SqlSession session = sessionFactory.openSession();

User user = session.selectOne("com.zhiyou.clg.mapper.userMapper.getUser", 1);

*进行增删改的时候需要进行手动提交任务,即将数据提交到数据库中

session.commit();

手动提交可实现事物管理：事物是由一系列动作组成，这些动作要么都执行，要么都不执行

 1 package com.zhiyou.clg.mapper;
 2 
 3 import static org.junit.jupiter.api.Assertions.*;
 4 
 5 import java.io.IOException;
 6 import java.io.Reader;
 7 
 8 import org.apache.ibatis.io.Resources;
 9 import org.apache.ibatis.session.SqlSession;
10 import org.apache.ibatis.session.SqlSessionFactory;
11 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
12 import org.junit.jupiter.api.AfterAll;
13 import org.junit.jupiter.api.BeforeAll;
14 import org.junit.jupiter.api.Test;
15 
16 import com.zhiyou.clg.bean.User;
17 
18 class UserTest {
19     private static SqlSession session = null;
20     final static String str="com.zhiyou.clg.mapper.UserMapper";
21     @BeforeAll//测试前会执行
22     static void setUpBeforeClass() throws Exception {
23                 //解析配置文件
24                 Reader reader = Resources.getResourceAsReader("conf.xml");
25                 //获取SessionFactory对象
26                 SqlSessionFactory SessionFactory = new SqlSessionFactoryBuilder().build(reader);
27                 //获取Session对象
28                 session = SessionFactory.openSession();
29     }
30 
31     @AfterAll//测试后执行
32     static void tearDownAfterClass() throws Exception {
33         session.commit();
34     }
35 
36     @Test
37     void test() throws IOException {
38         User user=session.selectOne(str+".selectUser", 1);
39         System.out.println(user);
40     }
41 
42 }

3. 查询的条件不在实体类中时

way1：参数类型封装到map中#{参数}--->map的键（此时参数类型为java.util.Map或map）

*若xml文件中出现了特殊字符

way1：使用转义字符

way2：使用<![CDATA[ ]]>

*映射文件UserMapper.xml：

1 <select id="selectway1" parameterType="map"
2         resultType="com.zhiyou.clg.bean.User">
3         <![CDATA[select * from user where age>=#{min} and age<=#{max}]]>
4         <!-- select *from user where age between #{min} and #{max} -->
5     </select>

　　*单元测试：

1 @Test
2     void testselectway1() throws IOException {
3         Map<String, Integer> map=new HashMap<String, Integer>();
4         map.put("min", 18);
5         map.put("max", 19);
6         
7         List<User> list=session.selectList(str+".selectway1",map);
8         System.out.println(list);
9     }

　　*若xml文件中出现了特殊字符

way1：使用转义字符

way2：使用<![CDATA[ ]]>

way2：封装一个实体类

4. 几个优化的地方

1)习惯把数据源信息放到一个属性文件中。后缀为properties

* # 在properties中表示注释

*在resource目录下新建该文件

1 jdbc.driver=com.mysql.jdbc.Driver
2 jdbc.url=jdbc:mysql://localhost:3306/mybatis
3 jdbc.username=root
4 jdbc.password=root

　　*在配置文件conf.xml中引入属性文件<properties resource=”文件名”/>

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 3 "http://mybatis.org/dtd/mybatis-3-config.dtd">
 4 <configuration> 
 5     <properties resource="db.properties"/>
 6     <environments default="development">
 7         <environment id="development">
 8             <transactionManager type="JDBC" />
 9             <dataSource type="POOLED">
10                 <property name="driver" value="${jdbc.driver}" />
11                 <property name="url" value="${jdbc.url}" />
12                 <property name="username" value="${jdbc.username}" />
13                 <property name="password" value="${jdbc.password}" />
14             </dataSource>
15         </environment>
16     </environments>
17     <mappers>
18         <mapper resource="com/zhiyou/clg/mapper/UserMapper.xml"/>
19     </mappers>
20 </configuration>

　　2)在conf.xml文件中为实体类起别名----不建议使用别名，建议还是在映射文件中使用全类名

<typeAlias type=”实体类路径” alias=”别名”/>//为某个实体类起别名

<package name=”实体类包名” />//将包下所有的实体类的别名起为对应的实体类名，故可以直接使用

3)添加日志

*在lib目录下导入日志jar包

*在resource目录下新建log4j.properties或者. log4j.xml文件（固定内容复制）

 1 log4j.properties,
 2 log4j.rootLogger=DEBUG, Console
 3 #Console
 4 log4j.appender.Console=org.apache.log4j.ConsoleAppender
 5 log4j.appender.Console.layout=org.apache.log4j.PatternLayout
 6 log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
 7 log4j.logger.java.sql.ResultSet=INFO
 8 log4j.logger.org.apache=INFO
 9 log4j.logger.java.sql.Connection=DEBUG
10 log4j.logger.java.sql.Statement=DEBUG
11 log4j.logger.java.sql.PreparedStatement=DEBUG

5. 使用接口结合xml文件

　　1)创建dao包，在包下创建接口，该接口要和映射文件匹配

1 package com.zhiyou.clg.dao;
2 import java.util.List;
3 import org.apache.ibatis.annotations.Param;
4 import com.zhiyou.clg.bean.User;
5 public interface UserDao {
6     List<User> selectUser2(int id);
7 }

　　2)映射文件中的namespace一定要和接口所在的包以及接口的名字一样

　　3)标签中的id一定和接口中方法的名字对照

1 <?xml version="1.0" encoding="UTF-8" ?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
3 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
4 <mapper namespace="com.zhiyou.clg.dao.UserDao">
5     <select id="selectUser2" parameterType="int"
6         resultType="com.zhiyou.clg.bean.User">
7         select * from user where id=#{id}
8     </select>
9 </mapper>

　　4)测试时：

1 @Test
2     void testselectUser2() {
3         UserDao userDao = session.getMapper(UserDao.class);
4         List<User> list = userDao.selectUser2(1);
5         System.out.println(list);
6     }

6. 解决字段与属性不匹配

　　way1：sql语句中为字段起别名，别名与实体类名一致

1 <select id="getOrder2" parameterType="int" resultType="com.zhiyou.clg.bean.Order">
2           select order_id id,order_no no,order_price price from Orders where order_id=#{id}   
3 </select>

　　way2：使用resultMap标签(属性：type、id)来定义实体类与字段之间的对应关系，其标签内包含标签id（主键）、标签result（普通字段，属性：column、property）

1        <select id="getOrder" resultMap="myMap">
2           select * from Orders where Order_id=#{id}   
3     </select>
4     <resultMap type="com.zhiyou.clg.bean.Order" id="myMap">
5         <id column="order_id" property="id"/>
6         <result column="order_no" property="no"/>
7         <result column="order_price" property="price"/>
8     </resultMap>

7. 关联查询

7.1比如根据班级id查询班级信息（带老师的信息）一对一或多对一

　　　　way1：SQL语句中使用联表查询

*实体类中需要添加属性（数据类型为实体类名）

*映射文件中使用association标签（属性：property（实体类中添加的属性名）、javaType(添加的属性所在的实体类的全类名)）

 1 <select id="getClazz" resultMap="myMap">
 2           select * from class c,teacher t where c.teacher_id=t.t_id and c_id=#{cid}   
 3     </select>
 4     <resultMap type="com.zhiyou.clg.bean.Clazz" id="myMap">
 5         <id column="c_id" property="id"/>
 6         <result column="c_name" property="name"/>
 7         <result column="teacher_id" property="teacherid"/>
 8         <association property="teacher" javaType="com.zhiyou.clg.bean.Teacher">
 9             <id column="t_id" property="id"/>
10             <result column="t_name" property="name"/>
11         </association>
12     </resultMap>

way2：嵌套查询（查询的结果为其他查询的条件）

*实体类中需要添加属性（数据类型为实体类名）

*映射文件中使用association标签（属性：property、javaType（查询到的结果，此时作为查询条件）、 column、select（另一映射的语句的id，即另一select标签的id））

 1      <select id="getClazz" resultMap="myMap2">
 2           select * from class where c_id=#{cid}   
 3     </select>
 4     <select id="getTeacher" parameterType="int" resultType="com.zhiyou.clg.bean.Teacher">
 5            select t_id id,t_name name from teacher where t_id=#{tid}   
 6     </select>
 7     <resultMap type="com.zhiyou.clg.bean.Clazz" id="myMap2">
 8         <id column="c_id" property="id"/>
 9         <result column="c_name" property="name"/>
10         <result column="teacher_id" property="teacherid"/>
11         <association property="teacher"   javaType="com.zhiyou.clg.bean.Teacher" 
12                     column="teacher_id" select="getTeacher">
13             <id column="t_id" property="id"/>
14             <result column="t_name" property="name"/>
15         </association>
16     </resultMap>

7.2比如根据班级id查询班级信息（带班里学生的信息）一对多

way1：SQL语句中使用联表查询

*实体类中添加属性（数据类型为集合，泛型为实体类名）

*映射文件中使用collection标签(属性：property（添加的属性名）、ofType（集合泛型的实体类的全类名）)

 1 　　 <select id="getClazz" resultMap="myMap3">
 2 select *from class c,teacher t,student s where c.c_id=s.class_id and c.teacher_id=t.t_id and c.c_id=#{cid}  
 3     </select>
 4     <resultMap type="com.zhiyou.clg.bean.Clazz" id="myMap3">
 5         <id column="c_id" property="id"/>
 6         <result column="c_name" property="name"/>
 7         <result column="teacher_id" property="teacherid"/>
 8         <association property="teacher" javaType="com.zhiyou.clg.bean.Teacher">
 9             <id column="t_id" property="id"/>
10             <result column="t_name" property="name"/>
11         </association>
12         <collection property="students" ofType="com.zhiyou.clg.bean.Student">
13             <id column="s_id" property="id"/>
14             <result column="s_name" property="name"/>
15             <result column="class_id" property="cid"/>
16         </collection>
17     </resultMap> -->

way2：嵌套查询（查询的结果为其他查询的条件）

*实体类中添加属性（数据类型为集合，泛型为实体类名）

*映射文件中使用collection标签(属性：property、ofType、column、select)

 1 <select id="getClazz" resultMap="myMap4">
 2           select * from class where c_id=#{cid}   
 3     </select>
 4     <select id="getTeacher" parameterType="int" resultType="com.zhiyou.clg.bean.Teacher">
 5            select t_id id,t_name name from teacher where t_id=#{tid}   
 6     </select>
 7     <select id="getStudent" parameterType="int" resultType="com.zhiyou.clg.bean.Student">
 8             select s_id id,s_name name,class_id cid from student where class_id=#{cid}
 9     </select>
10     <resultMap type="com.zhiyou.clg.bean.Clazz" id="myMap4">
11         <id column="c_id" property="id"/>
12         <result column="c_name" property="name"/>
13         <result column="teacher_id" property="teacherid"/>
14         <association property="teacher"   javaType="com.zhiyou.clg.bean.Teacher" 
15                     column="teacher_id" select="getTeacher">
16             <id column="t_id" property="id"/>
17             <result column="t_name" property="name"/>
18         </association>
19         <collection property="students" ofType="com.zhiyou.clg.bean.Student"
20                      column="c_id" select="getStudent">
21             <id column="s_id" property="id"/>
22             <result column="s_name" property="name"/>
23             <result column="class_id" property="cid"/>
24         </collection>
25     </resultMap>

8. $和#的区别

$: 解析时不会为内容添加”” 他是sql语句的拼接,存在sql注入的缺陷。

当传入的为表结构时使用，当传入的为列名或表名时可以使用

order by group by 时用$

$:一般用于传入数据库对象，例如列名或表名

#: 解析时会为内容添加””,它的sql时采用占位符，防止sql注入。

能用#不要用$

#:一般传入的是值

9. 添加对象时如何把生成的id返回

1     <insert id="adduser" parameterType="com.zhiyou.clg.bean.User" useGeneratedKeys="true" keyProperty="id">
2         insert into user(name,age) values(#{name},#{age});
3     </insert>

　　useGeneratedKeys="true" ：表示使用自动生成的id

keyProperty="id" ：把生成的id赋值给对应的实体类属性

以上两者联合使用

*测试时可通过get方法获取id值

1 @Test
2     void testadd() throws IOException {
3         User user=new User();
4         user.setName("小天");
5         user.setAge(10);
6         userDao.adduser(user);
7         System.out.println(user.getId());
8 
9     }

　　一般可用于添加单号（自动生成）后即刻便加入商品

10. 动态sql语句(即sql语句的拼接)

　　10.1 if标签（属性：test（判断条件））

　　缺点：如果仅仅是第二个条件满足导致sql语句出错（故使用if+where）

1 　　<select id="select1" resultType="com.zhiyou.clg.bean.User">
2         select *from user
3         <if test="name!=null">
4             where name=#{name}
5         </if>
6         <if test="age!=null and age!=''">
7             and age=#{age}
8         </if>
9     </select>

　　10.2 if+where ( where标签会知道如果它包含的标签中有返回值的话，就会插入where 若其以and或or开头会将and或or剔除)

 1     <select id="select2" resultType="com.zhiyou.clg.bean.User">
 2         select *from user
 3         <where>
 4             <if test="name!=null">
 5                 and name=#{name}
 6             </if>
 7             <if test="sex!=null">
 8                 and sex=#{sex}
 9             </if>
10             <if test="age!=null and age!=''">
11                 and age=#{age}
12             </if>
13         </where>
14     </select>

　　10.3 if+set( set标签会知道如果它包含的标签中有返回值的话，就会插入set并且剔除最后一个满足条件的逗号“，”)

 1 <update id="update1" parameterType="com.zhiyou.clg.bean.User">
 2         update user
 3         <set>
 4             <if test="name!=null">
 5                 name=#{name},
 6             </if>
 7             <if test="sex!=null">
 8                 sex=#{sex},
 9             </if>
10             <if test="age!=null and age!=''">
11                 age=#{age},
12             </if>
13         </set>
14         <where>
15             <if test="id!=null">
16                 id=#{id}
17             </if>
18         </where>
19     </update

　　10.4 choose(标签when+标签otherwise)----类似于switch语句，有且仅有一个条件会满足

 1 　　　<sql id="usercolumn" >
 2          id,name,age,sex
 3      </sql>
 4     <select id="select3" resultType="com.zhiyou.clg.bean.User">
 5         select 
 6             <include refid="usercolumn"></include>
 7          from user
 8         <where>
 9             <choose>
10                 <when test="name!=null">
11                     and name=#{name}
12                 </when>
13                 <when test="age!=null and age!=''">
14                     and age=#{age}
15                 </when>
16                 <otherwise>
17                     and sex=#{sex}
18                 </otherwise>
19             </choose>
20         </where>
21     </select>

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

属性：prefix：前缀　　　　　　

　　 prefixoverrides：去掉前缀

　　 suffix：后缀　　　　　　

　　 suffixoverrides：去掉后缀

 1     <update id="update2" parameterType="com.zhiyou.clg.bean.User">
 2         update user
 3             <trim prefix="set" suffixOverrides=",">
 4                 <if test="name!=null">
 5                     name=#{name},
 6                 </if>
 7                 <if test="sex!=null">
 8                     sex=#{sex},
 9                 </if>
10                 <if test="age!=null and age!=''">
11                     age=#{age},
12                 </if>
13             </trim>
14         <where>
15             <if test="id!=null">
16                 id=#{id}
17             </if>
18         </where>
19     </update>

　　10.6 sql片段------使用sql标签定义（属性：id）;引用片段时用include标签（属性：refid）

10.7 foreach

属性： collection:指定输入对象中的集合属性

item:每次遍历生成的对象

open:开始遍历时的拼接字符串

close:结束时拼接的字符串

separator:遍历对象之间需要拼接的字符串

 1     <sql id="namecolumn" >
 2          name
 3      </sql>
 4     <select id="select4" resultType="com.zhiyou.clg.bean.User">
 5         select 
 6             <include refid="namecolumn"></include>
 7         from user where id in 
 8             <foreach collection="ids" open="(" close=")" separator="," item="id">
 9                 #{id}
10             </foreach>
11     </select>

　　10.8模糊查询-----like后使用concat函数拼接（‘%’,#{name},’%’）

　　 name like concat（‘%’,#{name},’%’）

11. 逆向工程(generator)----->由表帮我们来生成dao、bean、xml

　　1)引入mybatis-generator的jar包

　　2)在工程目录下新建generator.xml文件（复制官网内容）

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE generatorConfiguration
 3   PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
 4   "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
 5 <generatorConfiguration>
 6     <!-- 数据库驱动jar包所在的位置 -->
 7   <classPathEntry location="D:\\mybatis\\generator830\\lib\\mysql-connector-java-5.1.47.jar" />
 8   <context id="DB2Tables" targetRuntime="MyBatis3">
 9  <!--  去除注释 -->
10       <commentGenerator>
11       <property name="suppressAllComments" value="true" />
12         </commentGenerator>
13    <!--  数据源信息 -->
14     <jdbcConnection driverClass="com.mysql.jdbc.Driver"
15         connectionURL="jdbc:mysql://localhost:3306/mybatis"
16         userId="root"
17         password="root">
18     </jdbcConnection>
19     <javaTypeResolver >
20       <property name="forceBigDecimals" value="false" />
21     </javaTypeResolver>
22     <!-- 生成的实体类所在的位置 -->
23     <javaModelGenerator targetPackage="com.zhiyou.clg.bean" targetProject="./src">
24       <property name="enableSubPackages" value="true" />
25       <property name="trimStrings" value="true" />
26     </javaModelGenerator>
27     <!-- 生成的映射文件所在的位置 -->
28     <sqlMapGenerator targetPackage="com.zhiyou.clg.mapper"  targetProject="./resource">
29       <property name="enableSubPackages" value="true" />
30     </sqlMapGenerator>
31     <!-- 生成的dao所在的位置 -->
32     <javaClientGenerator type="XMLMAPPER" targetPackage="com.zhiyou.clg.dao"  targetProject="./src">
33       <property name="enableSubPackages" value="true" />
34     </javaClientGenerator>
35     <!-- 表和实体类的对象关系
36         schema：该表所在的数据库
37         tableName：表名
38         domainObjectName：实体类名
39      -->
40     <table schema="DB2ADMIN" tableName="user" domainObjectName="User"  
41      enableCountByExample="false" enableDeleteByExample="false" enableSelectByExample="false" enableUpdateByExample="false" >
42       <property name="useActualColumnNames" value="true"/>
43       <generatedKey column="ID" sqlStatement="DB2" identity="true" />
44       <columnOverride column="DATE_FIELD" property="startDate" />
45       <ignoreColumn column="FRED" />
46       <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" />
47     </table>
48 
49   </context>
50 </generatorConfiguration>

　　3)在src目录下新建test包，再新建Test类，在main下复制官网内容，导包后运行

 1 package com.zhiyou.clg.test;
 2 
 3 import java.io.File;
 4 import java.io.IOException;
 5 import java.util.ArrayList;
 6 import java.util.List;
 7 
 8 import org.mybatis.generator.api.MyBatisGenerator;
 9 import org.mybatis.generator.config.Configuration;
10 import org.mybatis.generator.config.xml.ConfigurationParser;
11 import org.mybatis.generator.exception.XMLParserException;
12 import org.mybatis.generator.internal.DefaultShellCallback;
13 
14 public class TestGenerator {
15     public static void main(String[] args) throws Exception{
16         List<String> warnings = new ArrayList<String>();
17            boolean overwrite = true;
18            File configFile = new File("generator.xml");
19            ConfigurationParser cp = new ConfigurationParser(warnings);
20            Configuration config = cp.parseConfiguration(configFile);
21            DefaultShellCallback callback = new DefaultShellCallback(overwrite);
22            MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
23            myBatisGenerator.generate(null);
24     }
25 }

12. 分页助手(pagehelper)

　　1)引入jar包 jsqlparser-2.0.jar和pagehelper-5.1.10.jar(两jar包需匹配使用)

　　2)在配置文件中添加，拦截器插件（复制官网），注意顺序

<!--

plugins在配置文件中的位置必须符合要求，否则会报错，顺序如下:

properties?, settings?,

typeAliases?, typeHandlers?,

objectFactory?,objectWrapperFactory?,

plugins?,

environments?, databaseIdProvider?, mappers?

-->

1 <plugins>
2         <!-- com.github.pagehelper为PageHelper类所在包名 -->
3         <plugin interceptor="com.github.pagehelper.PageInterceptor">
4             <!-- 使用下面的方式配置参数，后面会有所有的参数介绍 -->
5            <!--  <property name="param1" value="value1"/> -->
6         </plugin>
7     </plugins>

　　*测试时：（参考官网）

 1 @Test
 2 void testselectall() {
 3         //1.使用PageHelper类设置起始页和每页显示的条数
 4         int pageNum=5;//当前页码   从网页中可以获取
 5         int pageSize=3;//pageSize：自定义
 6         PageHelper.startPage(pageNum,pageSize);
 7         //2调用查询所有的方法
 8         List<User> list=userMapper.selectall();
 9         for (User user : list) {
10             System.out.println(user);
11         }
12         //3.把查询的结果封装到Pageinfo中
13         PageInfo<User> pageinfo=new PageInfo<>(list,4);
14         System.out.println("上一页:"+pageinfo.getPrePage());
15         System.out.println("当前页:"+pageinfo.getPageNum());
16         System.out.println("下一页:"+pageinfo.getNextPage());
17         System.out.println("总页数:"+pageinfo.getPages());
18         int[] navigatepageNums = pageinfo.getNavigatepageNums();
19         for (int i : navigatepageNums) {
20             System.out.print(i+"\t");
21         }
22     }

　　*直接输出pageinfo查询到的结果

 1 PageInfo{
 2 pageNum=1, //当前页
 3 pageSize=2,//每页显示的条数
 4  size=2,//该页条数
 5  startRow=1,//从第几条开始
 6  endRow=2, //到第几条结束
 7 total=5, //总共有多少条
 8 pages=3,//总共的页数
 9  list=Page{count=true, pageNum=1, pageSize=2, startRow=0, endRow=2, total=5, pages=3, reasonable=false, pageSizeZero=false}
10 [com.zhiyou.clg.bean.User@52bf72b5, com.zhiyou.clg.bean.User@37afeb11], //当前页的数据
11 prePage=0, //上一页
12 nextPage=2, //下一页
13 isFirstPage=true,//是否为第一页
14  isLastPage=false, hasPreviousPage=false, hasNextPage=true, 
15 navigatePages=8,//每页显示的页码个数
16  navigateFirstPage=1,
17  navigateLastPage=3, 
18 navigatepageNums=[1, 2, 3]//页码的个数
19 }

转载于:https://www.cnblogs.com/jingmochen/p/11441119.html

aoshenbin6061

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MyBatis总结

Mybatis大纲介绍mybatis基于mybatis的开发过程查询的条件不在实体类中时几个优化的地方使用接口结合xml文件解决字段与属性不匹配关联查询$和#的区别添加对象时如何把生成的id返回动态sql语句逆向工程(generator)分页助手(pagehelper)1.介绍mybatismybatis支持普通sq...
复制链接

扫一扫