Mybatis
MyBatis 介绍
- MyBatis 支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架
- MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
- MyBatis 可以使用简单的 xml 或注解用于配置 和原始映射,将接口和 java 的 POJO 映射成数据库中的记录
- MyBatis 是一个半自动的 ORM (Object Relation Mapping) 框架
和其他持久层技术对比
-
JDBC
- SQL 夹杂在 Java 代码中耦合度高,导致硬编码内伤
- 维护不易且实际开发需求中 SQL 有变化,频繁修改的情况多见
- 代码冗长,开发效率低
-
Hibernate 和 JPA
- 操作简单,开发效率高
- 程序中的长难复杂 SQL 需要绕过框架
- 内部自动生产的 SQL,不容易做特殊化
- 基于全映射的自动框架,大量字段的 POJO 进行部分映射时比较困难
- 反射操作太多,导致数据库性能下降
-
MyBatis
- 轻量级,性能出色
- SQL 和 Java 编码分开,功能界面清晰。Java 代码专注业务、SQL 语句专注数据
- 开发效率稍逊与 Hibernate,但是完全能够接受
搭建 MyBatis
1.创建Maven工程并导入依赖
<dependencies>
<!--MyBatis依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.13</version>
</dependency>
<!--junit5单元测试-->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.9.2</version>
</dependency>
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
<!--log4j2依赖-->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.20.0</version>
</dependency>
</dependencies>
2.创建MyBatis核心配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--引入jdbc的properties文件,引入后可以使用${key}的方式范围value-->
<properties resource="jdbc.properties"/>
<!--
typeAliases 设置类型别名,即为某个具体的类型设置一个别名(标签需要放到properties之后)
设置之后,在MyBatis的范围中,就可以使用别名表示一个具体的类型
-->
<typeAliases>
<!--
typeAlias: 设置一个具体类型的别名
type: 设置需要起别名的类型的全限定类名
alias: 设置该类型的别名。如果不设置alias属性,当前的类型有默认的别名,默认值为类名且不区分大小写。
-->
<!-- <typeAlias type="cn.test.mybatis.pojo.User" alias="abc"/>-->
<!-- <typeAlias type="cn.test.mybatis.pojo.User"/>-->
<!--通过包来设置别名,指定包下的所有类型全部拥有默认的别名,即类名且不区分大小写-->
<package name="cn.test.mybatis.pojo"/>
</typeAliases>
<!--
environments 配置连接数据库的环境
default: 默认使用的环境
-->
<environments default="development">
<!--
environment: 设置一个具体的连接数据库环境
id: 设置环境的唯一标识,不能重复
-->
<environment id="development">
<!--
transactionManager: 设置事务管理器
type: 设置事务管理的方式。
type=JDBC: 表示使用JDBC原生的事务管理方式
type=MANAGED: 被管理,例如Spring的声明式事务
-->
<transactionManager type="JDBC"/>
<!--
dataSource: 设置数据源
type: 设置数据源的类型
type=POOLED: 表示使用数据库连接池
type=UNPOOLED: 表示不使用数据库连接池
type=JNDI: 表示来使用上下文中的数据源
-->
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
<!--测试环境-->
<environment id="test">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/ssm"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<!--引入mybatis的映射文件-->
<mappers>
<!-- <mapper resource="mappers/UserMapper.xml"/>-->
<!--
package: 以包的方式引入映射文件,但是必须满足两个条件
1. mapper接口和映射文件所在的包必须一致
2. mapper接口的名字必须和映射文件的名字必须一致
-->
<package name="cn.test.mybatis.mapper"/>
</mappers>
</configuration>
核心配置文件推荐命名为 mybatis-config.xml
,该配置文件位于 src/main/resources
目录下
MyBatis 核心配置文件中的标签必须要按照指定的顺序配置:
properties、settings、typeAliases、typeHandler、
objectFactory、objectWrapperFactory、reflectorFactory、
plugins、environments、databaseIdProvider、mappers
3.创建Mapper接口
mybatis 中的 mapper 接口相当于以前的 dao,但区别在于 mapper 仅仅是接口,我们不需要提供实现类。
package cn.test.mybatis.mapper;
import cn.test.mybatis.pojo.User;
public interface UserMapper {
int insertUser();
int updateUser();
int deleteUser();
User getUserById(Integer id);
List<User> getAllUsers();
}
4.创建Mybatis映射文件
相关概念:ORM (Object Relationship Mapping) 对象关系映射
- 对象:Java 的实体类对象
- 关系:关系型数据库
- 映射:二者之间存在对应关系
Java概念 | 数据库概念 |
---|---|
类 | 表 |
属性 | 字段/列 |
对象 | 记录/行 |
(1)映射文件的命名规则:
表所对应的实体类的类名+Mapper.xml
例如:表 t_user,映射的实体类为 User,所对应的映射文件为 UserMapper.xml
一个映射文件对应一个实体类,对应一张表的操作
MyBatis 映射文件用于编写 SQL,访问以及操作表中的数据
MyBatis 映射文件存放的位置是
src/main/resources/mappers目录下
(2)MyBatis 中可以面向接口操作数据,要保证两个一致:
- mapper 接口的全类名要和映射文件的 namespace 一致
- mapper 接口中的方法名和映射文件中的 sql 的 id 一致
Mapper 映射文件编写完成后需要在 Mybatis 的核心配置文件中使用 <mapper> 标签进行引入
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.test.mybatis.mapper.UserMapper">
<!-- mapper接口和映射文件要保证两个一致-->
<!-- 1.mapper接口的全类名要和映射文件的namespace一致-->
<!-- 2.mapper接口中的方法名和映射文件中的sql的id一致-->
<insert id="insertUser">
insert into t_user(username,password,age,gender,email) values('admin','123456',18,'男','123@qq.com')
</insert>
<update id="updateUser">
update t_user
set username='test',password='6666'
where id=2
</update>
<delete id="deleteUser">
delete from t_user
where id = 7
</delete>
<!-- resultType: 设置结果类型,即查询的数据要转换为Java的类型-->
<!-- resultMap: 自定义类型,处理多对一或一对多的映射关系-->
<select id="getUserById" resultType="cn.test.mybatis.pojo.User">
select * from t_user
where id = #{id}
</select>
<select id="getAllUsers" resultType="cn.test.mybatis.pojo.User">
select * from t_user
</select>
</mapper>
5.添加MyBatis日志
这里使用了 log4j2
日志,在 src/main/resources
目录下创建 log4j2.xml 文件。( log4j2 的依赖见第一步导入依赖)
<?xml version="1.0" encoding="UTF-8"?>
<Configuration xmlns="http://logging.apache.org/log4j/2.0/config">
<Appenders>
<Console name="stdout" target="SYSTEM_OUT">
<PatternLayout pattern="%5level [%t] - %msg%n"/>
</Console>
</Appenders>
<Loggers>
<Logger name="cn.test.mybatis.mapper" level="debug"/>
<Root level="error" >
<AppenderRef ref="stdout"/>
</Root>
</Loggers>
</Configuration>
6.测试Mapper中的方法
package cn.test.mybatis.test;
import cn.test.mybatis.mapper.UserMapper;
import cn.test.mybatis.pojo.User;
import cn.test.mybatis.utils.SqlSessionUtil;
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 org.junit.jupiter.api.Test;
import java.io.IOException;
import java.io.InputStream;
public class MybatisTest {
@Test
public void testInsert() throws IOException {
//1. 读取mybatis的配置文件
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
//2. 通过SqlSessionFactoryBuilder创建SqlSessionFactory对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory sqlSessionFactory = builder.build(inputStream);
//3. 开启SqlSession,并设置自动提交
SqlSession sqlSession = sqlSessionFactory.openSession(true);
//4. 获取mapper的代理类对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//5. 调用UserMapper的insertUser方法
int result = userMapper.insertUser();
System.out.println("result: " + result);
//6. 关闭sqlSession
sqlSession.close();
}
@Test
public void testUpdate() {
SqlSession sqlSession = SqlSessionUtil.getSqlSession();
sqlSession.getMapper(UserMapper.class).updateUser();
sqlSession.close();
}
@Test
public void testDelete() {
SqlSession sqlSession = SqlSessionUtil.getSqlSession();
sqlSession.getMapper(UserMapper.class).deleteUser();
sqlSession.close();
}
@Test
public void testGetUserById() {
SqlSession sqlSession = SqlSessionUtil.getSqlSession();
User user = sqlSession.getMapper(UserMapper.class).getUserById(1);
System.out.println("User: " + user);
sqlSession.close();
}
@Test
public void testGetAllUsers() {
SqlSession sqlSession = SqlSessionUtil.getSqlSession();
List<User> userList = sqlSession.getMapper(UserMapper.class).getAllUsers();
userList.forEach(System.out::println);
sqlSession.close();
}
}
package cn.test.mybatis.utils;
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;
public class SqlSessionUtil {
private static SqlSessionFactory sqlSessionFactory;
static {
InputStream inputStream = null;
try {
//1. 读取mybatis的配置文件
inputStream = Resources.getResourceAsStream("mybatis-config.xml");
//2. 通过SqlSessionFactoryBuilder创建SqlSessionFactory对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
sqlSessionFactory = builder.build(inputStream);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static SqlSession getSqlSession(){
//3. 开启SqlSession,并设置自动提交
SqlSession sqlSession = sqlSessionFactory.openSession(true);
return sqlSession;
}
}
7.在idea添加MyBatis的相关模板
点击 idea 的 Settings --> Editor --> File and Code Templates,在 Files 选项下点击 + 号,填写模板名称和模板文件的后缀,再将模板内容复制到内容区域
MyBatis 核心配置文件模板
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"https://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.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>
<!--引入mybatis的映射文件-->
<mappers>
<package name=""/>
</mappers>
</configuration>
Mapper 映射文件模板
<?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="">
</mapper>
MyBatis获取参数值的两种形式
MyBatis 获取参数值的两种方式:${} 和 #{}
${} 的本质就是字符串拼接,#{} 的本质就是占位符赋值
${} 使用字符串拼接的方式拼接 sql,如果为字符串类型或日期类型的字段进行赋值时,需要手动加单引号;
但是 #{} 使用占位符赋值的方式拼接 sql,此时为字符串类型或日期类型的字段进行赋值时,可以自动添加单引号。
单个字面量类型的参数
如果 mapper 接口中的方法参数为单个的字面量类型
此时可以使用 ${} 和 #{} 以任意的名称获取参数的值,注意 需要手动加单引号。如 : ′ {} 需要手动加单引号。如:' 需要手动加单引号。如:′{username}’
多个字面量类型的参数
如果 mapper 接口中的方法参数为多个时,此时 MyBatis 会自动将这些参数放在一个 map 集合中,以 arg0、arg1 … 为键,以参数为值;以 param1、param2… 为键,以参数为值;因此只需要通过 ${} 和 #{} 访问 map 集合的键就可以获取相对应的值,注意 ${} 需要手动添加单引号
mapper 接口中的方法参数类型是 map
如果 mapper 接口中的方法参数类型是 map ,只需要通过 ${} 和 #{} 访问 map 集合的键,就可以获取相应的值,一点要注意 ${} 单引号问题
mapper 接口中的方法参数类型是Java对象类型
如果 mapper 接口方法的参数为实体类类型的参数,只需要通过 ${} 和 #{} 访问实体类中的属性,就可以获取相对应的属性值, 一点要注意 ${} 单引号问题
使用@Param注解标注的mapper方法参数
如果使用 @Param 注解标注的 mapper 方法的参数,可以通过 ${} 和 #{} 访问 @Param 注解的 value 属性值,就可以获取相对应的属性值, 一点要注意 ${} 单引号问题
还可以使用 param1,param2… 参数为值来获取相对应的属性值
MyBatis的各种查询功能
1.查询一个对象
User getUserById(Integer id);
<select id="getUserById" resultType="User">
select * from t_user
where id = #{id}
</select>
2.查询一个list集合
List<User> getAllUsers();
<select id="getUserById" resultType="User">
select * from t_user
</select>
当查询的数据为多条时,不能使用实体类作为返回值,否则会抛出 TooManyResultsException;但是如果查询的数据只有一条,就可以使用实体类或集合作为返回值
3.查询单个数据
Integer getCount();
<!--resultType这里使用了MyBatis提供的别名-->
<select id="getCount" resultType="integer">
select count(*) from t_user
</select>
MyBatis 提供了一些为常见的 Java 类型内建的类型别名。它们都是不区分大小写的
别名 | 映射的类型 |
---|---|
_int | int |
_integer | int |
string | String |
int | Integer |
integer | Integer |
map | Map |
list | List |
4.查询一个map集合
查询一条数据为 map 集合
Map<String, Object> getUserByIdToMap(@Param("id") Integer id);
<!-- Map<String,Object> getUserByIdToMap(@Param("id") Integer id);-->
<select id="getUserByIdToMap" resultType="map">
select * from t_user where id = #{id}
</select>
查询多条数据为 map 集合
List<Map<String, Object>> getAllUsersToMap();
@MapKey("id")
Map<String, Object> getAllUsersToMap2();
<!-- List<Map<String,Object>> getAllUsersToMap();-->
<select id="getAllUsersToMap" resultType="map">
select * from t_user
</select>
<!-- Map<String, Object> getAllUsersToMap2();-->
<select id="getAllUsersToMap2" resultType="map">
select * from t_user
</select>
查询多条数据且返回类型需要是 map 集合时,有以下两种方式
- 将 mapper 接口方法的返回设置成 List<Map<String, Object>> 类型
- 可以将每条数据转换的 map 集合放到一个大的 map 集合中,但是必须使用 @MapKey 指定每条数据对应的 key
特殊 SQL 的执行
1.模糊查询
List<User> getUserByLike(@Param("keyword") String keyword);
<!-- List<User> getUserByLike(@Param("keyword") String keyword);-->
<select id="getUserByLike" resultType="User">
<!-- select * from t_user where username like '%${keyword}%'-->
<!-- select * from t_user where username like concat('%',#{keyword},'%')-->
select * from t_user where username like "%"#{keyword}"%"
</select>
可以使用 ${} 、concat、“” 方式来进行拼接
2.批量删除
void deleteMoreUser(@Param("ids") String ids);
<delete id="deleteMoreUser">
delete from t_user where id in(${ids})
</delete>
3.动态表名
List<User> getUserList(@Param("tableName") String tableName);
<!-- List<User> getUserList();-->
<select id="getUserList" resultType="User">
select * from ${tableName}
</select>
4.添加功能获取自增的主键
void insertUserAndReturnKey(User user);
<!--
useGeneratedKeys: 表示当前添加功能使用了自增的主键
keyProperty: 将添加的数据的自增主键为实体类型的参数的属性赋值
-->
<insert id="insertUserAndReturnKey" useGeneratedKeys="true" keyProperty="id">
insert into t_user(username,password,age,gender,email)
values (#{username},#{password},#{age},#{gender},#{email})
</insert>
自定义映射resultMap
1. resultMap处理字段和属性的映射关系
如果字段名和实体类中的属性名不一致,可以通过 resultMap 设置自定义的映射
List<Emp> getEmpList();
<!--
resultMap: 设置自定义的映射关系
id: 唯一标识
type: 处理映射关系的实体类型
常用标签:
id: 处理主键和实体类中属性的映射关系
result: 处理普通字段和实体类中属性的映射关系
标签中的属性:
column: 设置映射关系中的字段名,必须是sql查询出的某个字段
property: 设置映射关系中的属性的属性名,必须是处理的实体类类型中的属性名
-->
<resultMap id="empResultMap" type="Emp">
<id column="emp_id" property="empId"></id>
<result column="emp_name" property="empName"></result>
<result column="dept_id" property="deptId"></result>
</resultMap>
<select id="getEmpList" resultMap="empResultMap">
select * from t_emp
</select>
如果只是下划线与驼峰的关系,可以使用以下方式
<!--
字段名和属性名不一致的情况,可以使用以下方式处理:
1. 为查询字段设置别名,别名和属性名保持一致
2. 当字段符合MySQL的要求使用 _ ,而属性符合java的要求使用驼峰
此时可以在MyBatis的核心配置文件中设置一个全局配置,可以自动将下划线映射为驼峰
mapUnderscoreToCamelCase=true
-->
<!-- List<Emp> getEmpList();-->
<select id="getEmpList" resultType="Emp">
select * from t_emp
</select>
MyBatis的核心配置文件中设置mapUnderscoreToCamelCase属性
<settings>
<!--是否开启驼峰命名自动映射,即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
多对一的映射关系
1.使用级联方式
Emp getEmpById(@Param("id") Integer id);
<resultMap id="empAndDeptResultMap" type="Emp">
<id column="emp_id" property="empId"></id>
<result column="emp_name" property="empName"></result>
<result column="gender" property="gender"></result>
<result column="age" property="age"></result>
<result column="dept_id" property="dept.deptId"></result>
<result column="dept_name" property="dept.deptName"></result>
</resultMap>
<!-- Emp getEmpById(@Param("id") Integer id);-->
<select id="getEmpById" resultMap="empAndDeptResultMap">
select * from t_emp
left join t_dept
on t_emp.dept_id = t_dept.dept_id
where t_emp.emp_id = #{id}
</select>
2.使用 association 标签
association 处理多对一的映射关系(处理实体类类型的属性)
Emp getEmpById(@Param("id") Integer id);
<resultMap id="empAndDeptResultMap" type="Emp">
<id column="emp_id" property="empId"></id>
<result column="emp_name" property="empName"></result>
<result column="gender" property="gender"></result>
<result column="age" property="age"></result>
<result column="dept_id" property="deptId"></result>
<association property="dept" javaType="Dept">
<id column="dept_id" property="deptId"></id>
<result column="dept_name" property="deptName"></result>
</association>
</resultMap>
<!-- Emp getEmpById(@Param("id") Integer id);-->
<select id="getEmpById" resultMap="empAndDeptResultMap">
select * from t_emp
left join t_dept
on t_emp.dept_id = t_dept.dept_id
where t_emp.emp_id = #{id}
</select>
3.分布查询
分布查询第 2 步的 maper 方法与映射
Dept getDeptById(@Param("deptId") Integer deptId);
<!-- Dept getDeptById(@Param("deptId") Integer deptId);-->
<select id="getDeptById" resultType="Dept">
select *
from t_dept
where dept_id = #{deptId}
</select>
分布查询第 1 步的 maper 方法与映射
Emp getEmpById(@Param("id") Integer id);
<resultMap id="empAndDeptByStepResultMap" type="Emp">
<id column="emp_id" property="empId"></id>
<result column="emp_name" property="empName"></result>
<result column="gender" property="gender"></result>
<result column="age" property="age"></result>
<result column="dept_id" property="deptId"></result>
<!--
property: 设置需要处理映射关系的属性的属性名
select: 设置分布查询的sql的唯一标识
column: 将查询出的结果的某个字段作为分布查询的sql的条件
-->
<association property="dept" select="cn.test.mybatis.mapper.DeptMapper.getDeptById"
column="dept_id"></association>
</resultMap>
<select id="getEmpById" resultMap="empAndDeptByStepResultMap">
select *
from t_emp
where emp_id = #{id}
</select>
分布查询的优点:可以实现延迟加载
但必须在核心配置文件中设置全局配置信息
lazyLoadingEnabled:延迟加载的全局开关。当开启时,所有关联对象都会延迟加载
aggressiveLazyLoading:当开启时,任何方法的调用都会加载该对象的所有属性。否则,每个属性会按需加载
此时就可以实现按需加载,获取的数据是什么,就只会执行相应的 sql。此时可通过 association 和 collection 中的 fetchType 属性设置当前的分布查询是否使用延迟加载。
fetchType=“lazy” 表示延迟加载;fetchType=“eager” 表示立即加载
一对多的映射关系
1. 使用 collection
Dept getDeptAndEmpById(@Param("deptId") Integer deptId);
<resultMap id="deptAndEmpResultMap" type="Dept">
<id column="dept_id" property="deptId"></id>
<result column="dept_name" property="deptName"></result>
<!--
collection: 处理一对多的映射
ofType: 设置集合中存放数据的类型
-->
<collection property="empList" ofType="Emp">
<id column="emp_id" property="empId"></id>
<result column="emp_name" property="empName"></result>
<result column="gender" property="gender"></result>
<result column="age" property="age"></result>
<result column="dept_id" property="deptId"></result>
</collection>
</resultMap>
<!-- Dept getDeptAndEmpById(@Param("deptId") Integer deptId);-->
<select id="getDeptAndEmpById" resultMap="deptAndEmpResultMap">
select *
from t_dept
left join t_emp on t_dept.dept_id = t_emp.dept_id
where t_dept.dept_id = #{deptId}
</select>
2.使用分步查询
分布查询第 2步的 maper 方法与映射
List<Emp> getEmpListByDeptId(@Param("deptId") Integer deptId);
<!-- List<Emp> getEmpListByDeptId(@Param("deptId") Integer deptId);-->
<select id="getEmpListByDeptId" resultType="Emp">
select *
from t_emp
where dept_id = #{deptId}
</select>
分布查询第 1 步的 maper 方法与映射
Dept getDeptAndEmpById2(@Param("deptId") Integer deptId);
<resultMap id="deptAndEmpResultMap2" type="Dept">
<id column="dept_id" property="deptId"></id>
<result column="dept_name" property="deptName"></result>
<collection property="empList" select="cn.test.mybatis.mapper.EmpMapper.getEmpListByDeptId" column="dept_id"></collection>
</resultMap>
<!-- Dept getDeptAndEmpById(@Param("deptId") Integer deptId);-->
<select id="getDeptAndEmpById2" resultMap="deptAndEmpResultMap2">
select *
from t_dept
where dept_id = #{deptId}
</select>
动态SQL
MyBatis 框架的动态 SQL 技术是一种根据特定条件动态拼接 SQL 语句的功能,它存在的意义是为了解决拼接SQL 语句字符串时的痛点问题。
1.if
if 标签可以test属性的表达式进行判断,如果表达式的结果为true,则标签中的内容会执行。反之不会执行
2.where
- 如果where标签中有条件成立,会自动生成关键字
- 会自动将where标签中
内容前多余的and去掉,但是其中内容后面的and不会去掉
- 如果where标签中没有任何条件成立,则where标签没有任何功能
List<Emp> getEmpByCondition(Emp emp);
<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="gender != null and gender != ''">
and gender = #{gender}
</if>
</where>
</select>
3.trim
prefix、suffix:在标签中内容前面或内容后面添加指定内容
prefixOverrides、suffixOverrides:在标签中内容前面或内容后面去掉指定内容
<select id="getEmpByCondition" resultType="Emp">
select * from t_emp
<trim prefix="where" suffixOverrides="and">
<if test="empName != null and empName != ''">
emp_name = #{empName} and
</if>
<if test="age != null and age != ''">
age = #{age} and
</if>
<if test="gender != null and gender != ''">
gender = #{gender}
</if>
</trim>
</select>
4.choose、when、otherwise
相当于 java 中的 if…else if …else
when至少有一个,otherwise 最多只有一个
List<Emp> getEmpByChoose(Emp emp);
<!-- List<Emp> getEmpByChoose(Emp emp);-->
<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 = #{gender}
</when>
<when test="gender != null and gender != ''">
gender = #{gender}
</when>
</choose>
</where>
</select>
5.foreach
Mapper 的方法中的参数如果为 List,MyBatis 默认以 list 为键,参数为值放到 map 集合中,在 Mapper.xml 中使用时以 list 来获取
Mapper 的方法中的参数如果为 Array,MyBatis 默认以 array 为键,参数为值放到 map 集合中,在 Mapper.xml 中使用时以 array 来获取
可以使用 @Param 注解的 value 属性来设置自定义 key,在 Mapper.xml 中使用时以自定义的 key 来获取
void insertMoreEmp(@Param("emps") List<Emp> emps);
<!-- void insertMoreEmp(List<Emp> emps);-->
<insert id="insertMoreEmp">
insert into t_emp (emp_name,age,gender) values
<foreach collection="emps" item="emp" separator=",">
(#{emp.empName},#{emp.age},#{emp.gender})
</foreach>
</insert>
批量删除
foreach 标签的 open 设置语句开始的字符串,close 设置语句结束的字符串。
collection:设置需要循环的数组或集合
item:用一个字符串表示数组或集合中的每一项
separator:设置每次循环的数据之间的分割符
void deleteMoreEmp(@Param("empIds") Integer[] empIds);
<!-- void deleteMoreEmp(@Param("empIds") Integer[] empIds);-->
<delete id="deleteMoreEmp">
delete
from t_emp
where emp_id in
<foreach collection="empIds" item="empId" separator="," open="(" close=")">
#{empId}
</foreach>
</delete>
6.sql
sql 片段,可以使用 include 标签来引用该 sql 片段
<sql id="empColumns">
emp_id,emp_name,age,gender,dept_id
</sql>
<select id="getEmpByCondition" resultType="Emp">
select <include refid="empColumns"></include> from t_emp
<trim prefix="where" suffixOverrides="and">
<if test="empName != null and empName != ''">
emp_name = #{empName} and
</if>
<if test="age != null and age != ''">
age = #{age} and
</if>
<if test="gender != null and gender != ''">
gender = #{gender}
</if>
</trim>
</select>
MyBatis 的缓存
1.MyBatis的一级缓存
一级缓存是 SqlSession 级别的,通过同一个 SqlSession 查询的数据会被缓存,下次查询相同的数据,就会从缓存中直接读取,不会从数据库重新访问
使用一级缓存失效的四种情况:
- 不同的 SqlSession 对应不同的一级缓存。
- 同一个 SqlSession 但查询条件不同
- 同一个 SqlSession 两次查询期间执行了任何一次增删改操作
- 同一个 SqlSession 两次查询期间手动清空了缓存
2.MyBatis的二级缓存
二级缓存是 SqlSessionFactory 级别的,通过同一个 SqlSessionFactory 创建的 SqlSession 的查询结果会被缓存;此后如果再次执行相同的查询语句,结果从缓存中获取
二级缓存开启的条件:
- 在核心配置文件中,设置全局配置属性 cacheEnabled=“true”,默认为 true,不需要设置。
- 在映射文件中设置标签
<cache/>
- 二级缓存必须在 SqlSession 关闭或提交后有效
- 查询的数据转换的实体类类型必须实现序列化的接口
二级缓存失效的情况:
两次查询期间执行了任何一次增删改操作,会使一级和二级缓存同时失效。
3.二级缓存的相关配置
在 mapper 配置文件中添加 cache 标签可以设置一些属性:
-
eviction 属性:缓存回收策略,默认是 LRU。
LRU (Least Recently Used) 最近最少使用的:移除最长时间不被使用的对象
FIFO (First in First out) 先进先出:按对象进入缓存的顺序来移除它们
SOFT 软引用:移除基于垃圾收集器状态和弱引用规则的对象
-
flushInterval 属性:刷新间隔,单位毫秒
默认情况是不设置,也就是没有刷新间隔,缓存仅仅是调用语句时刷新
-
size 属性:引用数目,正整数
代表缓存最多可以存储多少个对象,太大容易导致内存溢出
-
readOnly 属性:只读,true、false
true:只读缓存,会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改,这提供了很重要的性能优势
false:读写缓存,会返回缓存对象的拷贝(通过序列化),这会慢一些,因此默认是 false
4. MyBatis缓存查询的顺序
- 先查二级缓存,因为二级缓存中可能会有其他程序已经查出来的数据,可以拿来直接使用
- 如果二级缓存没有命中,再查一级缓存
- 如果一级缓存也没有命中,则查询数据库
- SqlSession 关闭后,一级缓存中的数据会写入二级缓存中
5.整合第三方缓存EHCache
MyBatis的逆向工程
正向工程:先创建Java实体类,由框架赋值根据实体类生成数据表。Hidernate 是支持正向工程的
逆向工程:先创建数据库表,由框架赋值根据数据库表,反向生成如下资源:
- Java 实体类
- Mapper 接口
- Mapper 映射文件
1.创建逆向工程的步骤
1. 添加依赖
依赖
<dependencies>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.9.2</version>
</dependency>
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
<!--log4j2依赖-->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.20.0</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>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
</dependencies>
</plugin>
</plugins>
</build>
2.创建MyBatis核心配置文件
3.创建逆向工程的配置文件
文件名必须是:generatorConfig.xml
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>
<!-- 数据库驱动:选择你的本地硬盘上面的数据库驱动包 -->
<!-- <classPathEntry location="D:\maven-warehouse\repository\mysql\mysql-connector-java\5.1.47\mysql-connector-java-5.1.47.jar"/>-->
<!-- <classPathEntry location="D:\maven-warehouse\repository\mysql\mysql-connector-java\8.0.17\mysql-connector-java-8.0.17.jar"/> -->
<context id="DB2Tables" targetRuntime="MyBatis3">
<!-- 实体类生成序列化属性-->
<plugin type="org.mybatis.generator.plugins.SerializablePlugin"/>
<!-- 实体类重写HashCode()和equals()-->
<plugin type="org.mybatis.generator.plugins.EqualsHashCodePlugin"/>
<!-- 实体类重写toString() -->
<plugin type="org.mybatis.generator.plugins.ToStringPlugin"/>
<commentGenerator>
<!-- 是否去除自动生成的注释 -->
<property name="suppressAllComments" value="true"/>
<!-- 生成注释是否带时间戳-->
<property name="suppressDate" value="true"/>
<!-- 生成的Java文件的编码格式 -->
<property name="javaFileEncoding" value="utf-8"/>
<!-- 格式化java代码-->
<property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/>
<!-- 格式化XML代码-->
<property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/>
</commentGenerator>
<!-- 数据库连接驱动类,URL,用户名、密码 -->
<jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
connectionURL="jdbc:mysql://127.0.0.1:3306/ssm?useUnicode=true&characterEncoding=UTF-8"
userId="root" password="123456">
</jdbcConnection>
<!-- java类型处理器:处理DB中的类型到Java中的类型 -->
<javaTypeResolver type="org.mybatis.generator.internal.types.JavaTypeResolverDefaultImpl">
<!-- 是否有效识别DB中的BigDecimal类型 -->
<property name="forceBigDecimals" value="true"/>
</javaTypeResolver>
<!-- 生成Domain模型:包名(targetPackage)、位置(targetProject) -->
<javaModelGenerator targetPackage="cn.test.mybatis.pojo" targetProject=".\src\main\java">
<!-- 在targetPackage的基础上,根据数据库的schema再生成一层package,最终生成的类放在这个package下,默认为false -->
<property name="enableSubPackages" value="true"/>
<!-- 设置是否在getter方法中,对String类型字段调用trim()方法-->
<property name="trimStrings" value="true"/>
</javaModelGenerator>
<!-- 生成xml映射文件:包名(targetPackage)、位置(targetProject) -->
<sqlMapGenerator targetPackage="cn.test.mybatis.mapper" targetProject=".\src\main\resources">
<property name="enableSubPackages" value="true"/>
</sqlMapGenerator>
<!-- 生成DAO接口:包名(targetPackage)、位置(targetProject) -->
<javaClientGenerator type="XMLMAPPER" targetPackage="cn.test.mybatis.mapper" targetProject=".\src\main\java">
<property name="enableSubPackages" value="true"/>
</javaClientGenerator>
<!-- 要生成的表:tableName - 数据库中的表名或视图名,domainObjectName - 实体类名 -->
<table tableName="t_emp" domainObjectName="Emp"></table>
<table tableName="t_dept" domainObjectName="Dept"></table>
</context>
</generatorConfiguration>
**在侧边栏 maven 中找到当前的 mudole,在 Plugins 中找到 mybatis-generator 下的 mybatis-generator:generate 点击它就能生成对应的 java bean、mapper 以及 example 文件 **
注意:点击 mybatis-generator:generate 前先确定数据库的表是否已经创建了
分页插件
1.添加依赖
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.2.0</version>
</dependency>
2.配置分页插件
在 Mybatis 的核心配置文件中配置插件
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
3.分页插件的使用
在查询功能之前使用 PageHelper.startPage(int pageNum, int pageSize) 开启分页功能
- pageNum 当前的页面
- pageSize 每页显示的条数
- size 当前页显示的真实条数
- total 总记录数
- pages 总页数
- prePage 上一页的页码
- nextPage 下一页的页码
- isFirstPage/isLastPage:是否为第一页/最后一页
- hasPreviousPage/hasNextPage:是否有上一页/下一页
- navigatePages 导航分页的页码数
- navigatepageNums 导航分页的页码 [1,2,3,4,5]
@Test
public void testGetEmpByCondition2(){
SqlSession sqlSession = SqlSessionUtil.getSqlSession();
DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
//查询功能之前开启分页功能
Page<Object> page = PageHelper.startPage(1, 4);
List<Emp> empList = mapper.getEmpByCondition(null);
//查询功能之后可以获取相关的所有数据
PageInfo<Emp> list = new PageInfo<>(empList,2);
System.out.println(page);
System.out.println("-----------------------");
System.out.println(list);
sqlSession.close();
}