MyBatis 入门教程之八

发表于 更新于 阅读次数： 评论数： 本文字数： 3.4k 阅读时长 ≈ 3 分钟

大纲

MyBatis 实用场景

MyBatis 批量操作

调用不带参数的 openSession() 方法时，创建的 SqlSession 对象具有如下特性：

  • 会开启一个事务（不会自动提交）
  • 数据库连接对象会从由环境配置的数据源实例得到
  • 事务隔离级别将会使用驱动或数据源的默认配置
  • 预处理语句不会被复用，也不会批量处理更新

值得一提的是，openSession() 方法的 ExecutorType 类型的参数是枚举类型，取值如下：

  • SIMPLE：这个执行器类型不做特殊的事情（默认执行器），它会为每个 SQL 语句的执行创建一个新的预处理语句。
  • REUSE：这个执行器类型会复用预处理语句。
  • BATCH：这个执行器会批量执行所有更新语句。

批量操作介绍

批量操作就是使用 MyBatis 提供的 BATCH 类型的 Executor 进行的，它的底层是通过 JDBC 暂存 SQL 语句的方式来实现，也就是保存 SQL 语句到一定数量后再发给数据库执行一次。MyBatis 与 Spring 整合时，推荐额外配置一个可以专门用来执行批量操作的 SqlSession，配置示例如下。当需要使用批量操作的时候，可以在 Service 层注入可批量操作的 SqlSession，然后通过它获取 Mapper 映射器来操作数据库。

1
2
3
4
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
	<constructor-arg name="executorType" value="BATCH" />
	<constructor-arg name="sqlSessionFactory" ref="sqlSessionFactoryBean" />
</bean>

特别注意

  1. 当 ExecutorType 指定为 BATCH 后，执行增删改操作不会再返回正确的受影响的记录数。
  2. 批量操作是在 session.commit() 执行以后才发送 SQL 语句给数据库执行的。若想让其提前执行，以方便后续的查询操作可以获取到数据，则可以调用 sqlSession.flushStatements() 方法，让其直接冲刷到数据库进行执行。

批量操作使用案例

本节所需的案例代码，可以直接从 GitHub 下载对应章节 mybatis-lesson-22。

  • Mapper 接口
1
2
3
4
5
public interface EmployeeMapper {

	public boolean addEmp(Employee employee);

}
  • SQL 映射文件
1
2
3
4
5
6
7
8
<mapper namespace="com.clay.mybatis.dao.EmployeeMapper">

	<insert id="addEmp" parameterType="com.clay.mybatis.bean.Employee">
		insert into t_employee (last_name, gender, email)
		values(#{lastName}, #{gender}, #{email})
	</insert>

</mapper>
  • 批量操作
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
public class MyBatisApplication {

	public static void main(String[] args) throws IOException {
		String resource = "mybatis-config.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

		// 批量操作：设置执行器的类型为 BATCH
		SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH);
		try {
			EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);

			for (int i = 0; i < 10; i++) {
				Employee employee = new Employee("employe-" + i, "1", "employe@gmail.com");
				mapper.addEmp(employee);
			}

			session.commit();
		} finally {
			if (session != null) {
				session.close();
			}
		}
	}

}
  • 执行结果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
21:25:28,897 DEBUG JdbcTransaction:137 - Opening JDBC Connection
21:25:29,120 DEBUG PooledDataSource:434 - Created connection 706895319.
21:25:29,120 DEBUG JdbcTransaction:101 - Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2a225dd7]
21:25:29,124 DEBUG addEmp:137 - ==>  Preparing: insert into t_employee (last_name, gender, email) values(?, ?, ?)
21:25:29,165 DEBUG addEmp:137 - ==> Parameters: employe-0(String), 1(String), employe@gmail(String)
21:25:29,166 DEBUG addEmp:137 - ==> Parameters: employe-1(String), 1(String), employe@gmail(String)
21:25:29,166 DEBUG addEmp:137 - ==> Parameters: employe-2(String), 1(String), employe@gmail(String)
21:25:29,167 DEBUG addEmp:137 - ==> Parameters: employe-3(String), 1(String), employe@gmail(String)
21:25:29,167 DEBUG addEmp:137 - ==> Parameters: employe-4(String), 1(String), employe@gmail(String)
21:25:29,168 DEBUG addEmp:137 - ==> Parameters: employe-5(String), 1(String), employe@gmail(String)
21:25:29,168 DEBUG addEmp:137 - ==> Parameters: employe-6(String), 1(String), employe@gmail(String)
21:25:29,170 DEBUG addEmp:137 - ==> Parameters: employe-7(String), 1(String), employe@gmail(String)
21:25:29,170 DEBUG addEmp:137 - ==> Parameters: employe-8(String), 1(String), employe@gmail(String)
21:25:29,170 DEBUG addEmp:137 - ==> Parameters: employe-9(String), 1(String), employe@gmail(String)
21:25:29,174 DEBUG JdbcTransaction:70 - Committing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2a225dd7]
21:25:29,177 DEBUG JdbcTransaction:123 - Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2a225dd7]
21:25:29,177 DEBUG JdbcTransaction:91 - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2a225dd7]
21:25:29,178 DEBUG PooledDataSource:391 - Returned connection 706895319 to pool.

观察上面的执行结果，可以发现使用 MyBatis 的批量操作插入多条数据时，不会发送多条 SQL 语句到数据库，这大大提高了业务逻辑的执行效率。

PageHelper 分页插件

PageHelper 是 MyBatis 第三方的分页插件，支持任何复杂的单表、多表分页查询，部分特殊情况请看重要提示。

PageHelper 官方文档

PageHelper 使用案例

本节所需的案例代码，可以直接从 GitHub 下载对应章节 mybatis-lesson-21。

  • 引入依赖
1
2
3
4
5
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.3.1</version>
</dependency>
  • 注册插件
1
2
3
4
5
6
7
<configuration>

	<plugins>
		<plugin interceptor="com.github.pagehelper.PageInterceptor" />
	</plugins>

</configuration>
  • Mapper 接口
1
2
3
4
5
public interface EmployeeMapper {

	public List<Employee> getEmps();

}
  • SQL 映射文件

提示

在编写 SQL 语句的时候，不需要手动指定任何分页参数。

1
2
3
4
5
6
7
8
<mapper namespace="com.clay.mybatis.dao.EmployeeMapper">

	<select id="getEmps" resultType="com.clay.mybatis.bean.Employee">
		select id, last_name as lastName, gender, email
		from t_employee
	</select>

</mapper>
  • 业务逻辑，PageHelper 更多 API 的使用示例可以看 这里
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
public class MyBatisApplication {

	public static void main(String[] args) throws IOException {
		String resource = "mybatis-config.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

		SqlSession session = sqlSessionFactory.openSession();
		try {
			// 设置分页信息
			Page<Object> page = PageHelper.startPage(2, 2);

			// 数据库查询
			EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
			List<Employee> employees = mapper.getEmps();
			System.out.println(employees);

			// 获取分页信息
			PageInfo<Object> pageInfo = page.toPageInfo();
			System.out.println("总页数： " + pageInfo.getPages());
			System.out.println("总记录数： " + pageInfo.getTotal());
			System.out.println("当前的页码： " + pageInfo.getPageNum());
			System.out.println("当前的记录数： " + pageInfo.getSize());
			System.out.println("每页的记录数： " + pageInfo.getPageSize());
			System.out.println("是否有下一页： " + pageInfo.isHasNextPage());
			System.out.println("是否为第一页： " + pageInfo.isIsFirstPage());
			System.out.println("是否为最后一页： " + pageInfo.isIsLastPage());
		} finally {
			if (session != null) {
				session.close();
			}
		}
	}

}
  • 执行结果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
23:16:35,705 DEBUG getEmps_COUNT:137 - ==>  Preparing: SELECT count(0) FROM t_employee
23:16:35,763 DEBUG getEmps_COUNT:137 - ==> Parameters: 
23:16:35,802 DEBUG getEmps_COUNT:137 - <==      Total: 1
23:16:35,807 DEBUG getEmps:137 - ==>  Preparing: select id, last_name as lastName, gender, email from t_employee LIMIT ?, ?
23:16:35,810 DEBUG getEmps:137 - ==> Parameters: 2(Long), 2(Integer)
23:16:35,812 DEBUG getEmps:137 - <==      Total: 1
Page{count=true, pageNum=2, pageSize=2, startRow=2, endRow=4, total=3, pages=2, reasonable=false, pageSizeZero=false}[4_Tom_1_tom@gmail.com]
总页数： 2
总记录数： 3
当前的页码： 2
当前的记录数： 1
每页的记录数： 2
是否有下一页： false
是否为第一页： false
是否为最后一页： true

MyBatis 调用存储过程

存储过程（Stored Procedure）是一种存储在数据库中的复杂程序，以便外部程序调用的一种数据库对象。存储过程是为了完成特定功能的 SQL 语句集，经编译创建并保存在数据库中，用户可通过指定存储过程的名称并给定参数（需要时）来调用执行。存储过程的设计思想很简单，本质就是数据库 SQL 语言层面的代码封装与重用。

存储过程的优缺点

存储过程的优点：

  • 极大地提高 SQL 语言的功能和灵活性
  • 可保证数据的安全性和完整性
    • 通过存储过程可以使相关的动作在一起发生，从而可以维护数据库的完整性
    • 通过存储过程可以使没有权限的用户在控制之下间接地存取数据库，从而保证数据的安全
  • 极大地改善 SQL 语句的性能
    • 在运行存储过程前，数据库已对其进行了语法和句法分析，并给出优化执行方案，这种已经编译好的过程可极大地改善 SQL 语句的性能。由于执行 SQL 语句的大部分解析工作已经完成，所以存储过程能以极快的速度执行
  • 可以降低网络的通信量
    • 客户端调用存储过程时，只需要传存储过程名和相关参数即可，与传输 SQL 语句相比自然数据量少了很多

存储过程的缺点：

  • 开发阶段难以调试
  • 难以移植，存储过程往往定制化于特定的数据库上，当切换到其他厂商的数据库系统时，往往需要重写原有的存储过程
  • 如果在一个系统中大量的使用存储过程，到程序交付使用的时候，随着用户需求的增加会导致数据结构的变化，存储过程也要同步更新。最后如果用户想维护该系统可以说是很难的，而且代价是空前的，维护起来更麻烦

MySQL 存储过程的语法

  • 声明语句结束符
1
2
3
4
5
delimiter $$

或者

delimiter //
  • 声明存储过程
1
create procedure demo_in_parameter(in p_in int)
  • 存储过程的开始和结束符号
1
begin .... end
  • 变量定义
1
declare l_int int unsigned default 4000000;
  • 变量赋值
1
set @p_in=1
  • 调用存储过程
1
call demo_in_parameter();
  • 删除存储过程
1
drop procedure demo_in_parameter;
  • 创建存储过程（完整的）
1
2
3
4
5
6
delimiter $$
create procedure datetime()
BEGIN
	select now();
END $$
delimiter ;

存储过程调用案例

本节所需的案例代码，可以直接从 GitHub 下载对应章节 mybatis-lesson-23。

提示

  1. 若需要调用存储过程，可以使用 <select> 标签，并设置标签的 statementType 属性为 CALLABLE 即可
  2. <select> 标签体中存储过程的调用语法： { call procedure_name(#{param1_info}, #{param2_info}) }
MySQL 存储过程调用案例一

在下面的案例中，演示了如何在 MySQL 数据库中使用存储过程来根据员工 ID 查询员工的详细信息。

  • JavaBean 类
1
2
3
4
5
6
7
8
public class Employee {

	private Long id;
	private String lastName;
	private String gender;
	private String email;

}
  • Mapper 接口
1
2
3
4
5
public interface EmployeeMapper {

	public Employee getEmpById(Long id);

}
  • 创建 MySQL 存储过程
1
2
3
4
5
6
delimiter $$
create procedure query_single_employee(IN empId long)
begin
    select id, last_name as lastName, gender, email from t_employee where id = empId;
end $$
delimiter ;
  • SQL 映射文件
1
2
3
4
5
6
7
8
<mapper namespace="com.clay.mybatis.dao.EmployeeMapper">

	<!-- 调用存储过程（传入参数） -->
	<select id="getEmpById" parameterType="Long" resultType="com.clay.mybatis.bean.Employee" statementType="CALLABLE">
		{ call query_single_employee(#{id, mode=IN, jdbcType=BIGINT}) }
	</select>

</mapper>
  • 业务逻辑
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class MyBatisApplication {

	public static void main(String[] args) throws IOException {
		String resource = "mybatis-config.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

		SqlSession session = sqlSessionFactory.openSession();
		try {
			EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
			Employee employee = mapper.getEmpById(1L);
			System.out.println(employee);
		} finally {
			if (session != null) {
				session.close();
			}
		}
	}

}
  • 执行结果
1
2
3
4
22:58:51,817 DEBUG getEmpById:137 - ==>  Preparing: { call query_single_employee(?) }
22:58:51,914 DEBUG getEmpById:137 - ==> Parameters: 1(Long)
22:58:51,942 DEBUG getEmpById:137 - <==      Total: 1
22:58:51,942 DEBUG getEmpById:137 - <==    Updates: 0
Oracle 存储过程调用案例二

MyBatis 对存储过程的游标提供了一个 JdbcType=CURSOR 的支持，可以智能地通过游标读取数据集，并将数据集自动映射到声明的结果集中。在下面的案例中，简单演示了如何在 Oracle 数据库中使用存储过程来实现分页查询的逻辑（这里只是简单演示，并未完全真正实现分页查询的逻辑）。

  • JavaBean 类
1
2
3
4
5
6
7
8
public class Employee {

	private Long id;
	private String lastName;
	private String gender;
	private String email;

}
1
2
3
4
5
6
7
8
public class PageEmp {

	private int start;
	private int end;
	private int count;
	private List<Employee> emps;

}
  • Mapper 接口
1
2
3
4
public interface EmployeeMapper {
	
	public void getPageByProcedure(PageEmp page);
}
  • 创建 Oracle 存储过程
1
2
3
4
5
6
7
8
9
10
11
12
13
create or replace procedure
page_emp (
	p_start in int,
	p_end in int,
	p_count out int,
	ref_cur out sys_refcursor
) AS
BEGIN
	select count(*) into p_count from t_employee;
	open ref_cur for
		select * from (select e.*, rownum as r1 from t_employee e where rownum < p_end)
		where r1 > p_start;
END page_emp;
  • SQL 映射文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<mapper namespace="com.clay.mybatis.dao.EmployeeMapper">

	<resultMap id="EmpResultMap" type="com.clay.mybatis.bean.Employee">
		<id column="id" property="id"/>
		<result column="last_name" property="lastName"/>
		<result column="gender" property="gender"/>
		<result column="email" property="email"/>
	</resultMap>

	<!-- 调用存储过程，通过游标读取返回的数据集，并将数据集自动映射到声明的结果集中 -->
	<select id="getPageByProcedure" parameterType="com.clay.mybatis.bean.PageEmp" statementType="CALLABLE" databaseId="oracle">
		{
			call page_emp (
				#{start, mode=IN, jdbcType=INTEGER},
				#{end, mode=IN, jdbcType=INTEGER},
				#{count, mode=OUT, jdbcType=INTEGER},
				#{emps, mode=OUT, jdbcType=CURSOR, javaType=ResultSet, resultMap=EmpResultMap}
			)
		}
	</select>

</mapper>
  • MyBatis 全局配置文件
1
2
3
4
5
<!-- 数据库厂商标识 -->
<databaseIdProvider type="DB_VENDOR">
	<property name="MySQL" value="mysql"/>
	<property name="Oracle" value="oracle"/>
</databaseIdProvider>
  • 业务逻辑
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class MyBatisApplication {

	public static void main(String[] args) throws IOException {
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession session = sqlSessionFactory.openSession();
		try {
			EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
			PageEmp page = new PageEmp();
			page.setStart(1);
			page.setEnd(5);
			mapper.getPageByProcedure(page);
			
			System.out.println("总记录数：" + page.getCount());
			System.out.println("查出的数据：" + page.getEmps());
		} finally {
			if (session != null) {
				session.close();
			}
		}
	}

}

MyBatis 枚举类型处理器

默认的枚举处理器

MyBatis 在处理枚举类型对象的时候，默认是使用 EnumTypeHandler 枚举类型处理器将枚举的名称保存到数据库。若希望将枚举类型的索引值保存到数据库，则只需要在 MyBatis 的全局配置文件中指定使用 EnumOrdinalTypeHandler 枚举类型处理器即可，配置示例如下：

1
2
3
4
5
6
7
8
<configuration>

	<typeHandlers>
		<!-- 让 MyBatis 使用 EnumOrdinalTypeHandler 处理器来处理 AdminStatus 枚举类型 -->
		<typeHandler handler="org.apache.ibatis.type.EnumOrdinalTypeHandler" javaType="com.clay.mybatis.enums.AdminStatus"/>
	</typeHandlers>

</configuration>

自定义枚举类型处理器的步骤

自定义枚举类型处理器的步骤如下:

  • 1、实现 TypeHandler 接口或者继承 BaseTypeHandler 类
  • 2、使用 @MappedType 注解定义要处理的 javaType 类型，使用 @MappedJdbcTypes 注解定义要处理的 jdbcType 类型，这一步骤可选
  • 3、通过以下三种方式的任意一种来使用自定义的类型处理器
    • 在参数处理的时候，声明要使用自定义的 TypeHandler 进行处理，例如： #{status, typeHandler=xxxx}
    • 在 MyBatis 的全局配置文件中，指定 TypeHandler 要处理的 javaType 类型，例如：<typeHandlers> <typeHandler handler="xxxx" javaType="xxxx"/> </typeHandlers>
    • 在定义结果集标签的时候，声明要使用自定义的 TypeHandler 处理参数的封装，例如：<resultMap> <result column="status" property="status" typeHandler="xxxx"> </result> </resultMap>

自定义枚举类型处理器的案例

本节所需的案例代码，可以直接从 GitHub 下载对应章节 mybatis-lesson-24。

  • 创建数据库表
1
2
3
4
5
6
7
CREATE TABLE `t_admin` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `email` varchar(255) DEFAULT NULL,
  `status` int  DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  • JavaBean 类
1
2
3
4
5
6
7
8
public class Admin {

	private Long id;
	private String name;
	private String email;
	private AdminStatus status;

}
  • 枚举类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
 * 枚举接口
 */
public interface BaseEnum<E extends Enum<?>, T> {

	/**
	 * 获取枚举值
	 *
	 * @return 枚举值
	 */
	T getValue();

	/**
	 * 获取枚举值描述
	 *
	 * @return 枚举值的描述
	 */
	String getDescription();

}
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
/**
 * 枚举实现类
 */
public enum AdminStatus implements BaseEnum<AdminStatus, Integer> {

	VALID(1, "有效"), INVALID(0, "无效");

	private final Integer value;

	private final String description;

	@Override
	public Integer getValue() {
		return this.value;
	}

	@Override
	public String getDescription() {
		return this.description;
	}

	private AdminStatus(Integer value, String description) {
		this.value = value;
		this.description = description;
	}

}
  • 枚举类型处理器
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
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;

import com.clay.mybatis.enums.BaseEnum;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Objects;

/**
 * 枚举类型处理类
 */
public class AutoGenericEnumTypeHandler<E extends BaseEnum<?, ?>> extends BaseTypeHandler<E> {

	private Class<E> enumType;
	private E[] enums;

	public AutoGenericEnumTypeHandler() {

	}

	public AutoGenericEnumTypeHandler(Class<E> type) {
		if (Objects.isNull(type)) {
			throw new IllegalArgumentException("Type argument cannot be null");
		}
		this.enumType = type;
		this.enums = type.getEnumConstants();
		if (Objects.isNull(this.enums)) {
			throw new IllegalArgumentException(type.getName() + " does not represent an enum type");
		}
	}

	private E loadEnum(Object index) {
		for (E e : enums) {
			if (e.getValue().toString().equals(index.toString())) {
				return e;
			}
		}
		throw new IllegalArgumentException(enumType.getName() + " unknown enumerated type index : " + index);
	}

	@Override
	public void setNonNullParameter(PreparedStatement ps, int i, E parameter, JdbcType jdbcType) throws SQLException {
		ps.setObject(i, parameter.getValue());
	}

	@Override
	public E getNullableResult(ResultSet rs, String columnName) throws SQLException {
		if (Objects.isNull(rs.getObject(columnName))) {
			return null;
		}
		Object index = rs.getObject(columnName);
		return loadEnum(index);
	}

	@Override
	public E getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
		if (Objects.isNull(rs.getObject(columnIndex))) {
			return null;
		}
		Object index = rs.getObject(columnIndex);
		return loadEnum(index);
	}

	@Override
	public E getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
		if (Objects.isNull(cs.getObject(columnIndex))) {
			return null;
		}
		Object index = cs.getObject(columnIndex);
		return loadEnum(index);
	}

}
  • Mapper 接口
1
2
3
4
5
6
public interface AdminMapper {

	public Admin getAdminById(Long id);
	public boolean addAdmin(Admin admin);

}
  • SQL 映射文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<mapper namespace="com.clay.mybatis.dao.AdminMapper">

	<select id="getAdminById" parameterType="Long" resultType="com.clay.mybatis.bean.Admin">
		select id, name, email, status
		from t_admin
		where id = #{id}
	</select>

	<insert id="addAdmin" parameterType="com.clay.mybatis.bean.Admin" useGeneratedKeys="true" keyProperty="id">
		insert into t_admin (name, email, status)
		values(#{name}, #{email}, #{status})
	</insert>

</mapper>
  • MyBatis 的全局配置文件
1
2
3
4
5
6
7
8
<configuration>

	<typeHandlers>
		<!-- 让 MyBatis 使用 AutoGenericEnumTypeHandler 处理器来处理 AdminStatus 枚举类型 -->
		<typeHandler handler="com.clay.mybatis.handler.AutoGenericEnumTypeHandler" javaType="com.clay.mybatis.enums.AdminStatus" />
	</typeHandlers>

</configuration>
  • 业务代码
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
public class MyBatisApplication {

	public static void main(String[] args) throws IOException {
		String resource = "mybatis-config.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

		SqlSession session = sqlSessionFactory.openSession();
		try {
			AdminMapper mapper = session.getMapper(AdminMapper.class);

			Admin entity = new Admin("admin", "admin@gmail.com", AdminStatus.VALID);
			mapper.addAdmin(entity);

			Admin admin = mapper.getAdminById(1L);
			System.out.println(admin);

			session.commit();
		} finally {
			if (session != null) {
				session.close();
			}
		}
	}

}

  • 执行结果
1
2
3
4
5
6
7
21:36:08,853 DEBUG addAdmin:137 - ==>  Preparing: insert into t_admin (name, email, status) values(?, ?, ?)
21:36:08,892 DEBUG addAdmin:137 - ==> Parameters: admin(String), admin@gmail.com(String), 1(Integer)
21:36:08,893 DEBUG addAdmin:137 - <==    Updates: 1
21:36:08,909 DEBUG getAdminById:137 - ==>  Preparing: select id, name, email, status from t_admin where id = ?
21:36:08,910 DEBUG getAdminById:137 - ==> Parameters: 1(Long)
21:36:08,927 DEBUG getAdminById:137 - <==      Total: 1
Admin [id=1, name=admin, email=admin@gmail.com, status=VALID]

观察上面的执行结果，可以发现 MyBatis 会自动将枚举类型的 value 属性保存到数据库中，而不是保存枚举类型的名称或者索引值，同时查询数据后也会自动封装枚举类型的数据。