# MyBatis从入门到精通
# MyBatis简介
# MyBatis简介
MyBatis最初是Apach的一个开源项目iBatis,2020年6月被基金会迁移到了Google Code,iBatis3.x随后正式更名为MyBatis。
iBatis是一个基于Java的持久层框架,提供SQL Maps和Data Access Objects
# MyBatis特性
- MyBatis支持
定制化SQL
,存储过程
以及高级映射
- MyBatis避免了几乎所有的
JDBC代码
和手动设置参数以及获取结果集 - MyBatis可以使用简单的
XML
或者注解
用于配置和原始映射,将接口和Java的POJO映射为数据库的记录 - MyBatis是一个
半自动化
的ORM框架
# MyBatis和其他持久层框架的对比
- JDBC
- SQL夹杂在Java代码中
耦合度高
- SQL需求变化时,不易维护
- 代码冗长,开发效率低
- SQL夹杂在Java代码中
- Hibernate和JPA
- 操作简便,开发效率低
- 长难复杂SQL需要绕过框架
- 内部生成SQL,不容易做特殊优化
- 基于
全映射
的全自动框架,大量字段POJO进行部分映射比较困难 反射操作
太多,导致数据库性能下降
- MyBatis
- 轻量级,性能出色
- SQL和Java编码分开,功能边界清晰
- 开发效率略低于Hibernate
# MyBatis下载
# 搭建MyBatis
# 开发环境
IDE:IDEA2023.3.4
构建工具:maven3.8.6
MySQL版本:MySQL8.0
MyBatis版本:MyBatis3.5.7
# 创建Maven工程
# 引入依赖
<!-- Mybatis核心 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dependency>
<!-- junit测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- MySQL驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.12</version>
</dependency>
# Mybatis核心配置文件
习惯上命名mybatis-comfig.xml
,放在resources资源目录下
<?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.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="org/mybatis/example/BlogMapper.xml"/>
</mappers>
</configuration>
# 创建mapper接口
Mybatis的mapper接口相当于以前的dao。区别在于mapper仅仅是接口,不需要提供实现类。
package com.rong.hui.mapper;
public interface UserMapper {
// 添加用户信息
int insertUser();
}
# 创建MyBatis的映射文件
相关概念:ORM(Object Relationship Mapping)对象关系映射
1、映射文件命名规则
表所对应的实体类的类名+Mapper.xml
例如:表t_user,映射的实体类为User,所对应的映射文件为UserMapper.xml
一个映射文件对应一个实体类,对应一张表的操作
映射文件存放位置:src/main/resources/mappers目录下
2、mybatis中可以面向接口操作数据,
- mapper接口的全类名和映射文件的
命名空间
保持一致- mapper接口的方法名和映射文件中编写sql标签的
id
属性值一致
<?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="org.mybatis.example.BlogMapper">
<select id="selectBlog" resultType="Blog">
select * from Blog where id = #{id}
</select>
</mapper>
# 测试添加功能
public class MyBatisTest {
@Test
public void testMyBatis() throws IOException {
// 读取核心配置文件
InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
// 获取sqlSessionFactoryBuilder
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
// 通过核心配置文件所对应的字节流创建工厂类对象SqlSessionFactory,生产sqlSession对象
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(resourceAsStream);
// 获取sqlSession对象,此时sqlSession操作的sql语句必须手动提交或回滚事务
// SqlSession sqlSession = sqlSessionFactory.openSession();
// 获取sqlSession对象,此时sqlSession操作的sql语句会自动提交
SqlSession sqlSession = sqlSessionFactory.openSession(true);
// 获取mapper接口对象
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
// 测试功能
int result = mapper.insertUser();
// 提交事务
// sqlSession.commit();
System.out.println("result:"+result);
}
}
注意:sqlSession默认不自动提交事务,如果需要自动提交事务,
需要设置SqlSession sqlSession = sqlSessionFactory.openSession(true);
# 加入log4j日志功能
- 引入依赖
<!-- log4j日志 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
- 加入log4j的配置文件log4j.xml,位置为src/main/resources/log4j.xml
日志的级别:从上到下内容越来越详细
- FATAL(致命):程序出现严重错误,可能导致程序崩溃或无法运行
- ERROR(错误):程序出现错误,仍在尝试执行任务
- WARN(警告):存在警告,但程序仍在按预期运行
- INFO(信息):正常的操作和状态信息,相对
简洁
,不包含细节- DEBUG(调试) :输出内容非常
详细
,对程序性能产生一定影响通常DEBUG在
测试开发
阶段使用,帮助开发者了解程序运行细节,而ERROR和FATAL只在生产环境
使用,用于确保系统稳定运行
通用模板
<?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>
# MyBatis增删改查
<mapper namespace="com.rong.hui.mapper.UserMapper">
<insert id="insertUser">
insert into t_user values(null,'admin','123456',23,'男','12345@qq.com')
</insert>
<!---->
<update id="updateUser">
update t_user set username = '张三' where id = 4;
</update>
<delete id="deleteUser">
delete from t_user where id = 5
</delete>
<select id="getUserById" resultType="com.rong.hui.pojo.User">
select * from t_user where id = 3;
</select>
</mapper>
注意:
- 查询标签的select必须设置属性resultType或resultType
- resultType:自动映射,用于属性名和表中字段一致的情况
- resultType:自定义映射,用于一对多或多对一或字段名和属性名不一致的情况
- 当查询数据为多条时,不能使用实体类作为返回值,只能使用集合
# MyBatis核心配置文件详解
<?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>
<!--MyBatis核心配置文件标签顺序,没有可以不写,顺序不能乱
properties、settings、typeAliases、typeHandlers、objectFactory、objectWrapperFactory、
reflectorFactory、plugins、environments、databaseIdProvider、mappers
-->
<!--引入properties文件,并使用${属性名}方式获取变量-->
<properties resource="jdbc.properties"/>
<!--设置类型标签-->
<typeAliases>
<!--type为全限定类名,alias为别名,使用的时候不区分大小写,如果不写,默认就是类名User-->
<!--<typeAlias type="com.rong.hui.pojo.User" alias="User"></typeAlias>-->
<!--以包为单位,将包下所有类型设置默认的类型别名,即类名且不区分大小写-->
<package name="com.rong.hui.pojo"></package>
</typeAliases>
<!--配置多个连接数据库的环境,default设置默认环境的id-->
<environments default="development">
<!--id不能重复-->
<environment id="development">
<!--设置事务管理方式:type="JDBC|MANAGED"
JDBC:表示操作SQL时,事务的提交和回滚需要手动处理
MANAGED:表示被管理,例如Spring
-->
<transactionManager type="JDBC"/>
<!--配置数据源使用连接池:type="POOLED|UNPOOLED|JNDI"
POOLED:表示使用数据库连接池缓存数据库连接
UNPOOLED:表示不使用数据库连接池
JNDI:表示使用上下文中的数据源
-->
<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>
<!--<mapper resource="mapper/UserMapper.xml"/>-->
<!--以包为单位,将包下所有映射文件引入核心配置文件
注意:
1.mapper接口所在的包要和映射文件所在的包一致,src/main/java和 src/main/resources下的包名要一样
2.mapper接口要和映射文件名字一致,UserMapper.java UserMapper.xml
-->
<package name="com.rong.hui.mapper"></package>
</mappers>
</configuration>
jdbc.properties文件
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&serverTimezone=UTC
jdbc.username=root
jdbc.password=123456
# MyBatis获取参数值的两种方式
两种方式:
${}
本质是字符串拼接#{}
本质是占位符赋值
# 单个字面量类型的参数
mapper接口方法的参数为单个,可以使用${}和#{}以任意的名称获取参数值,但是需要注意${}的单引号问题
<select id="GetUserByUsername" resultType="User">
select * from t_user where username = #{username}
</select>
<select id="GetUserByUsername" resultType="User">
select * from t_user where username = '${username}'
</select>
# 多个字面量类型的参数
mapper接口方法的参数为多个,mybatis底层会把若干个参数放在一个map集合中,以两种方式存储:
- 以
arg0,arg1
为键,以参数为值 - 以
param1,param2
为键,以参数为值
<select id="checkLogin" resultType="User">
select * from t_user where username = #{arg0} and password = #{arg1}
</select>
<select id="checkLogin" resultType="User">
select * from t_user where username = '${param1}' and password = '${param2}'
</select>
# map集合类型的参数
mapper接口方法的参数为多个,可手动将多个参数放在map中
@Test
public void testCheckLoginByMap(){
SqlSession sqlSession = SqlSessionUtils.getSqlSession();
ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
Map<String, Object> map = new HashMap<>();
map.put("username","张三");
map.put("password","123456");
User user = mapper.checkLoginByMap(map);
System.out.println(user);
}
<select id="checkLoginByMap" resultType="User">
select * from t_user where username = #{username} and password = #{password}
</select>
# 实体类型的参数
通过实体类对象中的属性名获取属性值
<insert id="insertUser" >
insert into t_user values(null,#{username},#{password},#{age},#{sex},#{email})
</insert>
@Test
public void testInsertUser(){
SqlSession sqlSession = SqlSessionUtils.getSqlSession();
ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
mapper.insertUser(new User(null,"huyadish","12345678",26,"男","123456@qq.com"));
}
# 使用@Param标识参数
- mapper接口
User checkLoginByParam(@Param("username") String username, @Param("password") String password);
- 测试
@Test
public void testCheckLoginByParam(){
SqlSession sqlSession = SqlSessionUtils.getSqlSession();
ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
User user = mapper.checkLoginByParam("张三", "123456");
}
注意:
- 有多个字面量参数的情况,不能直接用属性名访问
- @Param方式可以通过属性名访问,也可以通过param1,param2访问
- 实体类型、map类型必须用属性名访问
推荐使用@Param和实体方式
# Mybatis的各种查询功能
# 查询一个实体类对象
// 通过实体类对象接收
User getUserById(@Param("id") Integer id);
// 通过实体数组接收
List<User> getUserById(@Param("id") Integer id);
# 查询一个List集合
// 通过实体数组接收
List<User> getAllUser();
# 查询单个数据
// 查询单个数据
Integer getCount();
用Integer接收
// 这里resultType可以写Integer、integer、Int、int都可以
<select id="getCount" resultType="java.lang.Integer">
select count(*) from t_user
</select>
注:mybatis为基本数据类型设置了类型别名,且不区分大小写
# 查询一条数据为map集合
<select id="getUserByIdToMap" resultType="java.util.Map">
select * from t_user where id = #{id}
</select>
// 使用map对象接收单条数据
Map<String,Object> getUserByIdToMap(@Param("id") Integer id);
注:多表查询的结果可以用map接收
# 查询多条数据为map集合
// 通过map的List接收多条数据
List<Map<String,Object>> getAllUserToMap();
// 通过map接收多条数据,但是要指定mapkey为哪个字段
@MapKey("id")
Map<String,Object> getAllUserToMap();
# 特殊SQL的执行
# 模糊查询
<select id="getUserByLike" resultType="com.rong.hui.pojo.User">
// 使用${}拼接字符串
select * from t_user where username like '%${username}%'
// 使用concat函数
select * from t_user where username like concat('%',#{username},'%')
// 使用#{}占位符
select * from t_user where username like '%'#{username}'%'
</select>
# 批量删除
// 传入类似于"1,2,3"的ids字符串
int deleteBatch(@Param("ids") String ids);
<delete id="deleteBatch">
delete from t_user where id in (${ids})
</delete>
注:批量删除使用
${}
# 动态设置表名
// 表名作为参数输入
List<User> getUserByTableName(@Param("tableName") String tableName);
<select id="getUserByTableName" resultType="User">
select * from ${tableName}
</select>
注:动态设置表名使用
${}
# 添加功能获取自动递增主键
// 添加用户信息
void insertUser(User user);
// 使用自动生成的主键,并且自增的主键将字放在参数的id属性中
<insert id="insertUser" useGeneratedKeys="true" keyProperty="id" >
insert into t_user values (null,#{username},#{password},#{age},#{sex},#{email})
</insert>
@Test
public void testInsertUser(){
SqlSession sqlSession = SqlSessionUtils.getSqlSession();
SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
User user = new User(null, "李四", "12345", 23, "男", "test@qq.com");
// 添加用户后新增的id会存放在user对象中
mapper.insertUser(user);
System.out.println(user);
}
注:insert、update、delete返回的结果都是收影响的行数,得用特殊的方法返回自增的主键
# 自定义映射resultMap
# 处理映射关系
解决字段名和属性名不一致的情况:
- 为字段起别名,保持和属性名一致
<select id="getAllEmp" resultType="com.rong.hui.pojo.Emp">
select eid,emp_name,age,sex,email from t_emp
</select>
- 全局配置下划线转驼峰
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"></setting>
- 通过resultmap设置自定义映射关系
// id属性为唯一标识,不能重复, type设置映射关系中的实体类类型
<resultMap id="empResultMap" type="Emp">
// id设置主键映射关系 property设置实体属性,column设置字段名
<id property="eid" column="eid"></id>
// result设置其他属性映射关系
<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>
注意:
- 如果只是解决字段名不一致问题,只需要全局开启
mapUnderscoreToCamelCase
就行resultMap
强大的地方在于可以处理一对多和多对一映射
# 多对一映射
# 使用级联属性
<!--多对一映射方式一,级联属性赋值-->
<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>
# 使用association
<!--多对一映射方式一,使用association-->
<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>
# 分步查询
在resultMap中定义分步查询
<!--多对一映射方式三,使用分步查询-->
<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>
<!--select是分布查询第二步方法的全限定名,column是关联的列-->
<association property="dept"
select="com.rong.hui.mapper.DeptMapper.getEmpAndDeptByStepTwo"
column="eid">
</association>
</resultMap>
第一步:先查emp
<select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap">
select * from t_emp where eid = #{eid}
</select>
第二步:再查关联的dept
<select id="getEmpAndDeptByStepTwo" resultType="Dept">
select * from t_dept where did = #{did}
</select>
# 延迟加载
使用分步查询的好处?
- 可以实现延迟加载,需要设置配置信息:
- lazyLoadingEnabled:延迟加载的全局开关。
默认开启
。当开启时,所有关联对象都会延迟加载- aggressiveLazyLoading:当开启时,任何方法调用都会加载该对象的所有属性(包含关联属性),
默认关闭
1、开启懒加载的情况:
<settings>
<!--开启延迟加载-->
<setting name="lazyLoadingEnabled" value="true"></setting>
</settings>
测试类:
@Test
public void testEmpAndDeptByStep(){
SqlSession sqlSession = SqlSessionUtils.getSqlSession();
EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
Emp emp = mapper.getEmpAndDeptByStepOne(3);
// 访问了某个属性才会去执行
System.out.println(emp.getEmpName());
System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++");
System.out.println(emp.getDept());
}
输出日志:
DEBUG 06-28 15:15:53,434 ==> Preparing: select * from t_emp where eid = ? (BaseJdbcLogger.java:137)
DEBUG 06-28 15:15:53,463 ==> Parameters: 3(Integer) (BaseJdbcLogger.java:137)
DEBUG 06-28 15:15:53,519 <== Total: 1 (BaseJdbcLogger.java:137)
王五
+++++++++++++++++++++++++++++++++++++++++++++++
DEBUG 06-28 15:15:53,521 ==> Preparing: select * from t_dept where did = ? (BaseJdbcLogger.java:137)
DEBUG 06-28 15:15:53,521 ==> Parameters: 3(Integer) (BaseJdbcLogger.java:137)
DEBUG 06-28 15:15:53,523 <== Total: 1 (BaseJdbcLogger.java:137)
Dept{did=3, deptName='C'}
可以看到员工表查询Sql和部门表查询sql是分步执行
的
2、未开启懒加载的情况
DEBUG 06-28 15:19:12,462 ==> Preparing: select * from t_emp where eid = ? (BaseJdbcLogger.java:137)
DEBUG 06-28 15:19:12,484 ==> Parameters: 3(Integer) (BaseJdbcLogger.java:137)
DEBUG 06-28 15:19:12,506 ====> Preparing: select * from t_dept where did = ? (BaseJdbcLogger.java:137)
DEBUG 06-28 15:19:12,506 ====> Parameters: 3(Integer) (BaseJdbcLogger.java:137)
DEBUG 06-28 15:19:12,508 <==== Total: 1 (BaseJdbcLogger.java:137)
DEBUG 06-28 15:19:12,509 <== Total: 1 (BaseJdbcLogger.java:137)
王五
+++++++++++++++++++++++++++++++++++++++++++++++
Dept{did=3, deptName='C'}
可以看到SQL语句是一起执行
的
<association property="dept"
select="com.rong.hui.mapper.DeptMapper.getEmpAndDeptByStepTwo"
column="eid"
fetchType="eager"
>
</association>
注意:可在association中设置fetchType属性控制当前查询是否需要延迟加载,可选值为eager或lazy,可以精细化控制延迟加载
# 一对多映射
# 使用collection标签
Dept实体属性
private List<Emp> emps;
mapper映射文件
<resultMap id="deptAndEmpResultMap" type="Dept">
<id property="did" column="did"></id>
<result property="deptName" column="dept_name"></result>
<!--这里property是实体属性,ofType是集合中存放的实体属性-->
<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>
测试
@Test
public void testGetDeptAndEmp(){
SqlSession sqlSession = SqlSessionUtils.getSqlSession();
DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
Dept dept = mapper.getDeptAndEmp(2);
System.out.println(dept);
}
输出日志:
DEBUG 06-28 15:40:49,685 ==> Preparing: select * from t_dept left join t_emp on t_dept.did = t_emp.did where t_dept.did = ? (BaseJdbcLogger.java:137)
DEBUG 06-28 15:40:49,705 ==> Parameters: 2(Integer) (BaseJdbcLogger.java:137)
DEBUG 06-28 15:40:49,723 <== Total: 2 (BaseJdbcLogger.java:137)
Dept{did=2, deptName='B', emps=[Emp{eid=2, empName='李四', age=32, sex='男', email='12345@qq.com', dept=null}, Emp{eid=4, empName='赵六', age=23, sex='女', email='12345@qq.com', dept=null}]}
可以看到emps属性中存放了两条员工信息
# 分步查询
使用collection配置一对多分步查询
<resultMap id="deptAndEmpResultMapByStep" type="Dept">
<id property="did" column="did"></id>
<result property="deptName" column="dept_name"></result>
<!--这里property是实体属性,ofType是集合中存放的实体属性,select是分步查询的sql,column是关联的列-->
<collection property="emps" select="com.rong.hui.mapper.EmpMapper.getDeptAndEmpByStepTwo" column="did" ofType="Emp"></collection>
</resultMap>
输出日志
DEBUG 06-28 15:57:09,588 ==> Preparing: select * from t_dept where t_dept.did = ? (BaseJdbcLogger.java:137)
DEBUG 06-28 15:57:09,612 ==> Parameters: 2(Integer) (BaseJdbcLogger.java:137)
DEBUG 06-28 15:57:09,664 <== Total: 1 (BaseJdbcLogger.java:137)
DEBUG 06-28 15:57:09,667 ==> Preparing: select * from t_emp where did = ? (BaseJdbcLogger.java:137)
DEBUG 06-28 15:57:09,668 ==> Parameters: 2(Integer) (BaseJdbcLogger.java:137)
DEBUG 06-28 15:57:09,670 <== Total: 2 (BaseJdbcLogger.java:137)
Dept{did=2, deptName='B', emps=[Emp{eid=2, empName='李四', age=32, sex='男', email='12345@qq.com', dept=null}, Emp{eid=4, empName='赵六', age=23, sex='女', email='12345@qq.com', dept=null}]}
可以看到先执行部门表的查询、再执行与部门关联的员工表的查询
总结:
- association用于处理多对一映射,并且支持分步查询
- collection用于处理一对多的情况,并且支持分步查询
- 分步查询需要在实体对象中添加关联的属性
- 懒加载需要开启全局配置
# 动态SQL
# if
作用:根据test属性表达式决定标签中内容是否要拼接到SQL中
<select id="getEmpByCondition" resultType="Emp">
select * from t_emp where 1=1
<if test="empName != null and empName != ''">
and emp_name = #{empName}
</if>
<if test="age != null and age != ''">
and age = #{age}
</if>
<if test="sex != null and sex != ''">
and sex = #{sex}
</if>
</select>
# where
作用:
- 当where标签中有内容时,自动生成where关键字,并且将内容前面多余的and或or去掉,
- 当where标签中没有内容是,不会生成where关键字
注意:where不能去除内容后面多余的and或or
<select id="getEmpByConditionOne" resultType="Emp">
select * from t_emp
<where>
<if test="empName != null and empName != ''">
and emp_name = #{empName}
</if>
<if test="age != null and age != ''">
and age = #{age}
</if>
<if test="sex != null and sex != ''">
sex = #{sex}
</if>
</where>
</select>
# trim
作用:
- prefix|suffix:为trim标签中内容前面或后面添加指定内容,
- prefixOverrides|suffixOverrides:为trim标签中内容前面或后面去掉指定内容
- 当标签没有内容时,trim没有任何效果
<select id="getEmpByConditionTwo" resultType="Emp">
select * from t_emp
<trim prefix="where" suffix="" prefixOverrides="" suffixOverrides="and|or">
<if test="empName != null and empName != ''">
emp_name = #{empName} and
</if>
<if test="age != null and age != ''">
age = #{age} or
</if>
<if test="sex != null and sex != ''">
sex = #{sex}
</if>
</trim>
</select>
# choose、when、otherwise
作用:从若干条件中选择一项拼接到SQL,并且可以指定默认条件,类似于switch语句
<select id="getEmpByConditionThree" 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>
<otherwise> did = 1</otherwise>
</choose>
</where>
</select>
# foreach
# 批量删除
作用:可用于批量操作
属性:collection为需要循环的数组或集合,item为数组或集合中的每个数据,separator分隔符,open|close是对整个循环结果添加符合
int batchDeleteByArray(@Param("eids") Integer[] eids);
<delete id="batchDeleteByArray">
delete from t_emp where eid in
<foreach collection="eids" item="eid" separator="," open="(" close=")">
#{eid}
</foreach>
</delete>
或者可以简写为
<delete id="batchDeleteByArray">
delete from t_emp
<where>
<foreach collection="eids" item="eid" separator="or">
eid = #{eid}
</foreach>
</where>
</delete>
# 批量添加
int batchInsertByList(@Param("emps") List<Emp> emps);
<insert id="batchInsertByList">
insert into t_emp values
<foreach collection="emps" item="emp" separator=",">
(null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},null)
</foreach>
</insert>
# SQL片段
<sql id="empColumns">eid,emp_name,age,sex,email</sql>
<include refid="empColumns"></include>
# MyBatis缓存
# MyBatis的一级缓存
一级缓存是SqlSession
级别的,默认开启
,通过同一个SqlSession查询的数据会被缓存,下次查询相同数据,就会从缓存中直接获取,不会从数据库访问。
一级缓存失效的四个条件:
- 不同的sqlSession对应不同的一级缓存
- 同一个sqlSession但是查询条件不同
- 同一个sqlSession两次查询期间执行了任何一次增删改操作
- 同一个sqlSession两次查询期间手动清空了缓存
@Test
public void testCache(){
SqlSession sqlSession1 = SqlSessionUtils.getSqlSession();
CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
Emp emp1 = mapper1.getEmpByID(1);
System.out.println(emp1);
// 相同的sqlSession查询的数据会被缓存,这里的sql不会执行
CacheMapper mapper2 = sqlSession1.getMapper(CacheMapper.class);
Emp emp2 = mapper2.getEmpByID(1);
System.out.println(emp2);
// 重新获取sqlSession,那么相同的查询是不会被缓存的,这里的sql会执行
SqlSession sqlSession2 = SqlSessionUtils.getSqlSession();
CacheMapper mapper3 = sqlSession2.getMapper((CacheMapper.class));
Emp emp3 = mapper3.getEmpByID(1);
System.out.println(emp3);
}
# MyBatis的二级缓存
二级缓存是SqlSessionFactory级别的,通过SqlSessionFactory创建的SqlSession查询的结果会被缓存
二级缓存开启的条件:
- 核心配置文件中配置
cacheEnabled
="true",默认为true,不用设置 - 映射文件中设置
cache
标签 - 二级缓存必须在SqlSession
关闭或提交
后有效 - 查询数据转换的实体类类型必须实现
序列化接口
二级缓存失效的条件:
- 两次查询之间进行了任意的增删改
测试方法
@Test
public void testTwoCache(){
try {
InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
Emp emp1 = mapper1.getEmpByID(1);
System.out.println(emp1);
sqlSession1.close();
// 同一个sqlSessionFactory创建出的sqlSession,查询结果会被缓存
SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
Emp emp2 = mapper2.getEmpByID(1);
System.out.println(emp2);
sqlSession2.close();
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
输出结果
DEBUG 07-02 11:03:05,705 Cache Hit Ratio [com.rong.hui.mapper.CacheMapper]: 0.0 (LoggingCache.java:60)
DEBUG 07-02 11:03:05,838 ==> Preparing: select * from t_emp where eid=? (BaseJdbcLogger.java:137)
DEBUG 07-02 11:03:05,859 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:137)
DEBUG 07-02 11:03:05,878 <== Total: 1 (BaseJdbcLogger.java:137)
Emp{eid=1, empName='张三', age=23, sex='男', email='12345@qq.com', dept=null}
DEBUG 07-02 11:03:05,900 Cache Hit Ratio [com.rong.hui.mapper.CacheMapper]: 0.5 (LoggingCache.java:60)
Emp{eid=1, empName='张三', age=23, sex='男', email='12345@qq.com', dept=null}
可以看到执行了一次查询,并且显示缓存命中率
# 二级缓存相关配置
cache标签可以设置一些属性
- eviction:缓存回收策略
- LRU:最近最少使用的,移除长时间不使用的对象
- FIFO:先进先出:按对象进入缓存的顺序来移除它们
- SOFT:软引用:基于垃圾回收器状态和软引用规则移除对象
- WEAK:弱引用:更积极地基于垃圾收集器状态和弱引用规则移除对象
- flushInterval:刷新间隔,正整数,单位毫秒
- 默认没有刷新间隔,调用增删改语句时刷新
- size:引用数目,正整数,代表最多可以缓存多少个对象,默认
1024
- readOnly:只读,true/false
- true就是共享缓存实例,不能修改
- false就是返回缓存对象的拷贝,会慢一些
# 缓存查询顺序
- 先查二级缓存
- 如果二级缓存没有,查询一级缓存
- 如果一级缓存也没有,再查数据库
- SqlSession关闭后,一级缓存的数据会写入二级缓存
# 整合第三方缓存EHCache
# 添加依赖
<!-- Mybatis EHCache整合包 -->
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.2.1</version>
</dependency>
<!-- slf4j日志门面的一个具体实现 -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>
# Jar包功能
jar包名称 | 作用 |
---|---|
mybatis-ehcache | Mybatis和EHCache的整合包 |
ehcache | EHCache核心包 |
slf4j-api | SLF4J日志门面包 |
logback-classic | 支持SLF4J门面接口的一个具体实现 |
# 配置文件
名字必须叫ehcache.xml
<?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>
# 设置二级缓存类型
在xxxMapper.xml文件中设置二级缓存类型
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
# 加入logback日志
存在SLF4J时,作为简易日志的log4j将失效,此时我们需要借助SLF4J的具体实现logback来打印日志。创建logback的配置文件logback.xml
<?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>
<!-- 设置全局日志级别。日志级别按顺序分别是:DEBUG、INFO、WARN、ERROR -->
<!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
<root level="DEBUG">
<!-- 指定打印日志的appender,这里通过“STDOUT”引用了前面配置的appender -->
<appender-ref ref="STDOUT" />
</root>
<!-- 根据特殊需求指定局部日志级别 -->
<logger name="com.atguigu.crowd.mapper" level="DEBUG"/>
</configuration>
# EHCache配置文件说明
- maxElementsInMemory:内存中缓存元素的最大数量
- maxElementsOnDisk:磁盘上缓存的元素最大数量,默认0表示无限大
- eternal:true表示永不过期
- overflowToDisk:true表示内存溢出时将过期元素缓存到磁盘
- timeToIdleSeconds:可选,前后两次访问时间间隔,超出数据会删除,默认0表示无限大
- timeToLiveSeconds:可选,缓存元素的有效生命周期,默认0表示无限大
- diskSpoolBufferSizeMB:可选,磁盘缓存区大小,默认30Mb
- diskPersistent:可选,VM重启时是否启用缓存中数据,默认false
- diskExpiryThreadIntervalSeconds:可选,磁盘缓存的清理线程运行间隔,默认是120秒。
- memoryStoreEvictionPolicy:当内存缓存达到最大,有新的元素加入的时候, 移除缓存中element的策略。 默认是LRU(最近最少使用),可选的有LFU(最不常使用)和FIFO(先进先出
# MyBatis逆向工程
- 正向工程:先创建Java类,由框架负责生成数据库表。Hibernate支持正向工程
- 逆向工程:先创建数据库表,由框架负责根据数据库表,反向生成Java实体类,Mapper接口,Mapper映射文件
# 逆向工程步骤
# 添加依赖和插件
<dependencies>
<!-- MyBatis核心依赖包 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.9</version>
</dependency>
<!-- junit测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
<!-- MySQL驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.27</version>
</dependency>
<!-- log4j日志 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
<!-- 控制Maven在构建过程中相关配置 -->
<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>
<!-- MySQL驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.27</version>
</dependency>
</dependencies>
</plugin>
</plugins>
</build>
# 创建MyBatis核心配置文件
<?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>
# 创建逆向工程配置文件
文件名必须是:generatorConfig.xml
<?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>
<!--
targetRuntime: 执行生成的逆向工程的版本
MyBatis3Simple: 生成基本的CRUD(清新简洁版)
MyBatis3: 生成带条件的CRUD(奢华尊享版)
-->
<context id="DB2Tables" targetRuntime="MyBatis3Simple">
<!-- 数据库的连接信息 -->
<jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/mybatis"
userId="root"
password="123456">
</jdbcConnection>
<!-- javaBean的生成策略-->
<javaModelGenerator targetPackage="com.rong.hui.pojo" targetProject=".\src\main\java">
<property name="enableSubPackages" value="true" />
<property name="trimStrings" value="true" />
</javaModelGenerator>
<!-- SQL映射文件的生成策略 -->
<sqlMapGenerator targetPackage="com.rong.hui.mapper"
targetProject=".\src\main\resources">
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>
<!-- Mapper接口的生成策略 -->
<javaClientGenerator type="XMLMAPPER"
targetPackage="com.rong.hui.mapper" targetProject=".\src\main\java">
<property name="enableSubPackages" value="true" />
</javaClientGenerator>
<!-- 逆向分析的表 -->
<!-- tableName设置为*号,可以对应所有表,此时不写domainObjectName -->
<!-- domainObjectName属性指定生成出来的实体类的类名 -->
<table tableName="t_emp" domainObjectName="Emp"/>
<table tableName="t_dept" domainObjectName="Dept"/>
</context>
</generatorConfiguration>
# 执行MBG插件的generate目标
1、双击运行插件
生成如下文件:包括实体类、实体类对应的查询条件类、mapper接口、mapper映射文件
Mysql时区不一致导致的问题
解决The server time zone value ‘Öйú±ê׼ʱ¼ä‘ is unrecognized or represents more than one time zone问题
在mysql中执行语句:
set global time_zone='+8:00'
# QBC风格
Mybatis Generator简称MBG,是一个专门为Mybatis框架使用者定制的代码生成器,可以快速根据表生成对应的映射文件,接口及Bean类。
QBC(Query by Criteria,按条件查询)是一种面向对象的查询方式,支持以函数API方式动态设置查询条件,组成查询语句。
# 查询
@Test
public void testMBG(){
try {
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
SqlSession sqlSession = sqlSessionFactory.openSession(true);
EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
// 查询所有数据
List<Emp> list = mapper.selectByExample(null);
list.forEach(emp -> System.out.println(emp));
// 根据条件查询,需要构造一个条件对象
EmpExample example = new EmpExample();
// 查询员工名称为张三,并且年龄大于20
example.createCriteria().andEmpNameEqualTo("张三").andAgeGreaterThan(20);
// example.or()方法将之前条件与之后条件拼接
example.or().andDidIsNotNull();
List<Emp> list1 = mapper.selectByExample(example);
list1.forEach(emp -> System.out.println(emp));
// 根据主键更新
mapper.updateByPrimaryKey(new Emp(1,"admin",22,null,"test@163.com",3));
// 选择性修改,如果属性值为null,则会忽略这个属性值的更新
mapper.updateByPrimaryKeySelective(new Emp(1,"admin",23,null,"test@163.com",3));
// 添加
mapper.insert(new Emp(null,"admin",24,null,"test@163.com",3));
// 删除
EmpExample example1 = new EmpExample();
example1.createCriteria().andEmpNameEqualTo("张三");
mapper.deleteByExample(example1);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
# 分页插件
# 分页插件使用步骤
# 添加依赖
pom.xml中添加
<!--分页插件-->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.2.0</version>
</dependency>
# 配置分页插件
mybatis-config.xml中添加
<plugins>
<!--设置分页插件-->
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
# 分页插件使用
# 开启分页功能
在查询功能之前开启分页
@Test
public void testPageHelper(){
try {
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
SqlSession sqlSession = sqlSessionFactory.openSession(true);
EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
// 第一个参数pageNum当前页数,第二个参数pageSize每页显示的条数
PageHelper.startPage(2,4);
List<Emp> list = mapper.selectByExample(null);
list.forEach(emp-> System.out.println(emp));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
# 分页相关数据
1、在查询之前使用Page对象
Page<Object> page = PageHelper.startPage(2, 4);
System.out.println(page);
List<Emp> list = mapper.selectByExample(null);
控制台输出分页基本数据
Page{count=true, pageNum=2, pageSize=4, startRow=4, endRow=8, total=0, pages=0, reasonable=null, pageSizeZero=null}[]
2、在查询之后使用PageInfo
List<Emp> list = mapper.selectByExample(null);
// 第一个参数为查询到的数据,第二个参数navigatePages为导航分页的页数
PageInfo<Emp> pageInfo = new PageInfo<>(list, 5);
System.out.println(pageInfo);
控制台输出分页详细数据:前一页页面,后一页页码,是否第一页,是否最后一页,是否有前一页,是否有后一页等等
PageInfo{
pageNum=2, pageSize=4, size=4, startRow=5, endRow=8, total=10, pages=3,
prePage=1, nextPage=3, isFirstPage=false, isLastPage=false, hasPreviousPage=true, hasNextPage=true, navigatePages=5, navigateFirstPage=1, navigateLastPage=3, navigatepageNums=[1, 2, 3]}
3、常用数据
- pageNum:当前页的页码
- pageSize:每页显示的条数
- size:当前页显示的真实条数
- total:总记录数
- pages:总页数
- prePage:上一页的页码
- nextPage:下一页的页码
- isFirstPage/isLastPage:是否为第一页/最后一页
- hasPreviousPage/hasNextPage:是否存在上一页/下一页
- navigatePages:导航分页的页码数
- navigatepageNums:导航分页的页码,[1,2,3,4,5]