本文介绍了mybatis中Mapper代理的工作原理，包括动态代理模式的应用，以及如何在不编写DAO实现类的情况下进行操作。接着，详细讲解了一对一、一对多、多对多的关联关系，通过实例展示了它们在数据库表结构中的表现。此外，还涵盖了分页查询的三种方法，包括使用RowBounds、PageHelper等。最后，通过示例代码展示了如何在mybatis中进行分页与多表联查的实际操作。
1.授课内容
Mapper代理
关联关系
分页
缓存
注解
2.Why
3.介绍
3.1.mapper代理
mapper代理使用的是动态代理模式(设计模式中的一个,SpringAOP的时候讲)
Mapper代理,码dao的时候,再也不用写dao的实现类
3.2.关联关系
3.2.1.一对一
老公和老婆
第一种(特殊的一对多)
老公表
Id 名字 事业
1 小张
2 小王
老婆表
Id 名字 护肤 老公id(关联字段)
(唯一,不能重复)
1 小红 2
2 小蓝 1
3 小新 1
第二种
老公表
Id 名字 事业
1 小张
2 小王
老婆表
Id(id值必须参照老公表的id)
(关联字段) 名字 护肤
1 小红
2 小蓝
3.2.2.一对多
朝代皇上
只有一种
朝代表
Id 名字 国祚
1 大唐
2 北宋
皇上表
Id 名字 庙号 朝代Id(关联字段)
1 李世民 1
2 李隆基 1
3 赵匡胤 2
4 赵光义 2
3.2.3.多对多
老师和学生
其实多对多可以理解为两个一对多;
只有一种
老师表
Id 名字 国祚
1 王老师
2 李老师
学生表
Id 名字 庙号
1 李世民
2 李隆基
3 赵匡胤
4 赵光义
老师学生关系表
Id 老师id(关联字段) 学生id(关联字段)
1 1 1
2 1 2
3 2 2
4 2 3
3.2.4.联合查询
笛卡尔集
全连接
左连接
右连接
4.实战
4.1.mapper代理
朝代表的crud;
dao接口
Dao的实现类不用码
映射文件
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import com.jinghangzz.mybatis.data.dao.IADemoDynastyDao;
import com.jinghangzz.mybatis.data.pojo.ADemoDynasty;
import com.jinghangzz.mybatis.data.test.BaseTest;
/**
-
Dao接口的代理类
-
@author TeaBig
/
public class ADemoDynastyDaoMapperTest extends BaseTest
{
/*-
保存一条记录
*/
@Test
public void saveOneDao()
{
/*获取链接- 参数如果为true,就是自动提交
- /
SqlSession session = this.sqlSessionFactory.openSession(true) ;
this.logger.info(“session:{}”,session);
/ 发送sql语句 - 参数是:Dao的Class对象(反射)
- 有三种:
-
~对象名.getClass -
~类名或者接口名.getClass(); -
~Class.forName(); - 返回值就是参数的Class对应的类型(对象)
- /
IADemoDynastyDao demoDynastyDao = session.getMapper(IADemoDynastyDao.class);
/ 保存一条记录 /
ADemoDynasty demoDynasty = new ADemoDynasty();
/ 木有设置主键的 /
demoDynasty.setName(“东汉”);
demoDynasty.setContent(“东汉”);
demoDynasty.setCapital(“洛阳”);
demoDynasty.setStYear(24);
demoDynasty.setEdYear(221);
demoDynasty.setGuoZuo(167);
demoDynasty.setCreateTime(new Date());
demoDynasty.setUpdateTime(new Date());
demoDynasty.setPubTime(new Date());
/ 调用dao的方法 */
int res = demoDynastyDao.saveOneDao(demoDynasty);
this.logger.info("=返回:{},主键:{}==",res,demoDynasty.getId());
/* 关闭链接 */
if(session != null )
{
session.close();
session = null ;
}
}
/**
-
查询多条记录
*/
@Test
public void findListDao()
{
/*获取链接- 参数如果为true,就是自动提交
- /
SqlSession session = this.sqlSessionFactory.openSession(true) ;
this.logger.info(“session:{}”,session);
/ 发送sql语句 - 参数是:Dao的Class对象(反射)
- 有三种:
-
~对象名.getClass -
~类名或者接口名.getClass(); -
~Class.forName(); - 返回值就是参数的Class对应的类型(对象)
- /
IADemoDynastyDao demoDynastyDao = session.getMapper(IADemoDynastyDao.class);
Map<String, Object> condMap = new HashMap<String, Object>();
/ 添加搜索条件 /
condMap.put(“keyword”, “%清%”);
condMap.put(“status”, “1”);
condMap.put(“st”, new Date());
condMap.put(“ed”, new Date());
/ 查询多条记录 */
List demoDynastyList = demoDynastyDao.findListDao(condMap);
demoDynastyList.forEach( t -> this.logger.info(“数据:{}”,t));
/* 关闭链接 */
if(session != null )
{
session.close();
session = null ;
}
}
/**
-
查询多条记录
*/
@Test
public void findOneDao()
{
/*获取链接- 参数如果为true,就是自动提交
- /
SqlSession session = this.sqlSessionFactory.openSession(true) ;
this.logger.info(“session:{}”,session);
/ 发送sql语句 - 参数是:Dao的Class对象(反射)
- 有三种:
-
~对象名.getClass -
~类名或者接口名.getClass(); -
~Class.forName(); - 返回值就是参数的Class对应的类型(对象)
- /
IADemoDynastyDao demoDynastyDao = session.getMapper(IADemoDynastyDao.class);
Map<String, Object> condMap = new HashMap<String, Object>();
/ 添加搜索条件 /
//condMap.put(“id”, “3”);
condMap.put(“name”, “大清”);
/ 查询多条记录 */
ADemoDynasty demoDynasty = demoDynastyDao.findOneDao(condMap);
this.logger.info(“数据:{}”,demoDynasty);
/* 关闭链接 */
if(session != null )
{
session.close();
session = null ;
}
}
/**
-
查询多条记录
*/
@Test
public void updateOneDao()
{
/*获取链接- 参数如果为true,就是自动提交
- /
SqlSession session = this.sqlSessionFactory.openSession(true) ;
this.logger.info(“session:{}”,session);
/ 发送sql语句 - 参数是:Dao的Class对象(反射)
- 有三种:
-
~对象名.getClass -
~类名或者接口名.getClass(); -
~Class.forName(); - 返回值就是参数的Class对应的类型(对象)
- /
IADemoDynastyDao demoDynastyDao = session.getMapper(IADemoDynastyDao.class);
Map<String, Object> condMap = new HashMap<String, Object>();
/ 添加搜索条件 /
//condMap.put(“id”, “3”);
condMap.put(“name”, “大清”);
/ 查询多条记录 */
ADemoDynasty demoDynasty = demoDynastyDao.findOneDao(condMap);
this.logger.info(“数据:{}”,demoDynasty);
demoDynasty.setName(demoDynasty.getName() + “+++++我修改了”);
/* 以后更新的时候是先查询,再更新 */
int res = demoDynastyDao.updateOneDao(demoDynasty);
this.logger.info(“结果:{},id:{}”,res,demoDynasty.getId());/* 关闭链接 */
if(session != null )
{
session.close();
session = null ;
}
}
/**
-
删除多条记录
*/
@Test
public void deleteBatchDao()
{
/*获取链接- 参数如果为true,就是自动提交
- /
SqlSession session = this.sqlSessionFactory.openSession(true) ;
this.logger.info(“session:{}”,session);
/ 发送sql语句 - 参数是:Dao的Class对象(反射)
- 有三种:
-
~对象名.getClass -
~类名或者接口名.getClass(); -
~Class.forName(); - 返回值就是参数的Class对应的类型(对象)
- /
IADemoDynastyDao demoDynastyDao = session.getMapper(IADemoDynastyDao.class);
Map<String, Object> condMap = new HashMap<String, Object>();
/ 添加搜索条件 /
//condMap.put(“id”, “3”);
condMap.put(“name”, “大唐”);
/ 以后更新的时候是先查询,再更新 */
int res = demoDynastyDao.deleteBatchDao(condMap);
this.logger.info(“结果:{},条件:{}”,res,condMap);
/* 关闭链接 */
if(session != null )
{
session.close();
session = null ;
}
}
}
-
4.2.关联关系
关联关系其实就是两者之前的关系,A和B;
一对一:一个A有一个B,一个B有一个A
一对多(a和b):一个a有多个B,一个b且一个a;b和a就是多对一
多对多:一个A有多个B,一个B有多个A
站在a或者B的角度;站在a看b,站在b看a;
无非两种情况:一个(关联对象)或者多个(对象);
pojo中,无法是单个引用或者集合
4.2.1.多的一方
Pojo
package com.jinghangzz.mybatis.data.pojo;
import java.util.Date;
/**
-
皇上的pojo
-
@author TeaBig
*/
public class ADemoKing
{
private int id;
private int dynastyId;
private String name;
private String content;
private String miaoHao;
private String nianHao;
private byte age;
private byte status;
private Date createTime;
private Date updateTime;
private Date pubTime;/* 关联关系:自定义引用 */
private ADemoDynasty dynasty ;
Set/get方法
@Override
public String toString()
{
return “ADemoKing [id=” + id + “, dynastyId=” + dynastyId + “, name=” + name + “, content=” + content
+ “, miaoHao=” + miaoHao + “, nianHao=” + nianHao + “, age=” + age + “, status=” + status
+ “, createTime=” + createTime + “, updateTime=” + updateTime + “, pubTime=” + pubTime + “]”;
}
}
映射文件:
<!--
查询所有的朝代记录
select标签可以发送select语句
id:唯一标识,当前的mapper文件中,id不能重复
resultType:结果类型;
如果查询的是单条,那返回值的类型就是resultType;
如果查询的是多条,那么返回值的类型是List,List里面放的是resultType
-->
<select id="selectList" resultType="com.jinghangzz.mybatis.data.pojo.ADemoKing">
select * from a_demo_king
</select>
<!-- resultMap -->
<!-- 要发送两条sql语句,
先查询皇上,
拿着dynastyId(朝代Id要去朝代表查询朝代)
-->
<resultMap type="com.jinghangzz.mybatis.data.pojo.ADemoKing" id="resultMap">
<!-- 如果配置了关联关系,那关联字段必须手动赋值 -->
<result column="dynastyId" property="dynastyId"/>
<!-- 联合:
property:pojo的属性名
column:数据库的列名;为dynasty赋值的时候,需要用到皇上表的哪列?
javaType:dynasty到底是哪个类型(java里面的); 包名+类名
select:拿着column执行哪个sql语句,应该可以查询到dynasty;执行sql语句的id;
sql语句的id,应该是namespace+sql语句的id(如果sql语句的就在当前文件中,那namespace可以忽略)
fetchType:抓取策略;lazy:延迟加载;eager:默认就是积极加载;
如果全局开头木有打开,只能此标签才会起作用,其它的标签不起作用;
建议:(延迟加载开关都打开)
延迟加载只能在一个JVM里面生效;微服务编程:(dubbo,SPringCloud,延迟加载不起作用)
-->
<association property="dynasty" column="dynastyId" javaType="com.jinghangzz.mybatis.data.pojo.ADemoDynasty"
select="dynasty.selectRelaOne" />
</resultMap>
<!-- 查询一条记录
resultType:指定的皇上,里面有一个朝代的引用,sql语句查询的结果木有存储,
那应该拿着dynastyId再去朝代表里面查询一次(sql语句要写到一个地,并且要用resultmap来赋值)
-->
<select id="selectOne" resultMap="resultMap">
select * from a_demo_king where id = #{id}
</select>
<!-- 拿着皇上表的dynastyId(朝代Id)查询朝代表的记录
paramterType:它是被忽略的,自动的判断是哪个类型;根据值来判断;
值就是association标签中的column(数据库的列)
column是int,基本数据类型,#{可以随便写}
这明明是皇上的Mapper文件,为啥要写朝代呢?
-->
<!-- <select id="selectRelaOne" resultType="com.jinghangzz.mybatis.data.pojo.ADemoDynasty">
select * from a_demo_dynasty where id = #{asdfasfasf}
</select> -->
<!-- 使用联合查询,一次性把结果查询出来
加上autoMapping=true
我们使用的是自动映射;
如果sql语句执行完以后,列名要是相同,会出现值一样的问题
(如何解决重复,要把所有重复的字段起一个别名)
-->
<resultMap type="com.jinghangzz.mybatis.data.pojo.ADemoKing" id="resultMapJoin" autoMapping="true">
<!-- 如果配置了关联关系,那关联字段必须手动赋值 -->
<result column="dynastyId" property="dynastyId"/>
<!-- 为朝代赋值 -->
<association property="dynasty" column="dynastyId" autoMapping="true"
javaType="com.jinghangzz.mybatis.data.pojo.ADemoDynasty">
<!-- 为重复的字段赋值
column:sql语句执行的结果,要的是别名(因为重复)
-->
<result column="dynaName" property="name"/>
</association>
</resultMap>
<!-- 关联查询 -->
<select id="selectJoin" resultMap="resultMapJoin">
select ak.*,ad.*,ad.name as dynaName from a_demo_king ak, a_demo_dynasty ad where ak.dynastyId = ad.id and
ak.id = #{asdfasfa}
</select>
<!-- 查询多个引用(关联关系) -->
<select id="selectRelaList" resultType="com.jinghangzz.mybatis.data.pojo.ADemoKing">
select * from a_demo_king where dynastyId = #{dynastyId}
</select>
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import com.jinghangzz.mybatis.data.pojo.ADemoDynasty;
import com.jinghangzz.mybatis.data.pojo.ADemoKing;
import com.jinghangzz.mybatis.data.test.BaseTest;
/**
-
查询皇上操作
-
@author TeaBig
/
public class ADemoKingTest extends BaseTest
{
/*-
查询一条记录
/
@Test
public void selectOne()
{
/ 获取链接 */
SqlSession session = this.sqlSessionFactory.openSession(true);/**
- 查询一条记录
/
ADemoKing demoKing = session.selectOne(“king.selectOne”,2);
this.logger.info(“皇上🆔{},朝代Id:{},name:{},miaoHao:{},createTime:{}”,
demoKing.getId(),demoKing.getDynastyId(),demoKing.getName(),demoKing.getMiaoHao(),demoKing.getCreateTime().toLocaleString());
/ 需求:一个皇上有一个朝代 - 期望可以通过皇上把朝代查询出来;
- ~pojo
- ~
- /
// ADemoDynasty dynasty = demoKing.getDynasty() ;
// this.logger.info(“朝代🆔{},name:{},首都:{},createTime:{}”,
// dynasty.getId(),dynasty.getName(),dynasty.getCapital(),dynasty.getCreateTime().toLocaleString());
/ 关闭链接 */
if(session != null)
{
session.close();
session = null ;
}
}
- 查询一条记录
/**
-
查询一条记录
/
@Test
public void selectJoin()
{
/ 获取链接 */
SqlSession session = this.sqlSessionFactory.openSession(true);/**
- 查询一条记录
/
ADemoKing demoKing = session.selectOne(“king.selectJoin”,2);
this.logger.info(“皇上🆔{},朝代Id:{},name:{},miaoHao:{},createTime:{}”,
demoKing.getId(),demoKing.getDynastyId(),demoKing.getName(),demoKing.getMiaoHao(),demoKing.getCreateTime().toLocaleString());
/ 需求:一个皇上有一个朝代 - 期望可以通过皇上把朝代查询出来;
- ~pojo
- ~
- /
ADemoDynasty dynasty = demoKing.getDynasty() ;
this.logger.info(“朝代🆔{},name:{},首都:{},createTime:{}”,
dynasty.getId(),dynasty.getName(),dynasty.getCapital(),dynasty.getCreateTime().toLocaleString());
/ 关闭链接 */
if(session != null)
{
session.close();
session = null ;
}
}
}
4.2.2.一的一方
Pojo
package com.jinghangzz.mybatis.data.pojo;
- 查询一条记录
-
import java.util.Date;
import java.util.List;
/**
-
朝代的POJO
-
pojo的类名和表名一样(把_去掉,注意驼峰标识)
-
pojo的属性名和表的类名一样
-
pojo的对象和表的记录一样;
-
@author TeaBig
*/
public class ADemoDynasty
{
private int id;
private String name;
private String content;
private int stYear;
private int edYear;
private int guoZuo;
private String capital;
private byte status;
private Date createTime;
private Date updateTime;
private Date pubTime;/* 持有多个引用 */
private List kingList;
读写器
@Override
public String toString()
{
return "ADemoDynasty [id=" + id + ", name=" + name + ", content=" + content + ", stYear=" + stYear + ", edYear="
+ edYear + ", guoZuo=" + guoZuo + ", capital=" + capital + ", status=" + status + ", createTime="
+ createTime + ", updateTime=" + updateTime + ", pubTime=" + pubTime + "]";
}
}
映射文件
测试代码
package com.jinghangzz.mybatis.test;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import com.jinghangzz.mybatis.data.pojo.ADemoDynasty;
import com.jinghangzz.mybatis.data.pojo.ADemoKing;
import com.jinghangzz.mybatis.data.test.BaseTest;
/**
- 测试朝代的一方
- @author TeaBig
/
public class ADemoDynastyTest extends BaseTest
{
/*
* 查询一条记录
/
@Test
public void selectOne()
{
/ 获取链接 */
SqlSession session = this.sqlSessionFactory.openSession(true);
/**
* 查询一条记录
*/
ADemoDynasty dynasty = session.selectOne("dynasty.selectOne",10);
this.logger.info("朝代:id:{},name:{},首都:{},createTime:{}",
dynasty.getId(),dynasty.getName(),dynasty.getCapital(),dynasty.getCreateTime().toLocaleString());
/* 需求:一个朝代有多个皇上
* 期望可以通过皇上把朝代查询出来;
* ~pojo
* ~
* */
List<ADemoKing> kingList = dynasty.getKingList() ;
kingList.forEach( demoKing ->
{
this.logger.info("皇上:id:{},朝代Id:{},name:{},miaoHao:{},createTime:{}",
demoKing.getId(),demoKing.getDynastyId(),demoKing.getName(),demoKing.getMiaoHao(),demoKing.getCreateTime().toLocaleString());
});
/* 关闭链接 */
if(session != null)
{
session.close();
session = null ;
}
}
/**
* 查询一条记录
*/
@Test
public void selectJoin()
{
/* 获取链接 */
SqlSession session = this.sqlSessionFactory.openSession(true);
List<ADemoDynasty> dynastyList = session.selectList("dynasty.selectJoin",10);
dynastyList.forEach( dynasty -> {
this.logger.info("朝代:id:{},name:{},首都:{},createTime:{}",
dynasty.getId(),dynasty.getName(),dynasty.getCapital(),dynasty.getCreateTime().toLocaleString());
/* 需求:一个朝代有多个皇上
* 期望可以通过皇上把朝代查询出来;
* ~pojo
* ~
* */
List<ADemoKing> kingList = dynasty.getKingList() ;
kingList.forEach( demoKing ->
{
this.logger.info("皇上:id:{},朝代Id:{},name:{},miaoHao:{},createTime:{}",
demoKing.getId(),demoKing.getDynastyId(),demoKing.getName(),demoKing.getMiaoHao(),demoKing.getCreateTime().toLocaleString());
});
});
/* 关闭链接 */
if(session != null)
{
session.close();
session = null ;
}
}
}
Mybtis.cfg.xml
<?xml version="1.0" encoding="UTF-8"?><!-- 配置了一堆环境;jdbc的环境
default:默认的环境,配置environment的id
-->
<environments default="my">
<!-- 配置一个单数 -->
<environment id="my">
<!-- 事务管理器:专门用来管理事务的 -->
<transactionManager type="JDBC"/>
<!-- 数据源
pooled:连接池;放的是一个一个的Connection;
数据源包含了java连接数据库的各种信息
-->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?serverTimezone=UTC"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<!-- 一定一定一定要把映射文件包含起来 -->
<mappers>
<!-- 映射文件的路径,classpath -->
<mapper resource="com/jinghangzz/mybatis/data/pojo/ADemoDynastyMapper.xml"/>
<mapper resource="com/jinghangzz/mybatis/data/pojo/ADemoKingMapper.xml"/>
</mappers>
配置文件:
<?xml version="1.0" encoding="UTF-8"?><!-- 配置了一堆环境;jdbc的环境
default:默认的环境,配置environment的id
-->
<environments default="my">
<!-- 配置一个单数 -->
<environment id="my">
<!-- 事务管理器:专门用来管理事务的 -->
<transactionManager type="JDBC"/>
<!-- 数据源
pooled:连接池;放的是一个一个的Connection;
数据源包含了java连接数据库的各种信息
-->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?serverTimezone=UTC"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<!-- 一定一定一定要把映射文件包含起来 -->
<mappers>
<!-- 映射文件的路径,classpath -->
<mapper resource="com/jinghangzz/mybatis/data/pojo/ADynastyMapper.xml"/>
</mappers>
测试代码:
package com.jinghangzz.mybatis.test;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.jinghangzz.mybatis.data.pojo.ADemoDynasty;
import com.jinghangzz.mybatis.data.test.BaseTest;
/**
-
分页
-
有三种
-
@author TeaBig
/
public class PageTest extends BaseTest
{
/*- 分页的第一种
/
@Test
public void page_1()
{
/ 获取链接- SqlSession===Connection;
- /
SqlSession session = sqlSessionFactory.openSession() ;
this.logger.info(“session:{}”,session);
/=以上是加载驱动,获取链接======/
/=操作数据库======/
/ - 查询多条:selectList
- 查询单条:selectOne
- 参数1:mapper文件中,namespace(如果sql语句的id在全局中是唯一的,那可以省略namespace)+sql语句的id
- /
List dynastyList = session.selectList(“test.page_1”);
/ 如何循环 /
final Map<String, Object> resultMap = new HashMap<String, Object>();
dynastyList.forEach( t ->
{
Integer count = 0 ;
if(resultMap.get(“count”) != null )
{
count = Integer.valueOf(resultMap.get(“count”) + “”) ;
}
System.out.println(count + “==>” + t);
count ++ ;
resultMap.put(“count”,count);
});
/ 关闭链接 */
session.close();
}
/**
- 分页的第二种
/
@Test
public void page_2()
{
/ 获取链接- SqlSession===Connection;
- /
SqlSession session = sqlSessionFactory.openSession() ;
this.logger.info(“session:{}”,session);
/=以上是加载驱动,获取链接======/
/=操作数据库======*/
/** - limit ?,?
- 参数1:第一个?;表示从第几条开始
- 参数2:第二个?;表示往后查询多少条
- 分页相当的low;
-
一次性将sql语句全部查询出来, -
在内存中进行分页; -
如果数据库里面有100000000w条记录,难道也要一次性放到内存中?(这绝对不现实)
RowBounds rowBounds = new RowBounds(2, 3);
/*- 参数1:sql语句的Id
- 参数2:sql语句的参数(paramterType)
- 参数3:RowBounds
/
List dynastyList = session.selectList(“test.page_2”,null,rowBounds);
/ 如何循环 /
final Map<String, Object> resultMap = new HashMap<String, Object>();
dynastyList.forEach( t ->
{
Integer count = 0 ;
if(resultMap.get(“count”) != null )
{
count = Integer.valueOf(resultMap.get(“count”) + “”) ;
}
System.out.println(count + “==>” + t);
count ++ ;
resultMap.put(“count”,count);
});
/ 关闭链接 */
session.close();
}
/**
-
分页的第三种
-
PageHelper
/
@Test
public void page_3()
{
/ 获取链接- SqlSession===Connection;
- /
SqlSession session = sqlSessionFactory.openSession() ;
this.logger.info(“session:{}”,session);
/=以上是加载驱动,获取链接======/
/=操作数据库======/
/ 一定要在调用selectList或者SelectOne之前调用此方法 /
/* - 参数1:第几页
- 参数2:每页多少条
- 它会先查询总条数,
- 然后再查询分页的数据
- 分页的信息存储在page中
*/
Page page = PageHelper.startPage(10000, 3);
/**
- 参数1:sql语句的Id
- 参数2:sql语句的参数(paramterType)
- 参数3:RowBounds
*/
List dynastyList = session.selectList(“test.page_2”,null);
/* 一定要在调用selectOne或者selectList之后调用page查看分页信息 */
this.logger.info(“分页信息:总条数:{},总页数:{},每页条数:{},当前页:{}”,
page.getTotal(),page.getPages(),page.getPageSize(),page.getPageNum());/* 如何循环 /
final Map<String, Object> resultMap = new HashMap<String, Object>();
dynastyList.forEach( t ->
{
Integer count = 0 ;
if(resultMap.get(“count”) != null )
{
count = Integer.valueOf(resultMap.get(“count”) + “”) ;
}
System.out.println(count + “==>” + t);
count ++ ;
resultMap.put(“count”,count);
});
/ 关闭链接 */
session.close();
}
}
- 分页的第一种
5.总结
5.1.常见错误
扫一扫
2034
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
