文章目录
Mybatis
-
mybatis的事务默认是不自动提交的
-
主配置文件添加这个可以显示日志
<settings> <setting name="logImpl" value="STDOUT_LOGGING" /> </settings>
1. 框架概述
1.1 三层架构
界面层（controller包）
springmvc框架
和用户对接，接受用户的请求参数，显示处理结果。
jsp、html、servlet
业务逻辑层（XXXservice包）
spring框架
接收界面层传递的数据，计算逻辑，调用数据库，获取数据
数据访问层（XXXDao包）
mybatis框架
访问数据库，执行对象数据的查询等操作
1.2 框架概念
框架是一个模板，其中已经定义好了一些功能，这些功能是可用的，可以在项目中加入自己的功能。
框架是一个半成品软件，定义好的基础功能是可重复使用的，可升级的。
框架特点：
- 不是全能，不能做所有事情
- 只是针对某一个领域有效
- 是一个软件
1.3 Mybatis简介
Mybatis是一个sql映射框架，提供数据库的操作能力，增强的JDBC，使用这个只需要写好sql语句即可。
Mybatis是一个框架，早期叫做ibatis
MyBatis SQL Mapper Framework for Java （sql映射框架）
-
sql mapper：sql映射
把数据库表中的一行数据映射成一个java对象，一行数据可以看作是一个java对象。操作这个对象，就相当于操作表中的数据
-
Data Access Objects（DAOs）：数据访问
对数据库执行增删改查
提供的功能：
- 创建Connection、Statement等能力
- 执行sql语句
- 循环sql，将结果转为java对象，List集合
- 关闭资源
开发人员只需提供sql语句
2. 分析JDBC缺点
重复代码太多，开发效率降低。
以上过程完全可以使用反射机制代替，而Mybatis框架就是别人提前写好的java代码，这Mybatis框架封装了JDBC代码，Mybatis框架就是别人已经写好的java代码。
sql编写在java程序中。
sql语句可能在后期是需要调优的，语句被修改的概率很高，然而在修改了sql语句导致java代码重新编译，项目重新部署，十分繁琐…
严重违背开闭原则：OCP
3. 实现步骤
3.1 加入依赖
<dependencies>
<dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>mssql-jdbc</artifactId>
<version>9.2.0.jre15</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency>
</dependencies>
3.2 创建数据实体类
public class Student {
private String sno;
private String sname;
private String ssex;
private Integer sage;
private String sdept;
public String getSno() {
return sno;
}
public void setSno(String sno) {
this.sno = sno;
}
@Override
public String toString() {
return "Student{" +
"sno='" + sno + '\'' +
", sname='" + sname + '\'' +
", ssex='" + ssex + '\'' +
", sage=" + sage +
", sdept='" + sdept + '\'' +
'}';
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getSsex() {
return ssex;
}
public void setSsex(String ssex) {
this.ssex = ssex;
}
public Integer getSage() {
return sage;
}
public void setSage(Integer sage) {
this.sage = sage;
}
public String getSdept() {
return sdept;
}
public void setSdept(String sdept) {
this.sdept = sdept;
}
}
3.3 创建dao接口
其中定义操作数据库的方法
public interface StudentDao {
// 查询所有数据
List<Student> findAll();
}
3.4 创建sql映射文件
<!--
sql映射文件：在其中写sql语句，mybatis会执行这些sql
1. 指定约束文件
mybatis-3-mapper.dtd是约束文件的名称，扩展名是dtd
约束文件的作用：限制，检查当前文件中出现的标签，属性必须符合mybatis的要求
2. mapper标签
当前文件的根标签，是必须的。
namespace(命名空间)：唯一值，可以自定义，但是要求使用dao接口的全限定名称
3. 在当前文件中，可以使用特定的标签，表示数据库的操作
<select>：查询
<update>：更新
<insert>：插入
<delete>：删除
-->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.company.dao.StudentDao">
<!--
select : 表示查询操作
id : 表示要执行sql语句的唯一标识，mybatis会使用这个id值找到要执行的sql语句
可自定义，但是要求使用接口中的方法名称
resultType : 表示结果类型，是sql语句执行后得到结果的类型
-->
<select id="findAll" resultType="com.company.domain.Student">
select Sno, Sname, Ssex, Sage, Sdept from Student where Ssex = '女'
</select>
</mapper>
3.5 创建jdbc配置文件
在resources下写properties文件
jdbc.driver=com.microsoft.sqlserver.jdbc.SQLServerDriver
jdbc.url=jdbc:sqlserver://localhost:1433;Database=S_T
jdbc.user=sa
jdbc.password=xxxxqq76985
3.5 创建主配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 定义配置文件路径 -->
<properties resource="jdbc.properties" />
<!--
settings，打印日志到控制台
其中还有很多的settings配置，但是大多数采用默认值即可，不需要手工配置
-->
<settings>
<setting name="logImpl" value="STDOUT_LOGGING" />
</settings>
<!-- 配置java类的别名 -->
<typeAliases>
<typeAlias type="com.company.vo.SelectAge" alias="SelectAge" />
<package name="com.company.domain" />
</typeAliases>
<!-- 配置插件，一定要放在environments前面 -->
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor" />
</plugins>
<!-- 默认使用developmet环境 -->
<environments default="development">
<!--
environment：一个数据库信息的配置
id：一个唯一值，表示环境的名称
-->
<environment id="development">
<!--
transactionManager：mybatis的事务类型
type: JDBC (表示使用jdbc中的Connection对象的commit，rollback做事务处理)
MANAGED (把mybatis的事务处理委托给其他容器，一个服务器软件，一个框架等等)
-->
<transactionManager type="JDBC"/>
<!--
dataSource：表示数据源，连接数据库的，实现了javax.sql.DataSource接口都是数据源
type：表示数据源的类型，POOLED表示使用连接池，UNPOOLED表示不使用连接池，创建连接再关闭
-->
<dataSource type="POOLED">
<!--
driver, user, username, password 都是固定的，不能修改
-->
<property name="driver" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>
<!--
sql mapper(sql映射文件)的位置
-->
<mappers>
<!--
一个mapper指定一个文件的位置
从类路径开始
-->
<!-- 第一种方式 -->
<mapper resource="com/company/dao/StudentDao.xml"/>
<!-- 第二种方式
name: xml文件（mapper文件）所在的包名，这个包中所有的xml文件一次都能加载给mybatis
要求:
1. mapper文件名称需要和接口名称完全相同
2. mapper文件和dao接口需要在同一目录
-->
<package name="com.company.dao" />
</mappers>
</configuration>
必须指定mapper映射文件，因为在写sqlId的时候，会在指定mapper中寻找namespace
3.6 访问数据库
import com.company.domain.Student;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;
// 这是一个测试类
public class Test {
public static void main(String[] args) throws IOException {
// 1. 定义mybatis主配置文件的名称，从类路径开始
String config = "data.xml";
// 2. 读取这个config表示的文件
InputStream is = Resources.getResourceAsStream(config);
// 3. 创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
// 4. 创建SqlSessionFactory对象
SqlSessionFactory factory = builder.build(is);
// 5. [重要] 获取SqlSession对象
SqlSession sqlSession = factory.openSession();
// 6. [重要] 指定要执行sql语句的标识，sql映射文件中的namespace + "." + 标签的id值
String sqlId = "com.company.dao.StudentDao" + "." + "findAll";
// 7. 执行sql语句
List<Student> studentList = sqlSession.selectList(sqlId);
// 8. 输出结果
for (Student student : studentList) {
System.out.println(student);
}
// 9. 关闭SqlSession对象
sqlSession.close();
}
}
String sqlId = “com.company.dao.StudentDao” + “.” + “findAll”;
com.company.dao.StudentDao匹配的是StudentDao的namespace
4. 实现类介绍
-
Resources
mybatis中的一个类，负责读取主配置文件
-
SqlSessionFactoryBuilder
创建SqlSessionFactory对象
-
SqlSessionFactory（接口）
重要对象，创建该对象耗时长，使用资源多，只要一个即可
获取SqlSession对象
openSession说明：
- 无参数，获取到非自动提交事务的SqlSession对象
- true，获取自动提交事务的SqlSession对象
-
SqlSession（接口）
定义了操作数据的方法
SqlSession不是线程安全的，需要在方法内部使用，使用后关闭才能保证线程安全
5. 获取session封装
public class MybatisUtil {
private static SqlSessionFactory factory;
/*
类加载时获取factory，factory只需要一个就行
*/
static {
String config = "data.xml";
try {
InputStream is = Resources.getResourceAsStream(config);
factory = new SqlSessionFactoryBuilder().build(is);
} catch (IOException e) {
e.printStackTrace();
}
}
private MybatisUtil() {}
public static SqlSession getSqlSession() {
return factory.openSession();
}
public static SqlSession getSqlSession(boolean flag) {
return factory.openSession(flag);
}
}
6. 动态代理实现类
Mybatis帮你创建dao接口的实现类，在实现类中调用SqlSession的方法执行sql语句
（反射机制）
实现动态代理的条件：
- dao接口和mapper文件尽量放在一起
- dao接口和mapper文件名称一致
- mapper文件中的namespace是dao接口的全限定名称
- mapper文件中的操作标签id值是接口中的方法名称
- dao接口不要使用重载方法（同名，不同参数）
public class Main {
public static void main(String[] args) {
SqlSession sqlSession = MybatisUtil.getSqlSession();
// 动态代理获取接口实现类
StudentDao dao = sqlSession.getMapper(StudentDao.class);
List<Student> studentList = dao.findAll();
for (Student student : studentList) {
System.out.println(student);
}
sqlSession.close();
}
}
7. 深入理解参数
public interface StudentDao {
// 查询所有数据
List<Student> findAll();
// 插入数据
int insert(Student stu);
// 根据Sno删除
int deleteBySno(String sno);
// 根据姓名年龄查询
List<Student> findByNameSex (@Param("name") String name, @Param("sex") String sex);
}
动态代理创建的实现类执行方法时，会检测出参数的类型，自动会赋给sql语句中的占位符
但是如果参数类型是类，那么占位符中的名字必须是类中的属性名，动态代理机制会检测出该属性名的getter方法。
#{传入类的属性名}
7.1 传入单个简单参数
这个占位符名字任意（前面是#的前提）
#{任意字符}
${指定名称}
简单参数：
- java中基本数据类型
- String类型
<delete id="deleteBySno">
delete from Student where Sno=#{sno}
</delete>
public void testDelete() {
SqlSession sqlSession = MybatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
Student stu = new Student();
stu.setSno("201515010");
int num = dao.deleteBySno("201515010");
sqlSession.commit();
System.out.println(num);
// 9. 关闭SqlSession对象
sqlSession.close();
}
7.2 传入多个简单参数
public void testFindByNameSex() {
SqlSession sqlSession = MybatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
String name = "张";
String sex = "男";
List<Student> studentList = dao.findByNameSex(name, sex);
for (Student student : studentList) {
System.out.println(student);
}
sqlSession.close();
}
7.2.1 使用注解（重要）
如果方法需要传入多个参数，需要在定义方法参数中使用注解指定在sql映射文件中占位符的名称
List<Student> findByNameSex (@Param("name") String name, @Param("sex") String sex);
<select id="findByNameSex" resultType="com.company.domain.Student">
select Sno, Sname, Ssex, Sage, Sdept
from Student
where Ssex = #{sex} and Sname like CONCAT('%',#{name},'%')
</select>
7.2.2 封装参数（重要）
这个方法是将参数封装成对象，类似于sqlSession.insert(String sqlId, Object obj)
在原方法中通过obj的getter方法找到参数，而封装参数就类似于此
public class FindByNameSex {
private String paramName;
private String paramSex;
public String getParamName() {
return paramName;
}
public void setParamName(String paramName) {
this.paramName = paramName;
}
public String getParamSex() {
return paramSex;
}
public void setParamSex(String paramSex) {
this.paramSex = paramSex;
}
}
List<Student> findByNameSex (FindByNameSex params);
<select id="findByNameSex" resultType="com.company.domain.Student">
select Sno, Sname, Ssex, Sage, Sdept
from Student
where Sname like CONCAT('%',#{paramName},'%') and Ssex = #{paramSex}
</select>
简化写法是：#{属性名}
具体写法是：#{属性名, javaType=属性名类型, jdbcType=属性在数据库的类型}
javaType和jdbcType是能在mybatis反射获取
7.2.3 指定顺序
Parameter ‘id’ not found. Available parameters are [arg1, arg0, param1, param2]，这句话的意思就是id找不到，可用的参数是[arg1, arg0, param1, param2]。所以可使用参数出现的顺序号码引用参数，第一个参数用arg0或param1表示，第二个参数用arg1或param2表示，以此类推（arg从0开始计数，param从1开始计数）。
<select id="findByNameSex" resultType="com.company.domain.Student">
select Sno, Sname, Ssex, Sage, Sdept
from Student
where Sname like CONCAT('%',#{arg0},'%') and Ssex = #{arg1}
</select>
7.2.4 封装map
在主函数中将参数封装成map集合，key是映射文件占位符的名字，value就是占位符的值
这种方式不推荐！！！
因为别人看代码十分不方便
/**
* 按照姓名和性别封装的集合查询
* @param params 参数集合
* @return 学生集合
*/
List<Student> findByNameSex (Map<String, Object> params);
public void testFindByNameSex() {
SqlSession sqlSession = MybatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
Map<String, Object> params = new HashMap<>();
params.put("myName", "张");
params.put("mySex", "男");
List<Student> studentList = dao.findByNameSex(params);
for (Student student : studentList) {
System.out.println(student);
}
sqlSession.close();
}
<select id="findByNameSex" resultType="com.company.domain.Student">
select Sno, Sname, Ssex, Sage, Sdept
from Student
where Sname like CONCAT('%',#{myName},'%') and Ssex = #{mySex}
</select>
7.3 $和#的区别
select * from student where id=#{studentId}
select * from student where id=?
select * from student where id=${studentId}
select * from student where id=1001
| #{} | ${} |
|---|---|
| 使用PreparedStatement | 使用Statement |
| 效率高 | 效率低 |
| 大程度避免SQL注入 | 无法避免SQL注入 |
| 可替换表名或列名 |
8. 封装输出结果
8.1 resultType
输出的参数类型最好是全限定名称。
可以是别名
8.1.1 简单类型参数
<select id="countStudent" resultType="java.lang.Integer">
select count(*) from Student
</select>
8.1.2 对象类型参数
注意：
- 封装对象的属性名要和字段名相同（不区分大小写）
- 封装对象一定要有setter和getter方法
封装输出对象
public class SelectAge {
private String sname;
private int sage;
public String getStuName() {
return sname;
}
public void setStuName(String sname) {
this.sname = sname;
}
public int getStuAge() {
return sage;
}
public void setStuAge(int sage) {
this.sage = sage;
}
@Override
public String toString() {
return "SelectAge{" +
"sname='" + sname + '\'' +
", sage=" + sage +
'}';
}
}
输出结果设为该对象
<select id="selectAge" resultType="com.company.vo.SelectAge">
select Sname, Sage from Student
</select>
执行查找
@Test
public void testSelectAge() {
SqlSession sqlSession = MybatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
List<SelectAge> stuList = dao.selectAge();
for (SelectAge stu : stuList) {
System.out.println(stu);
}
sqlSession.close();
}
8.1.3 Map
返回的对象是Map的话，列名是key，值是value
但是不能返回多个map，除非使用List<Map<Object, Object>>封装Map
8.2 resultMap
resultMap的作用是当封装对象的属性名和列名不一致的时候
在sql映射文件中配置属性名和字段名的映射关系
如果不使用resultMap，封装对象的属性名必须和字段名相同（不区分大小写）
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.company.dao.StudentDao">
<select id="selectAge" resultMap="selectAge">
select Sno, Sname, Sage from Student
</select>
<resultMap id="selectAge" type="com.company.vo.SelectAge">
<id column="Sno" property="stuId" />
<result column="Sname" property="stuName" />
<result column="Sage" property="stuAge" />
</resultMap>
</mapper>
主键字段使用id
其他字段使用result
8.3 as重写字段名
为使属性名和字段名匹配，在不使用resultMap时，可在sql语句中重写字段名使其与属性名一致
<select id="selectAge" resultType="com.company.vo.SelectAge">
select Sno as stuId, Sname as stuName, Sage as stuAge from Student
</select>
8.3 定义封装对象别名
定义返回封装对象别名是在主配置文件中配置
第一种方式：
<typeAliases>
<typeAlias type="com.company.vo.SelectAge" alias="SelectAge" />
</typeAliases>
<select id="selectAge" resultType="SelectAge">
select Sname, Sage from Student
</select>
第二种方式：
name是包名，这个包中的所有类的类名就是别名，此时类名不区分大小写
<typeAliases>
<package name="com.company.domain" />
</typeAliases>
<select id="findByNameSex" resultType="student">
select Sno, Sname, Ssex, Sage, Sdept
from Student
where Sname like CONCAT('%',#{myName},'%') and Ssex = #{mySex}
</select>
9. 动态SQL
根据条件，能够得到不同的sql语句，使用mybatis的标签即可实现
9.1 if
<if test="判断传入java对象的属性值">
部分sql语句
</if>
示例：
<select id="selectAgeIf" resultMap="selectAge">
select Sno, Sname, Sage from Student
where Sno > 0
<if test="sname != null and sname != ''">
and Sname = #{sname}
</if>
<if test="sage > 0">
or Sage > #{sage}
</if>
</select>
public void testSelectAgeIf() {
SqlSession sqlSession = MybatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
Student stu = new Student();
stu.setSname("张力");
stu.setSage(19);
List<SelectAge> stuList = dao.selectAgeIf(stu);
for (SelectAge student : stuList) {
System.out.println(student);
}
}
9.2 where
用来包含多个 的
当多个if中有只有一个成立，会自动增加一个where关键字并去除多余的and，or等
当多个if中有多个if成立，会自动删除第一个if中多余的and，or等，其余if中多余字段保留
示例：
<select id="selectAgeIf" resultMap="selectAge">
select Sno, Sname, Sage from Student
<where>
<if test="sname != null and sname != ''">
and Sname = #{sname}
</if>
<if test="sage > 0">
or Sage > #{sage}
</if>
</where>
</select>
@Test
public void testSelectAgeIf() {
SqlSession sqlSession = MybatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
Student stu = new Student();
stu.setSname("张力");
stu.setSage(19);
List<SelectAge> stuList = dao.selectAgeIf(stu);
for (SelectAge student : stuList) {
System.out.println(student);
}
}
9.3 foreach
循环java数组，list集合的。主要用于sql的in语句中
相关标签参数：
-
collection
接口中方法参数的类型，数组是array，集合是list
-
item
自定义，表示成员变量
-
open
循环开始时的字符
-
close
循环结束时的字符
-
separator
集合成员之间的分隔符
示例：
<select id="selectAgeFor" resultMap="selectAge">
select Sno, Sname, Sage from Student where Sno in
<foreach collection="list" item="id" open="(" close=")" separator=",">
#{id}
</foreach>
</select>
@Test
public void testSelectAgeFor() {
SqlSession sqlSession = MybatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
List<String> idList = new ArrayList<>();
idList.add("201415010");
idList.add("201415011");
idList.add("201415012");
List<SelectAge> stuList = dao.selectAgeFor(idList);
for (SelectAge student : stuList) {
System.out.println(student);
}
}
foreach标签的用法有很多巧妙之处：
<select id="selectAgeFor" resultMap="selectAge">
select Sno, Sname, Sage from Student where Sno in
<foreach collection="list" item="id" open="(" close=")">
#{id} ,
</foreach>
</select>
结果：
select Sno, Sname, Sage from Student where Sno in ( ? , ? , ? , )
<select id="selectAgeFor" resultMap="selectAge">
select Sno, Sname, Sage from Student where Sno in(
<foreach collection="list" item="id">
#{id} ,
</foreach>
-1, )
</select>
结果：
select Sno, Sname, Sage from Student where Sno in( ? , ? , ? , -1, )
如果集合或者数组中封装的是对象，需要遍历对象当中固定某个属性，可以使用 #{对象.属性名} 遍历
9.4 代码复用
可以将多次出现的sql语句进行复用
<sql id="allAttr">
select Sno, Sname, Ssex, Sage, Sdept from Student
</sql>
<select id="findAll" resultType="com.company.domain.Student">
<include refid="allAttr" />
where Ssex = '男'
</select>
<select id="findByNameSex" resultType="student">
<include refid="allAttr" />
where Sname like #{name} and Ssex = #{sex}
</select>
10. 分页输出
通过一个插件能够将结果分页显示，这个功能不是mybatis提供的。
10.1 导入依赖项
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.2.0</version>
</dependency>
10.2 主配置文件导入插件
<!-- 配置插件，一定要放在environments前面 -->
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor" />
</plugins>
<environments default="development">
<environment id="development">
...
10.3 实现分页
@Test
public void testFindAll() {
SqlSession sqlSession = MybatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
// 实现分页操作
PageHelper.startPage(1,5);
List<Student> studentList = dao.findAll();
for (Student student : studentList) {
System.out.println(student);
}
sqlSession.close();
}
这个PageHelper.startPage(1,5);表示第一页的五行数据，如果要查看第二页的五行数据则是PageHelper.startPage(2,5);
可以将多次出现的sql语句进行复用
<sql id="allAttr">
select Sno, Sname, Ssex, Sage, Sdept from Student
</sql>
<select id="findAll" resultType="com.company.domain.Student">
<include refid="allAttr" />
where Ssex = '男'
</select>
<select id="findByNameSex" resultType="student">
<include refid="allAttr" />
where Sname like #{name} and Ssex = #{sex}
</select>
10. 分页输出
通过一个插件能够将结果分页显示，这个功能不是mybatis提供的。
10.1 导入依赖项
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.2.0</version>
</dependency>
10.2 主配置文件导入插件
<!-- 配置插件，一定要放在environments前面 -->
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor" />
</plugins>
<environments default="development">
<environment id="development">
...
10.3 实现分页
@Test
public void testFindAll() {
SqlSession sqlSession = MybatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
// 实现分页操作
PageHelper.startPage(1,5);
List<Student> studentList = dao.findAll();
for (Student student : studentList) {
System.out.println(student);
}
sqlSession.close();
}
这个PageHelper.startPage(1,5);表示第一页的五行数据，如果要查看第二页的五行数据则是PageHelper.startPage(2,5);
扫一扫
676
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
