一、Mybatis 简介 1、MyBatis 历史
MyBatis 最初是 Apache 的一个开源项目 iBatis, 2010 年 6 月这个项目由 Apache Software Foundation 迁移到了 Google Code。随着开发团队转投 Google Code 旗下,iBatis3.x 正式更名为 MyBatis。代码于 2013 年 11 月迁移到 Github
iBatis 一词来源于“internet”和“abatis”的组合,是一个基于 Java 的持久层框架。iBatis 提供的持久层框架包括 SQL Maps 和 Data Access Objects(DAO)
2、MyBatis 特性
MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
MyBatis 可以使用简单的 XML 或注解用于配置和原始映射,将接口和 Java 的 POJO(Plain Old Java Objects,普通的 Java 对象)映射成数据库中的记录
MyBatis 是一个 半自动的 ORM(Object Relation Mapping)框架
3、MyBatis 下载
4、和其它持久化层技术对比
JDBC
SQL 夹杂在 Java 代码中耦合度高,导致硬编码内伤
维护不易且实际开发需求中 SQL 有变化,频繁修改的情况多见
代码冗长,开发效率低
Hibernate 和 JPA
操作简便,开发效率高
程序中的长难复杂 SQL 需要绕过框架
内部自动生产的 SQL,不容易做特殊优化
基于全映射的全自动框架,大量字段的 POJO 进行部分映射时比较困难。
反射操作太多,导致数据库性能下降
MyBatis
轻量级,性能出色
SQL 和 Java 编码分开,功能边界清晰。Java 代码专注业务、SQL 语句专注数据
开发效率稍逊于 HIbernate,但是完全能够接受
二、搭建 MyBatis 1、开发环境
IDE:idea 2022.2
构建工具:maven 3.6.3
MySQL 版本:MySQL 5.7
MyBatis 版本:MyBatis 3.5.7
2、创建 maven 工程 a>打包方式:jar b>引入依赖 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 <dependencies > <dependency > <groupId > org.mybatis</groupId > <artifactId > mybatis</artifactId > <version > 3.5.7</version > </dependency > <dependency > <groupId > junit</groupId > <artifactId > junit</artifactId > <version > 4.12</version > <scope > test</scope > </dependency > <dependency > <groupId > mysql</groupId > <artifactId > mysql-connector-java</artifactId > <version > 5.1.3</version > </dependency > </dependencies >
3、创建 MyBatis 的核心配置文件
习惯上命名为mybatis-config.xml
,这个文件名仅仅只是建议,并非强制要求。将来整合 Spring 之后,这个配置文件可以省略,所以大家操作时可以直接复制、粘贴。 核心配置文件主要用于配置连接数据库的环境以及 MyBatis 的全局配置信息 核心配置文件存放的位置是 src/main/resources 目录下
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 <?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 > <environments default ="development" > <environment id ="development" > <transactionManager type ="JDBC" /> <dataSource type ="POOLED" > <property name ="driver" value ="com.mysql.cj.jdbc.Driver" /> <property name ="url" value ="jdbc:mysql://localhost:3306/MyBatis" /> <property name ="username" value ="root" /> <property name ="password" value ="123456" /> </dataSource > </environment > </environments > <mappers > <mapper resource ="mappers/UserMapper.xml" /> </mappers > </configuration >
4、创建 mapper 接口
MyBatis 中的 mapper 接口相当于以前的 dao。但是区别在于,mapper 仅仅是接口,我们不需要提供实现类
1 2 3 4 5 6 7 8 package com.atguigu.mybatis.mapper;public interface UserMapper { int insertUser () ; }
5、创建 MyBatis 的映射文件
相关概念:ORM(Object Relationship Mapping)对象关系映射。
对象:Java 的实体类对象
关系:关系型数据库
映射:二者之间的对应关系
Java 概念
数据库概念
类
表
属性
字段/列
对象
记录/行
1、映射文件的命名规则
表所对应的实体类的类名+Mapper.xml
例如:表 t_user,映射的实体类为 User,所对应的映射文件为 UserMapper.xml
因此一个映射文件对应一个实体类,对应一张表的操作
MyBatis 映射文件用于编写 SQL,访问以及操作表中的数据
MyBatis 映射文件存放的位置是 src/main/resources/mappers 目录下
2 、MyBatis 中可以面向接口操作数据,要保证两个一致
a> mapper 接口的全类名和映射文件的命名空间(namespace)保持一致
b> mapper 接口中方法的方法名和映射文件中编写 SQL 的标签的 id 属性保持一致
1 2 3 4 5 6 7 8 9 10 <?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.atguigu.mybatis.mapper.UserMapper" > <insert id ="insertUser" > insert into t_user values(null,'张三','123',23,'女') </insert > </mapper >
6、通过 junit 测试功能
SqlSession:代表 Java 程序和数据库之间的会话。(HttpSession 是 Java 程序和浏览器之间的会话)
SqlSessionFactory:是“生产”SqlSession 的“工厂”
工厂模式:如果创建某一个对象,使用的过程基本固定,那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中,以后都使用这个工厂类来“生产”我们需要的对象
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 public class UserMapperTest { @Test public void testInsertUser () throws IOException { InputStream is = Resources.getResourceAsStream("mybatis-config.xml" ); SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder (); SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is); SqlSession sqlSession = sqlSessionFactory.openSession(true ); UserMapper userMapper = sqlSession.getMapper(UserMapper.class); int result = userMapper.insertUser(); System.out.println("result:" + result); } }
此时需要手动提交事务,如果要自动提交事务,则在获取 sqlSession 对象时,使用SqlSession sqlSession = sqlSessionFactory.openSession(true);
,传入一个 Boolean 类型的参数,值为 true,这样就可以自动提交
7、加入 log4j 日志功能 a>加入依赖 1 2 3 4 5 6 <dependency > <groupId > log4j</groupId > <artifactId > log4j</artifactId > <version > 1.2.17</version > </dependency >
b>加入 log4j 的配置文件
log4j 的配置文件名为 log4j.xml,存放的位置是 src/main/resources 目录下
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE log4j :configuration SYSTEM "log4j.dtd" > <log4j:configuration xmlns:log4j ="http://jakarta.apache.org/log4j/" > <appender name ="STDOUT" class ="org.apache.log4j.ConsoleAppender" > <param name ="Encoding" value ="UTF-8" /> <layout class ="org.apache.log4j.PatternLayout" > <param name ="ConversionPattern" value ="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" /> </layout > </appender > <logger name ="java.sql" > <level value ="debug" /> </logger > <logger name ="org.apache.ibatis" > <level value ="info" /> </logger > <root > <level value ="debug" /> <appender-ref ref ="STDOUT" /> </root > </log4j:configuration >
日志的级别
FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)
从左到右打印的内容越来越详细
三、核心配置文件详解
核心配置文件中的标签必须按照固定的顺序(有的标签可以不写,但顺序一定不能乱): properties、settings、typeAliases、typeHandlers、objectFactory、objectWrapperFactory、reflectorFactory、plugins、environments、databaseIdProvider、mappers
environments 中可以设置多个连接数据库的环境,这个设置是必要的,当然也可以只设一个 environment,设置了多个可以指定默认值
一开始 environment 中的驱动,url,username,password 都是写死的,很不好,想要使用 properties,就需要再最开头配置 properties
后期查询功能回会很多,但是 UserMapper.xml 中如果 resultType 使用全类名就很复杂如:
1 2 3 <select id ="getAllUser" resultType ="com.zhang.mybatis.pojo.User" > select * from mybatis.t_user; </select >
但是如果配置别名:<typeAlias type="com.zhang.mybatis.pojo.User" alias="User"/>
就可简写为:
1 2 3 <select id ="getAllUser" resultType ="User" > select * from mybatis.t_user; </select >
如果不写 alias 就使用默认的别名,即类名==不区分大小写==。
最常用的是:以包为单位,设置改包下所有的类型都拥有默认的别名,即类名且不区分大小写 。
1 <package name ="com.atguigu.mybatis.bean" />
映射文件会很多,但是可以直接引入包,引入包下的所有映射文件(只有将映射文件配置了之后该映射文件才能起作用(Mapper 相当于一个 Dao,后期需要的 Dao 很多,所以需要引入包的功能))
整体配置文件(目前需要的配置):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 <?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" > </properties > <settings > <setting name ="mapUnderscoreToCamelCase" value ="true" /> <setting name ="lazyLoadingEnabled" value ="true" /> </settings > <typeAliases > <package name ="com.atguigu.mybatis.bean" /> </typeAliases > <environments default ="development" > <environment id ="development" > <transactionManager type ="JDBC" /> <dataSource type ="POOLED" > <property name ="driver" value ="${jdbc.driver}" /> <property name ="url" value ="${jdbc.url}" /> <property name ="username" value ="${jdbc.username}" /> <property name ="password" value ="${jdbc.password}" /> </dataSource > </environment > </environments > <mappers > <package name ="com.atguigu.mybatis.mapper" /> </mappers > </configuration >
默认的类型别名
四、MyBatis 的增删改查
添加1 2 3 4 <insert id ="insertUser" > insert into t_user values(null,'admin','123456',23,'男','12345@qq.com') </insert >
删除1 2 3 4 <delete id ="deleteUser" > delete from t_user where id = 6 </delete >
修改1 2 3 4 <update id ="updateUser" > update t_user set username = '张三' where id = 5 </update >
查询一个实体类对象1 2 3 4 <select id ="getUserById" resultType ="com.atguigu.mybatis.bean.User" > select * from t_user where id = 2 </select >
查询集合1 2 3 4 <select id ="getUserList" resultType ="com.atguigu.mybatis.bean.User" > select * from t_user </select >
注意:
查询的标签 select 必须设置属性 resultType 或 resultMap,用于设置实体类和数据库表的映射关系
resultType:自动映射,用于属性名和表中字段名一致的情况
resultMap:自定义映射,用于一对多或多对一或字段名和属性名不一致的情况
当查询的数据为多条时,不能使用实体类作为返回值,只能使用集合,否则会抛出异常 TooManyResultsException;但是若查询的数据只有一条,可以使用实体类或集合作为返回值
五、MyBatis 获取参数值的两种方式(重点)
MyBatis 获取参数值的两种方式:${}
和#{}
${}
的本质就是字符串拼接,#{}
的本质就是占位符赋值
${}
使用字符串拼接的方式拼接 sql,若为字符串类型或日期类型的字段进行赋值时,需要手动加单引号;但是#{}
使用占位符赋值的方式拼接 sql,此时为字符串类型或日期类型的字段进行赋值时,可以自动添加单引号
${}
相当于 Statement;#{}
PreparedStatement,同样的道理,能用#{}
就不用${}
1、单个字面量类型的参数
若 mapper 接口中的方法参数为单个的字面量类型,此时可以使用${}和#{}以任意的名称(#{aaa}这样的也能正常运行)(最好见名识意)获取参数的值,注意${}需要手动加单引号
1 2 3 4 <select id ="getUserByUsername" resultType ="User" > select * from t_user where username = #{username} </select >
1 2 3 4 <select id ="getUserByUsername" resultType ="User" > select * from t_user where username = '${username}' </select >
2、多个字面量类型的参数
若 mapper 接口中的方法参数为多个时,此时 MyBatis 会自动将这些参数放在一个 map 集合中
以 arg0,arg1…为键,以参数为值;
以 param1,param2…为键,以参数为值;
因此只需要通过${}和#{}访问 map 集合的键就可以获取相对应的值,注意${}需要手动加单引号。
使用 arg 或者 param 都行,要注意的是,arg 是从 arg0 开始的,param 是从 param1 开始的
1 2 3 4 <select id ="checkLogin" resultType ="User" > select * from t_user where username = #{arg0} and password = #{arg1} </select >
1 2 3 4 <select id ="checkLogin" resultType ="User" > select * from t_user where username = '${param1}' and password = '${param2}' </select >
3、map 集合类型的参数
若 mapper 接口中的方法需要的参数为多个时,此时可以手动创建 map 集合,将这些数据放在 map 中只需要通过${}和#{}访问 map 集合的键就可以获取相对应的值,注意${}需要手动加单引号
1 2 3 4 <select id ="checkLoginByMap" resultType ="User" > select * from t_user where username = #{username} and password = #{password} </select >
1 2 3 4 5 6 7 8 9 10 11 @Test public void checkLoginByMap () { SqlSession sqlSession = SqlSessionUtils.getSqlSession(); ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class); Map<String,Object> map = new HashMap <>(); map.put("usermane" ,"admin" ); map.put("password" ,"123456" ); User user = mapper.checkLoginByMap(map); System.out.println(user); }
4、实体类类型的参数
若 mapper 接口中的方法参数为实体类对象时此时可以使用${}和#{},通过访问实体类对象中的属性名获取属性值,注意${}需要手动加单引号
1 2 3 4 <insert id ="insertUser" > insert into t_user values(null,#{username},#{password},#{age},#{sex},#{email}) </insert >
1 2 3 4 5 6 7 @Test public void insertUser () { SqlSession sqlSession = SqlSessionUtils.getSqlSession(); ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class); User user = new User (null ,"Tom" ,"123456" ,12 ,"男" ,"123@321.com" ); mapper.insertUser(user); }
5、使用@Param 标识参数
可以通过@Param 注解标识 mapper 接口中的方法参数,此时,会将这些参数放在 map 集合中
以@Param 注解的 value 属性值为键,以参数为值;
以 param1,param2…为键,以参数为值;(这种参数也可以)
只需要通过${}和#{}访问 map 集合的键就可以获取相对应的值,注意${}需要手动加单引号
其实就是第 2 种和第 3 种方法的加强版(不用像 2 那样不能见名知意,也不用像 3 那样代码复杂)
1 2 3 4 <select id ="CheckLoginByParam" resultType ="User" > select * from t_user where username = #{username} and password = #{password} </select >
1 2 3 4 5 6 @Test public void checkLoginByParam () { SqlSession sqlSession = SqlSessionUtils.getSqlSession(); ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class); mapper.CheckLoginByParam("admin" ,"123456" ); }
6、总结
看调用函数的参数个数:
单个参数#{}的大括号中的值随意(一般见名知意即可)
多个参数
看调用函数的参数类型
普通类型
Map 类型
实体类类型
@Param 标识类型
多个参数时建议分成两种情况进行处理
实体类类型的参数
使用@Param 标识参数
原因:
普通类型时的 arg0,arg1…不容易见名知意
Map 类型再调用时,需要手动 new 一个 map 再把值 put 进 map 中,且 map 的 key 也要和#{}中的名字一样,耦合度高,且代码复杂
六、MyBatis 的各种查询功能
如果查询出的数据只有一条,可以通过
实体类对象接收
List 集合接收
Map 集合接收,结果{password=123456, sex=男, id=1, age=23, username=admin}
如果查询出的数据有多条,一定不能用实体类对象接收,会抛异常 TooManyResultsException,可以通过
实体类类型的 LIst 集合接收
Map 类型的 LIst 集合接收
在 mapper 接口的方法上添加@MapKey 注解
1、查询一个实体类对象 1 2 3 4 5 6 User getUserById (@Param("id") int id) ;
1 2 3 4 <select id ="getUserById" resultType ="User" > select * from t_user where id = #{id} </select >
2、查询一个 List 集合 1 2 3 4 5 List<User> getUserList () ;
1 2 3 4 <select id ="getUserList" resultType ="User" > select * from t_user </select >
3、查询单个数据
1 2 3 4 <select id ="getCount" resultType ="_integer" > select count(id) from t_user </select >
4、查询一条数据为 map 集合 1 2 3 4 5 6 Map<String, Object> getUserToMap (@Param("id") int id) ;
1 2 3 4 5 <select id ="getUserToMap" resultType ="map" > select * from t_user where id = #{id} </select >
5、查询多条数据为 map 集合 方法一: 1 2 3 4 5 6 List<Map<String, Object>> getAllUserToMap () ;
1 2 3 4 5 6 7 8 9 10 <select id ="getAllUserToMap" resultType ="map" > select * from t_user </select >
方法二:(使用较多) 1 2 3 4 5 6 7 @MapKey("id") <!-- id是主键不会重复 -->Map<String, Object> getAllUserToMap () ;
1 2 3 4 5 6 7 8 9 10 11 12 <select id ="getAllUserToMap" resultType ="map" > select * from t_user </select >
七、特殊 SQL 的执行 1、模糊查询 1 2 3 4 5 6 7 List<User> getUserByLike (@Param("username") String username) ;
1 2 3 4 5 6 7 8 9 10 11 <select id ="getUserByLike" resultType ="User" > SELECT * FROM mybatis.t_user where username like "%"#{username}"%" </select >
其中 select * from t_user where username like "%"#{username}"%"
是最常用的
’%‘ 只是 SQL 语句的模糊查询的符号,使用 ’_‘ 也可以,且和 sql 的意思一样
2、批量删除
==只能使用${} ==,如果使用#{},则解析后的 sql 语句为delete from t_user where id in ('1,2,3')
,这样是将1,2,3
看做是一个整体,只有 id 为1,2,3
的数据会被删除。正确的语句应该是delete from t_user where id in (1,2,3)
,或者delete from t_user where id in ('1','2','3')
1 2 3 4 5 6 7 int deleteMore (@Param("ids") String ids) ;
1 2 3 <delete id ="deleteMore" > delete from t_user where id in (${ids}) </delete >
1 2 3 4 5 6 7 8 @Test public void deleteMore () { SqlSession sqlSession = SqlSessionUtils.getSqlSession(); SQLMapper mapper = sqlSession.getMapper(SQLMapper.class); int result = mapper.deleteMore("1,2,3,8" ); System.out.println(result); }
3、动态设置表名
1 2 3 4 5 6 7 List<User> getUserByTable (@Param("tableName") String tableName) ;
1 2 3 4 <select id ="getUserByTable" resultType ="User" > select * from ${tableName} </select >
4、添加功能获取自增的主键 使用场景:
t_clazz(clazz_id,clazz_name)
t_student(student_id,student_name,clazz_id)
添加班级信息
获取新添加的班级的 id
为班级分配学生,即将某学的班级 id 修改为新添加的班级的 id
在 mapper.xml 中设置两个属性
useGeneratedKeys:设置使用自增的主键
keyProperty:因为增删改有统一的返回值是受影响的行数,因此只能将获取的自增的主键放在传输的参数 user 对象的某个属性中
1 2 3 4 5 6 void insertUser (User user) ;
1 2 3 4 <insert id ="insertUser" useGeneratedKeys ="true" keyProperty ="id" > insert into t_user values (null,#{username},#{password},#{age},#{sex},#{email}) </insert >
1 2 3 4 5 6 7 8 9 10 @Test public void insertUser () { SqlSession sqlSession = SqlSessionUtils.getSqlSession(); SQLMapper mapper = sqlSession.getMapper(SQLMapper.class); User user = new User (null , "ton" , "123" , 23 , "男" , "123@321.com" ); mapper.insertUser(user); System.out.println(user); }
八、自定义映射 resultMap 如果实体类的属性和表中的字段不一样时,使用普通的查询会将该字段的内容显示为 null
这个时候就需要使用自定义映射了
1、resultMap 处理字段和属性的映射关系
若字段名和实体类中的属性名不一致,则可以通过 resultMap 设置自定义映射,即使字段名和属性名一致的属性也要映射,也就是全部属性都要列出来
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 <resultMap id ="empResultMap" type ="Emp" > <id property ="eid" column ="eid" > </id > <result property ="empName" column ="emp_name" > </result > <result property ="age" column ="age" > </result > <result property ="sex" column ="sex" > </result > <result property ="email" column ="email" > </result > </resultMap > <select id ="getAllEmp" resultMap ="empResultMap" > select * from t_emp </select >
若字段名和实体类中的属性名不一致,但是字段名符合数据库的规则(使用_),实体类中的属性名符合 Java 的规则(使用驼峰)。此时也可通过以下两种方式处理字段名和实体类中的属性的映射关系
可以通过为字段起别名的方式,保证和实体类中的属性名保持一致
1 2 3 4 <select id ="getAllEmp" resultType ="Emp" > select eid,emp_name empName,age,sex,email from t_emp </select >
可以在 MyBatis 的核心配置文件中的setting
标签中,设置一个全局配置信息 mapUnderscoreToCamelCase,可以在查询表中数据时,自动将_类型的字段名转换为驼峰 ,例如:字段名 user_name,设置了 mapUnderscoreToCamelCase,此时字段名就会转换为 userName。核心配置文件详解
1 2 3 <settings > <setting name ="mapUnderscoreToCamelCase" value ="true" /> </settings >
2、多对一映射处理
查询员工信息以及员工所对应的部门信息(多表联查)
1 2 3 4 5 6 7 8 9 public class Emp { private Integer eid; private String empName; private Integer age; private String sex; private String email; private Dept dept; }
a>级联方式处理映射关系 1 2 3 4 5 6 7 8 9 10 11 12 13 14 <resultMap id ="empAndDeptResultMapOne" type ="Emp" > <id property ="eid" column ="eid" > </id > <result property ="empName" column ="emp_name" > </result > <result property ="age" column ="age" > </result > <result property ="sex" column ="sex" > </result > <result property ="email" column ="email" > </result > <result property ="dept.did" column ="did" > </result > <result property ="dept.deptName" column ="dept_name" > </result > </resultMap > <select id ="getEmpAndDept" resultMap ="empAndDeptResultMapOne" > select * from t_emp left join t_dept on t_emp.eid = t_dept.did where t_emp.eid = #{eid} </select >
b>使用 association 处理映射关系
association:处理多对一的映射关系
property:需要处理多对的映射关系的属性名
javaType:该属性的类型(如果是对象就是对象的类名)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 <resultMap id ="empAndDeptResultMapTwo" type ="Emp" > <id property ="eid" column ="eid" > </id > <result property ="empName" column ="emp_name" > </result > <result property ="age" column ="age" > </result > <result property ="sex" column ="sex" > </result > <result property ="email" column ="email" > </result > <association property ="dept" javaType ="Dept" > <id property ="did" column ="did" > </id > <result property ="deptName" column ="dept_name" > </result > </association > </resultMap > <select id ="getEmpAndDept" resultMap ="empAndDeptResultMapTwo" > select * from t_emp left join t_dept on t_emp.eid = t_dept.did where t_emp.eid = #{eid} </select >
c>分步查询 1. 查询员工信息
select:设置分布查询的 sql 的唯一标识(namespace.SQLId 或 mapper 接口的全类名.方法名)
column:设置分步查询的条件
1 2 3 4 5 6 7 8 9 Emp getEmpAndDeptByStepOne (@Param("eid") Integer eid) ;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 <resultMap id ="empAndDeptByStepResultMap" type ="Emp" > <id property ="eid" column ="eid" > </id > <result property ="empName" column ="emp_name" > </result > <result property ="age" column ="age" > </result > <result property ="sex" column ="sex" > </result > <result property ="email" column ="email" > </result > <association property ="dept" select ="com.atguigu.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo" column ="did" > </association > </resultMap > <select id ="getEmpAndDeptByStepOne" resultMap ="empAndDeptByStepResultMap" > select * from t_emp where eid = #{eid} </select >
2. 查询部门信息 1 2 3 4 5 6 7 8 9 Dept getEmpAndDeptByStepTwo (@Param("did") Integer did) ;
1 2 3 4 5 6 7 8 9 <resultMap id ="EmpAndDeptByStepTwoResultMap" type ="Dept" > <id property ="did" column ="did" > </id > <result property ="deptName" column ="dept_name" > </result > </resultMap > <select id ="getEmpAndDeptByStepTwo" resultMap ="EmpAndDeptByStepTwoResultMap" > select * from t_dept where did = #{did} </select >
3、一对多映射处理 1 2 3 4 5 6 public class Dept { private Integer did; private String deptName; private List<Emp> emps; }
a>collection
collection:用来处理一对多的映射关系
ofType:表示该属性对应的集合中存储的数据的类型
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 <resultMap id ="DeptAndEmpResultMap" type ="Dept" > <id property ="did" column ="did" > </id > <result property ="deptName" column ="dept_name" > </result > <collection property ="emps" ofType ="Emp" > <id property ="eid" column ="eid" > </id > <result property ="empName" column ="emp_name" > </result > <result property ="age" column ="age" > </result > <result property ="sex" column ="sex" > </result > <result property ="email" column ="email" > </result > </collection > </resultMap > <select id ="getDeptAndEmp" resultMap ="DeptAndEmpResultMap" > select * from t_dept left join t_emp on t_dept.did = t_emp.did where t_dept.did = #{did} </select >
b>分步查询 1. 查询部门信息 1 2 3 4 5 6 7 8 Dept getDeptAndEmpByStepOne (@Param("did") Integer did) ;
1 2 3 4 5 6 7 8 9 10 11 <resultMap id ="DeptAndEmpByStepOneResultMap" type ="Dept" > <id property ="did" column ="did" > </id > <result property ="deptName" column ="dept_name" > </result > <collection property ="emps" select ="com.atguigu.mybatis.mapper.EmpMapper.getDeptAndEmpByStepTwo" column ="did" > </collection > </resultMap > <select id ="getDeptAndEmpByStepOne" resultMap ="DeptAndEmpByStepOneResultMap" > select * from t_dept where did = #{did} </select >
2. 根据部门 id 查询部门中的所有员工 1 2 3 4 5 6 7 8 List<Emp> getDeptAndEmpByStepTwo (@Param("did") Integer did) ;
1 2 3 4 <select id ="getDeptAndEmpByStepTwo" resultType ="Emp" > select * from t_emp where did = #{did} </select >
c>延迟加载
分步查询的优点:可以实现延迟加载,但是必须在核心配置文件中设置全局配置信息:
lazyLoadingEnabled:延迟加载的全局开关。当开启时,所有关联对象都会延迟加载
aggressiveLazyLoading:当开启时,任何方法的调用都会加载该对象的所有属性。 否则,每个属性会按需加载
此时就可以实现按需加载,获取的数据是什么,就只会执行相应的 sql。此时可通过 association 和 collection 中的 fetchType 属性设置当前的分步查询是否使用延迟加载,fetchType=”lazy(延迟加载)|eager(立即加载)”
1 2 3 4 <settings > <setting name ="lazyLoadingEnabled" value ="true" /> </settings >
1 2 3 4 5 6 7 @Test public void getEmpAndDeptByStepOne () { SqlSession sqlSession = SqlSessionUtils.getSqlSession(); EmpMapper mapper = sqlSession.getMapper(EmpMapper.class); Emp emp = mapper.getEmpAndDeptByStepOne(1 ); System.out.println(emp.getEmpName()); }
关闭延迟加载,两条 SQL 语句都运行了
开启延迟加载,只运行获取 emp 的 SQL 语句
1 2 3 4 5 6 7 8 9 @Test public void getEmpAndDeptByStepOne () { SqlSession sqlSession = SqlSessionUtils.getSqlSession(); EmpMapper mapper = sqlSession.getMapper(EmpMapper.class); Emp emp = mapper.getEmpAndDeptByStepOne(1 ); System.out.println(emp.getEmpName()); System.out.println("----------------" ); System.out.println(emp.getDept()); }
开启后,需要用到查询 dept 的时候才会调用相应的 SQL 语句
fetchType:当开启了全局的延迟加载之后,可以通过该属性手动控制延迟加载的效果,fetchType=”lazy(延迟加载)|eager(立即加载)”
1 2 3 4 5 6 7 8 9 10 11 <resultMap id ="empAndDeptByStepResultMap" type ="Emp" > <id property ="eid" column ="eid" > </id > <result property ="empName" column ="emp_name" > </result > <result property ="age" column ="age" > </result > <result property ="sex" column ="sex" > </result > <result property ="email" column ="email" > </result > <association property ="dept" select ="com.atguigu.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo" column ="did" fetchType ="lazy" ></association > </resultMap >
总结
多对一映射用 association
一对多映射用 collection
分布查询都是一样的
都是 property 中写查询属性类型
select 后面调用语句(用全类名+方法名)
column 后面相当于就是 join on 结构中 on 后面要求建立的关系的字段
都可使用延迟加载,效果也一样
九、动态 SQL
Mybatis 框架的动态 SQL 技术是一种根据特定条件动态拼装 SQL 语句的功能,它存在的意义是为了解决拼接 SQL 语句字符串时的痛点问题
1、if
2、where
where 和 if 一般结合使用:
若 where 标签中的 if 条件都不满足,则 where 标签没有任何功能,即不会添加 where 关键字
若 where 标签中的 if 条件满足,则 where 标签会自动添加 where 关键字,并将条件最前方 多余的 and/or 去掉
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 <select id ="getEmpByCondition" resultType ="Emp" > select * from t_emp <where > <if test ="empName != null and empName !=''" > emp_name = #{empName} </if > <if test ="age != null and age !=''" > and age = #{age} </if > <if test ="sex != null and sex !=''" > and sex = #{sex} </if > <if test ="email != null and email !=''" > and email = #{email} </if > </where > </select >
注意:where 标签不能去掉条件后 多余的 and/or
1 2 3 4 5 6 7 <if test ="empName != null and empName !=''" > emp_name = #{empName} and </if > <if test ="age != null and age !=''" > age = #{age} </if >
3、trim 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 <select id ="getEmpByCondition" resultType ="Emp" > select * from t_emp <trim prefix ="where" suffixOverrides ="and|or" > <if test ="empName != null and empName !=''" > emp_name = #{empName} and </if > <if test ="age != null and age !=''" > age = #{age} and </if > <if test ="sex != null and sex !=''" > sex = #{sex} or </if > <if test ="email != null and email !=''" > email = #{email} </if > </trim > </select >
1 2 3 4 5 6 7 8 @Test public void getEmpByCondition () { SqlSession sqlSession = SqlSessionUtils.getSqlSession(); DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class); List<Emp> emps= mapper.getEmpByCondition(new Emp (null , "张三" , null , null , null , null )); System.out.println(emps); }
trim 用于去掉或添加标签中的内容
常用属性
prefix:在 trim 标签中的内容的前面 添加 某些内容
suffix:在 trim 标签中的内容的后面 添加 某些内容
prefixOverrides:在 trim 标签中的内容的前面 去掉 某些内容
suffixOverrides:在 trim 标签中的内容的后面 去掉 某些内容
若 trim 中的标签都不满足条件,则 trim 标签没有任何效果,也就是只剩下select * from t_emp
4、choose、when、otherwise
choose、when、otherwise
相当于if...else if..else
when
相当于else if
; otherwise
相当于else
when 至少要有一个,otherwise 至多只有一个
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 <select id ="getEmpByChoose" resultType ="Emp" > select * from t_emp <where > <choose > <when test ="empName != null and empName != ''" > emp_name = #{empName} </when > <when test ="age != null and age != ''" > age = #{age} </when > <when test ="sex != null and sex != ''" > sex = #{sex} </when > <when test ="email != null and email != ''" > email = #{email} </when > <otherwise > did = 1 </otherwise > </choose > </where > </select >
1 2 3 4 5 6 7 @Test public void getEmpByChoose () { SqlSession sqlSession = SqlSessionUtils.getSqlSession(); DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class); List<Emp> emps = mapper.getEmpByChoose(new Emp (null , "张三" , 23 , "男" , "123@qq.com" , null )); System.out.println(emps); }
相当于if a else if b else if c else d
,只会执行其中一个
5、foreach
1 2 3 4 5 6 7 <delete id ="deleteMoreByArray" > delete from t_emp where eid in <foreach collection ="eids" item ="eid" separator ="," open ="(" close =")" > #{eid} </foreach > </delete >
1 2 3 4 5 6 7 @Test public void deleteMoreByArray () {SqlSession sqlSession = SqlSessionUtils.getSqlSession();DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);int result = mapper.deleteMoreByArray(new Integer []{6 , 7 , 8 , 9 });System.out.println(result); }
属性:
collection:设置要循环的数组或集合
item:表示集合或数组中的每一个数据
separator:设置循环体之间的分隔符,分隔符前后默认有一个空格,如,
open:设置 foreach 标签中的内容的开始符
close:设置 foreach 标签中的内容的结束符
1 2 3 4 5 6 7 <insert id ="insertMoreByList" > insert into t_emp values <foreach collection ="emps" item ="emp" separator ="," > (null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},null) </foreach > </insert >
1 2 3 4 5 6 7 8 9 10 11 @Test public void insertMoreByList () {SqlSession sqlSession = SqlSessionUtils.getSqlSession();DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);Emp emp1 = new Emp (null ,"a" ,1 ,"男" ,"123@321.com" ,null );Emp emp2 = new Emp (null ,"b" ,1 ,"男" ,"123@321.com" ,null );Emp emp3 = new Emp (null ,"c" ,1 ,"男" ,"123@321.com" ,null );List<Emp> emps = Arrays.asList(emp1, emp2, emp3); int result = mapper.insertMoreByList(emps);System.out.println(result); }
6、SQL 片段
sql 片段,可以记录一段公共 sql 片段,在使用的地方通过 include 标签进行引入
声明 sql 片段:<sql>
标签
1 <sql id ="empColumns" > eid,emp_name,age,sex,email</sql >
1 2 3 4 <select id ="getEmpByCondition" resultType ="Emp" > select <include refid ="empColumns" > </include > from t_emp </select >
十、MyBatis 的缓存 1、MyBatis 的一级缓存
一级缓存是 SqlSession 级别的,通过同一个 SqlSession 查询的数据会被缓存,下次查询相同的数据,就会从缓存中直接获取,不会从数据库重新访问
使一级缓存失效的四种情况:
不同的 SqlSession 对应不同的一级缓存
同一个 SqlSession 但是查询条件不同
同一个 SqlSession 两次查询期间执行了任何一次增删改操作
同一个 SqlSession 两次查询期间手动清空了缓存 sqlSession 有个方法 clearCache,调用之后就清空了缓存
注意范围和功能
2、MyBatis 的二级缓存
3、二级缓存的相关配置
在 mapper 配置文件中添加的 cache 标签可以设置一些属性
eviction 属性:缓存回收策略
LRU(Least Recently Used) – 最近最少使用的:移除最长时间不被使用的对象。
FIFO(First in First out) – 先进先出:按对象进入缓存的顺序来移除它们。
SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。
WEAK – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。
默认的是 LRU
flushInterval 属性:刷新间隔,单位毫秒
默认情况是不设置,也就是没有刷新间隔,缓存仅仅调用语句(增删改)时刷新
size 属性:引用数目,正整数
代表缓存最多可以存储多少个对象,太大容易导致内存溢出
readOnly 属性:只读,true/false
true:只读缓存;会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
false:读写缓存;会返回缓存对象的拷贝(通过序列化)。这会慢一些,但是安全,因此默认是 false
4、MyBatis 缓存查询的顺序
先查询二级缓存,因为二级缓存中可能会有其他程序已经查出来的数据,可以拿来直接使用
如果二级缓存没有命中,再查询一级缓存
如果一级缓存也没有命中,则查询数据库
SqlSession 关闭之后,一级缓存中的数据会写入二级缓存
5、整合第三方缓存 EHCache(了解) a>添加依赖 1 2 3 4 5 6 7 8 9 10 11 12 <dependency > <groupId > org.mybatis.caches</groupId > <artifactId > mybatis-ehcache</artifactId > <version > 1.2.1</version > </dependency > <dependency > <groupId > ch.qos.logback</groupId > <artifactId > logback-classic</artifactId > <version > 1.2.3</version > </dependency >
b>各个 jar 包的功能
jar 包名称
作用
mybatis-ehcache
Mybatis 和 EHCache 的整合包
ehcache
EHCache 核心包
slf4j-api
SLF4J 日志门面包
logback-classic
支持 SLF4J 门面接口的一个具体实现
c>创建 EHCache 的配置文件 ehcache.xml
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 <?xml version="1.0" encoding="utf-8" ?> <ehcache xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation ="../config/ehcache.xsd" > <diskStore path ="D:\atguigu\ehcache" /> <defaultCache maxElementsInMemory ="1000" maxElementsOnDisk ="10000000" eternal ="false" overflowToDisk ="true" timeToIdleSeconds ="120" timeToLiveSeconds ="120" diskExpiryThreadIntervalSeconds ="120" memoryStoreEvictionPolicy ="LRU" > </defaultCache > </ehcache >
d>设置二级缓存的类型
在 xxxMapper.xml 文件中设置二级缓存类型
1 <cache type ="org.mybatis.caches.ehcache.EhcacheCache" />
e>加入 logback 日志
存在 SLF4J 时,作为简易日志的 log4j 将失效,此时我们需要借助 SLF4J 的具体实现 logback 来打印日志。创建 logback 的配置文件logback.xml
,名字固定,不可改变
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 <?xml version="1.0" encoding="UTF-8" ?> <configuration debug ="true" > <appender name ="STDOUT" class ="ch.qos.logback.core.ConsoleAppender" > <encoder > <pattern > [%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern > </encoder > </appender > <root level ="DEBUG" > <appender-ref ref ="STDOUT" /> </root > <logger name ="com.atguigu.crowd.mapper" level ="DEBUG" /> </configuration >
f>EHCache 配置文件说明
属性名
是否必须
作用
maxElementsInMemory
是
在内存中缓存的 element 的最大数目
maxElementsOnDisk
是
在磁盘上缓存的 element 的最大数目,若是 0 表示无穷大
eternal
是
设定缓存的 elements 是否永远不过期。 如果为 true,则缓存的数据始终有效, 如果为 false 那么还要根据 timeToIdleSeconds、timeToLiveSeconds 判断
overflowToDisk
是
设定当内存缓存溢出的时候是否将过期的 element 缓存到磁盘上
timeToIdleSeconds
否
当缓存在 EhCache 中的数据前后两次访问的时间超过 timeToIdleSeconds 的属性取值时, 这些数据便会删除,默认值是 0,也就是可闲置时间无穷大
timeToLiveSeconds
否
缓存 element 的有效生命期,默认是 0.,也就是 element 存活时间无穷大
diskSpoolBufferSizeMB
否
DiskStore(磁盘缓存)的缓存区大小。默认是 30MB。每个 Cache 都应该有自己的一个缓冲区
diskPersistent
否
在 VM 重启的时候是否启用磁盘保存 EhCache 中的数据,默认是 false
diskExpiryThreadIntervalSeconds
否
磁盘缓存的清理线程运行间隔,默认是 120 秒。每个 120s, 相应的线程会进行一次 EhCache 中数据的清理工作
memoryStoreEvictionPolicy
否
当内存缓存达到最大,有新的 element 加入的时候, 移除缓存中 element 的策略。 默认是 LRU(最近最少使用),可选的有 LFU(最不常使用)和 FIFO(先进先出
十一、MyBatis 的逆向工程
正向工程:先创建 Java 实体类,由框架负责根据实体类生成数据库表。Hibernate 是支持正向工程的
逆向工程:先创建数据库表,由框架负责根据数据库表,反向生成如下资源:
Java 实体类
Mapper 接口
Mapper 映射文件
1、创建逆向工程的步骤 a>添加依赖和插件 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 <dependencies > <dependency > <groupId > org.mybatis</groupId > <artifactId > mybatis</artifactId > <version > 3.5.9</version > </dependency > <dependency > <groupId > junit</groupId > <artifactId > junit</artifactId > <version > 4.13.2</version > <scope > test</scope > </dependency > <dependency > <groupId > mysql</groupId > <artifactId > mysql-connector-java</artifactId > <version > 5.1.3</version > </dependency > <dependency > <groupId > log4j</groupId > <artifactId > log4j</artifactId > <version > 1.2.17</version > </dependency > </dependencies > <build > <plugins > <plugin > <groupId > org.mybatis.generator</groupId > <artifactId > mybatis-generator-maven-plugin</artifactId > <version > 1.3.0</version > <dependencies > <dependency > <groupId > org.mybatis.generator</groupId > <artifactId > mybatis-generator-core</artifactId > <version > 1.3.2</version > </dependency > <dependency > <groupId > com.mchange</groupId > <artifactId > c3p0</artifactId > <version > 0.9.2</version > </dependency > <dependency > <groupId > mysql</groupId > <artifactId > mysql-connector-java</artifactId > <version > 5.1.3</version > </dependency > </dependencies > </plugin > </plugins > </build >
b>创建 MyBatis 的核心配置文件 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 <?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" /> <typeAliases > <package name ="" /> </typeAliases > <environments default ="development" > <environment id ="development" > <transactionManager type ="JDBC" /> <dataSource type ="POOLED" > <property name ="driver" value ="${jdbc.driver}" /> <property name ="url" value ="${jdbc.url}" /> <property name ="username" value ="${jdbc.username}" /> <property name ="password" value ="${jdbc.password}" /> </dataSource > </environment > </environments > <mappers > <package name ="" /> </mappers > </configuration >
c>创建逆向工程的配置文件
文件名必须是:generatorConfig.xml
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" > <generatorConfiguration > <context id ="DB2Tables" targetRuntime ="MyBatis3" > <jdbcConnection driverClass ="com.mysql.cj.jdbc.Driver" connectionURL ="jdbc:mysql://localhost:3306/mybatis" userId ="root" password ="123456" > </jdbcConnection > <javaModelGenerator targetPackage ="com.zhang.mybatis.entity" targetProject =".\src\main\java" > <property name ="enableSubPackages" value ="true" /> <property name ="trimStrings" value ="true" /> </javaModelGenerator > <sqlMapGenerator targetPackage ="com.zhang.mybatis.mappers" targetProject =".\src\main\resources" > <property name ="enableSubPackages" value ="true" /> </sqlMapGenerator > <javaClientGenerator type ="XMLMAPPER" targetPackage ="com.zhang.mybatis.mappers" targetProject =".\src\main\java" > <property name ="enableSubPackages" value ="true" /> </javaClientGenerator > <table tableName ="t_emp" domainObjectName ="Emp" /> <table tableName ="t_dept" domainObjectName ="Dept" /> </context > </generatorConfiguration >
d>执行 MBG 插件的 generate 目标
如果出现报错:Exception getting JDBC Driver
,可能是 pom.xml 中,数据库驱动配置错误
dependency 中的驱动
mybatis-generator-maven-plugin 插件中的驱动
两者的驱动版本应该相同
执行结果
2、QBC a>查询
selectByExample
:按条件查询,需要传入一个 example 对象或者 null;如果传入一个 null,则表示没有条件,也就是查询所有数据
example.createCriteria().xxx
:创建条件对象,通过 andXXX 方法为 SQL 添加查询添加,每个条件之间是 and 关系
example.or().xxx
:将之前添加的条件通过 or 拼接其他条件
1 2 3 4 5 6 7 8 9 10 11 12 13 14 @Test public void testMBG () throws IOException { InputStream is = Resources.getResourceAsStream("mybatis-config.xml" ); SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder (); SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is); SqlSession sqlSession = sqlSessionFactory.openSession(true ); EmpMapper mapper = sqlSession.getMapper(EmpMapper.class); EmpExample example = new EmpExample (); example.createCriteria().andEmpNameEqualTo("张三" ).andAgeGreaterThanOrEqualTo(20 ); example.or().andDidIsNotNull(); List<Emp> emps = mapper.selectByExample(example); emps.forEach(System.out::println); }
b>增改
updateByPrimaryKey
:通过主键进行数据修改,如果某一个值为 null,也会将对应的字段改为 null
mapper.updateByPrimaryKey(new Emp(1,"admin",22,null,"456@qq.com",3));
updateByPrimaryKeySelective()
:通过主键进行选择性数据修改,如果某个值为 null,则不修改这个字段
mapper.updateByPrimaryKeySelective(new Emp(2,"admin2",22,null,"456@qq.com",3));
十二、分页插件 1、分页插件使用步骤 a>添加依赖 1 2 3 4 5 6 <dependency > <groupId > com.github.pagehelper</groupId > <artifactId > pagehelper</artifactId > <version > 5.2.0</version > </dependency >
b>配置分页插件
在 MyBatis 的核心配置文件(mybatis-config.xml)中配置插件
1 2 3 4 <plugins > <plugin interceptor ="com.github.pagehelper.PageInterceptor" > </plugin > </plugins >
2、分页插件的使用 a>开启分页功能
在查询功能之前使用PageHelper.startPage(int pageNum, int pageSize)
开启分页功能
pageNum:当前页的页码
pageSize:每页显示的条数
1 2 3 4 5 6 7 8 9 10 11 12 @Test public void testPageHelper () throws IOException { InputStream is = Resources.getResourceAsStream("mybatis-config.xml" ); SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder (); SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is); SqlSession sqlSession = sqlSessionFactory.openSession(true ); EmpMapper mapper = sqlSession.getMapper(EmpMapper.class); PageHelper.startPage(1 ,4 ); List<Emp> emps = mapper.selectByExample(null ); emps.forEach(System.out::println); }
b>分页相关数据 方法一:直接输出 1 2 3 4 5 6 7 8 9 10 11 12 13 14 @Test public void testPageHelper () throws IOException { InputStream is = Resources.getResourceAsStream("mybatis-config.xml" ); SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder (); SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is); SqlSession sqlSession = sqlSessionFactory.openSession(true ); EmpMapper mapper = sqlSession.getMapper(EmpMapper.class); Page<Object> page = PageHelper.startPage(1 , 4 ); List<Emp> emps = mapper.selectByExample(null ); System.out.println(page); }
1 Page{ count=true , pageNum=1 , pageSize=4 , startRow=0 , endRow=4 , total=8 , pages=2 , reasonable=false , pageSizeZero=false } [ Emp{ eid=1 , empName='admin', age=22 , sex='男', email='456 @qq.com', did=3 } , Emp{ eid=2 , empName='admin2', age=22 , sex='男', email='456 @qq.com', did=3 } , Emp{ eid=3 , empName='王五', age=12 , sex='女', email='123 @qq.com', did=3 } , Emp{ eid=4 , empName='赵六', age=32 , sex='男', email='123 @qq.com', did=1 } ]
方法二使用 PageInfo
在查询获取 list 集合之后,使用PageInfo<T> pageInfo = new PageInfo<>(List<T> list, intnavigatePages)
获取分页相关数据
list:分页之后的数据
navigatePages:导航分页的页码数 (一般是奇数)
1 2 3 4 5 6 7 8 9 10 11 12 @Test public void testPageHelper () throws IOException { InputStream is = Resources.getResourceAsStream("mybatis-config.xml" ); SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder (); SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is); SqlSession sqlSession = sqlSessionFactory.openSession(true ); EmpMapper mapper = sqlSession.getMapper(EmpMapper.class); PageHelper.startPage(1 , 4 ); List<Emp> emps = mapper.selectByExample(null ); PageInfo<Emp> page = new PageInfo <>(emps,5 ); System.out.println(page); }
1 2 3 4 PageInfo{ pageNum=1 , pageSize=4 , size=4 , startRow=1 , endRow=4 , total=8 , pages=2 , list=Page{count=true , pageNum=1 , pageSize=4 , startRow=0 , endRow=4 , total=8 , pages=2 , reasonable=false , pageSizeZero=false }[Emp{eid=1 , empName='admin' , age=22 , sex='男' , email='456@qq.com' , did=3 }, Emp{eid=2 , empName='admin2' , age=22 , sex='男' , email='456@qq.com' , did=3 }, Emp{eid=3 , empName='王五' , age=12 , sex='女' , email='123@qq.com' , did=3 }, Emp{eid=4 , empName='赵六' , age=32 , sex='男' , email='123@qq.com' , did=1 }], prePage=0 , nextPage=2 , isFirstPage=true , isLastPage=false , hasPreviousPage=false , hasNextPage=true , navigatePages=5 , navigateFirstPage=1 , navigateLastPage=2 , navigatepageNums=[1 , 2 ]}
其中 list 中的数据等同于方法一中直接输出的 page 数据
常用数据:
pageNum:当前页的页码
pageSize:每页显示的条数
size:当前页显示的真实条数
total:总记录数
pages:总页数
prePage:上一页的页码
nextPage:下一页的页码
isFirstPage/isLastPage:是否为第一页/最后一页
hasPreviousPage/hasNextPage:是否存在上一页/下一页
navigatePages:导航分页的页码数
navigatepageNums:导航分页的页码,[1,2,3,4,5]
getList : 取出存入的数据(List<Emp>
)