在前面的文章中,笔者详细介绍了 MyBatis 框架的底层框架与运行流程,并且在理解运行流程的基础上手写了一个自己的 MyBatis 框架。看完前两篇文章后,相信读者对 MyBatis 的偏底层原理和执行流程已经有了自己的认知,并且对其在实际开发过程中使用步骤也已是轻车熟路。所谓实践是检验真理的唯一标准,本文将为大家介绍一些 MyBatis 使用中的一些实用插件与自定义插件。本文涉及到的代码已上传至 GitHub: mypagehelper-demo

话不多说,现在开始!

1. Lombok插件

1.1 Lombok简介

在编写 Java 程序时经常会用到很多实体类对象 ,其创建的一般流程就是定义成员变量,然后定义对应的 Constructor(有参/无参构造方法)、Getter and Setter 方法、toString() 方法等等。在 IDEA 中,可以通过 alt + insert 快捷键来快速插入这些方法,操作起来感觉还是很方便的。但是,在实际的业务开发中这些实体对象的属性可能经常发生变化(成员变量命名变化、成员变量个数变化等等),比如在 Web 项目的开发中入参和出参的 DTO 类的属性经常会有所变化。这样在每次发生属性变化时,都需要去修改成员变量对应的构造方法、 Getter and Setter 方法以及 toString() 方法等等,这些操作既繁琐又浪费时间还没有技术含量,降低了实际的开发效率。对于这些问题,Lombok 给出了完美的解决方案。

Lombok 是一种 Java 实用工具,它通过注解方式来帮助开发人员消除代码的冗长。在 IDEA 的插件库搜索 Lombok 便可完成插件的安装,同时在项目里引入 Lombok 依赖可以提供编译支持。

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.8</version>
<scope>provided</scope>
</dependency>

1.2 Lombok的使用

在 Lombok 的包中会提供很多注解,有的作用在类上,有的作用在变量上,而有的注解在方法上,下面会对实际开发中常用的注解进行介绍。

注解名称 作用位置 作用 注解效果
@Data 为类提供 Getter and Setter、equals、canEqual、hashCode、toString 方法 @Date 效果
@Value 为类提供全参构造、equals、hashCode、toString 方法,为类的属性提供 Getter 方法 @Value 效果
@AllArgsConstructor 为类提供一个全参构造 @AllArgsConstructor 效果
@NoArgsConstructor 为类提供一个无参构造 @NoArgsConstructor 效果
@EqualsAndHashCode 为类提供 equals、canEqual 以及hashcode 方法 @EqualsAndHashCode 效果
@toString 为类提供 toString 方法 @toString 效果
@Getter 类或者属性 为类的所有属性或单个属性提供 Getter 方法 @Getter 效果
@Setter 类或者属性 为类的所有属性或单个属性提供 Setter 方法 @Setter 效果
@NonNull 属性 为属性提供非空检查,如果为空则抛出空指针异常 @NonNull 效果
@RequiredArgsConstructor 使用 带@NonNull 或 final 修饰的属性来构造类的构造方法 @RequiredArgsConstructor 效果

在 MyBatis 的使用中灵活搭配 Lombok 的各种注解能够很大程度上简化代码,提高开发效率,关于更多 Lombok 插件的使用可参见其官网:https://projectlombok.org/

2. PageHelper插件

2.1 PageHelper简介

实际开发中遇到查询数据库表给前端返回信息时,常需要对查询结果进行分页,使用 PageHelper 插件能够方便快捷地实现分页要求。 PageHelper 是开源的分页插件,支持任何单表或多表的分页。在实际开发中,推荐使用 maven 添加依赖的方式引入插件:

<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.2.0</version>
</dependency>

2.2 PageHelper的使用

2.2.1 添加PageHelper的配置

在 MyBatis 框架的配置文件中提供了 plugins 标签用于配置 MyBatis 插件,因此在使用 PageHelper 时需要把插件的相关配置写到 MyBatis 的配置文件 mybatis-config.xml 中,如下所示:

<plugins>
<!-- com.github.pagehelper为PageHelper类所在包名 -->
<plugin interceptor="com.github.pagehelper.PageInterceptor">
<property name="param1" value="value1"/>
</plugin>
</plugins>

这里需要注意的是:在 MyBatis 配置文件中,各个标签的顺序有严格的要求,务必在正确的位置添加 PageHelper 的配置。相应的标签顺序见下方:

properties, settings, typeAliases, typeHandlers, objectFactory, objectWrapperFactory, plugins, environments, databaseIdProvided, mappers

2.2.2 PageHelper的两种使用方式

在添加了 PageHelper 的配置后,就可以在实际开发中利用该插件来实现分页。还是采用之前的学生表案例来编写相应的测试方法,如下所示:

public class StudentTest {

  private InputStream in;
private SqlSession sqlSession; @Before
public void init() throws IOException {
// 读取MyBatis的配置文件
in = Resources.getResourceAsStream("mybatis-config.xml");
// 创建SqlSessionFactory的构建者对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
// 使用builder创建SqlSessionFactory对象
SqlSessionFactory factory = builder.build(in);
// 使用factory创建sqlSession对象并设置自动提交事务
sqlSession = factory.openSession(true);
} @Test
public void getAllStudents() {
// 定义分页相关参数
int pageNum = 1, pageSize = 3;
StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
// 使用分页插件
PageHelper.startPage(pageNum, pageSize);
List<Student> students = studentMapper.findAll();
// 输出结果
System.out.println(students);
} @After
public void close() throws IOException {
// 关闭资源
sqlSession.close();
in.close();
}
}

可以采用 PageHelper.startPage(int pageNum, int pageSize) 来快速实现分页操作,其中 int pageNum 用于指定当前的页码,而 int pageSize 用于指定每一页展示的记录数。这里需要注意的是:只有紧跟在 PageHelper.startPage 方法后的第一个 Mybatis 的查询(Select)方法会被分页。因此在调用 PageHelper.startPage 方法后需要紧跟 Mapper 接口中定义的查询方法,否则分页插件将失效。对于上面的测试方法,在运行后得到如下结果:

通过打印的日志发现原本 SELECT * FROM student 的 SQL 语句在配置了 PageHelper 插件后会在语句末尾加入 LIMIT 的分页操作,同时传入指定的 pageSize 参数。在最后的查询结果输出中也可以看出实际的总记录数为 total = 4 ,而查询结果只显示了第一页的三条记录,成功实现了对查询结果分页的操作。

上面介绍的 PageHelper.startPage() 方法最大的局限在于只能对紧跟在其后的 MyBatis 的查询操作的结果进行分页。然而,在实际的后端开发中经常需要对多表进行查询并对结果进行聚合,然后给前端传一个结果集合,这种时候如何实现分页操作呢?在这种情况下,仍然可以利用 PageHelper 插件进行手工分页,定义用于分页请求的 pageRequest() 方法以及相应的测试类,如下所示:

/**
* 分页请求
* @param pageNum 指定页码
* @param pageSize 指定每页的记录数
* @param list 待分页的集合
* @param <T> 集合类型
* @return 分页后的集合
*/
private <T> List<T> pageRequest(int pageNum, int pageSize, List<T> list){
// 根据pageNum和pageSize构建Page类
Page<T> page = new Page<T>(pageNum, pageSize);
// 设置page对象的总记录数属性
page.setTotal(list.size());
// 计算分页的开始和结束索引
int startIndex = (pageNum - 1) * pageSize;
int endIndex = Math.min(startIndex + pageSize, list.size());
// 从待分页的集合获取需要展示的内容添加到page对象
page.addAll(list.subList(startIndex, endIndex));
// 返回分页后的集合
return page.getResult();
} @Test
public void testPage() {
// 定义分页相关参数
int pageNum = 2, pageSize = 3;
// 准备List<Student>集合
List<Student> students = new ArrayList<Student>();
students.add(new Student(1, "张A","男"));
students.add(new Student(2, "张B","男"));
students.add(new Student(3, "张C","男"));
students.add(new Student(4, "张D","男"));
students.add(new Student(5, "张E","男"));
// 分页
List<Student> results = pageRequest(pageNum, pageSize, students);
System.out.println(results);
}

通过构建上面的 pageRequest 方法,我们实现了一个简单的手工分页,通过调用该方法就能够实现对已有集合的分页,通过运行测试方法可以得到如下结果。

从结果易知在面对已存在的 List 集合时,我们基于 PageHelper 插件构建的 pageRequest 方法仍起到了分页的作用。这里指定的页码 pageNum = 2,pageSize = 3 ,待分页的集合总记录为五条,结果显示了集合中的最后两条记录,分页结果正确。

在本小节中介绍了 PageHelper.startPage 方法以及手工定义 pageRequest 方法的两种基于 PageHelper 插件的分页方式,能够根据不同的情况实现分页需求。

3. MyBatis插件的运行原理简介

第一篇文章中已经对 MyBatis 框架的运行流程进行了讲解,相信读者都已知晓 MyBatis 是利用 XMLConfigBuilder 来对配置文件进行解析的。而在前文提到插件的配置是写在 mybatis-config.xml 配置文件中,因此去 XMLConfigBuilder 类中找解析 plugins 标签的方法。

3.1 XMLConfigBuilder#pluginElement()方法

果不其然,可以找到解析 MyBatis 插件的 XMLConfigBuilder#pluginElement() 方法,如下所示:

private void pluginElement(XNode parent) throws Exception {
if (parent != null) {
// 遍历子节点
for (XNode child : parent.getChildren()) {
// 获取interceptor标签下拦截器的全限定类名
String interceptor = child.getStringAttribute("interceptor");
// 获取子节点对应的属性
Properties properties = child.getChildrenAsProperties();
// 通过上面获取得拦截器的全限定类名构建一个拦截器实例
Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
// 将子节点对应的属性设置到拦截器
interceptorInstance.setProperties(properties);
// 将该拦截器实例设置到Configuration对象
configuration.addInterceptor(interceptorInstance);
}
}
}

3.2 Interceptor接口

找到上面方法中涉及到的 Interceptor 类对于的源码如下所示:

public interface Interceptor {

  Object intercept(Invocation invocation) throws Throwable;

  Object plugin(Object target);

  void setProperties(Properties properties);

}

可以看出这是一个接口,其中定义了 intercept()、plugin() 以及 setProperties() 三个方法:

  • intercept() 方法:覆盖所拦截对象原有的方法,也是插件的核心方法。其入参是 invocation,可以利用反射调原对象的方法;
  • plugin() 方法:入参 target 是被拦截的对象,该方法的作用是生成一个被拦截对象的代理实例;
  • setProperties() 方法:方便把 MyBatis 配置文件中 plugin 标签下的内容解析后设置到 Configuration 对象。

对于一个插件来说,必须要先实现 Intercept 接口中的三个方法才能在 MyBatis 框架中进行配置并使用。

3.3 从PageHelper插件源码来看插件的实现流程

本节中会从 PageHelper 的源代码来分析 MyBatis 插件的实现流程,找到关键类 PageInterceptor 的源码如下:

// 压制警告注解
@SuppressWarnings({"rawtypes", "unchecked"})
// 拦截器的注解
@Intercepts(
{
// 注册拦截器签名:指定需要被拦截的类型(type)、方法(method)和参数(args)需要被拦截
// 只包含4个参数
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
// 只包含6个参数
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
}
)
public class PageInterceptor implements Interceptor {
// 缓存count查询的ms
protected Cache<String, MappedStatement> msCountMap = null;
private Dialect dialect;
private String default_dialect_class = "com.github.pagehelper.PageHelper";
private Field additionalParametersField;
private String countSuffix = "_COUNT"; @Override
public Object intercept(Invocation invocation) throws Throwable {
try {
// 解析拦截到的参数
Object[] args = invocation.getArgs();
MappedStatement ms = (MappedStatement) args[0];
Object parameter = args[1];
RowBounds rowBounds = (RowBounds) args[2];
ResultHandler resultHandler = (ResultHandler) args[3];
Executor executor = (Executor) invocation.getTarget();
CacheKey cacheKey;
BoundSql boundSql;
// 由于逻辑关系,只会进入一次
if(args.length == 4){
// 4个参数时
boundSql = ms.getBoundSql(parameter);
cacheKey = executor.createCacheKey(ms, parameter, rowBounds, boundSql);
} else {
// 6个参数时
cacheKey = (CacheKey) args[4];
boundSql = (BoundSql) args[5];
}
List resultList;
// 调用方法判断是否需要进行分页,如果不需要,直接返回结果
if (!dialect.skip(ms, parameter, rowBounds)) {
// 反射获取动态参数
String msId = ms.getId();
Configuration configuration = ms.getConfiguration();
Map<String, Object> additionalParameters = (Map<String, Object>) additionalParametersField.get(boundSql);
// 判断是否需要进行count查询
if (dialect.beforeCount(ms, parameter, rowBounds)) {
String countMsId = msId + countSuffix;
Long count;
// 先判断是否存在手写的count查询
MappedStatement countMs = getExistedMappedStatement(configuration, countMsId);
if(countMs != null){
count = executeManualCount(executor, countMs, parameter, boundSql, resultHandler);
} else {
countMs = msCountMap.get(countMsId);
// 自动创建
if (countMs == null) {
// 根据当前的ms创建一个返回值为Long类型的ms
countMs = MSUtils.newCountMappedStatement(ms, countMsId);
msCountMap.put(countMsId, countMs);
}
count = executeAutoCount(executor, countMs, parameter, boundSql, rowBounds, resultHandler);
}
// 处理查询总数
// 返回true时继续分页查询,false时直接返回
if (!dialect.afterCount(count, parameter, rowBounds)) {
// 当查询总数为0时,直接返回空的结果
return dialect.afterPage(new ArrayList(), parameter, rowBounds);
}
}
// 判断是否需要进行分页查询
if (dialect.beforePage(ms, parameter, rowBounds)) {
// 生成分页的缓存key
CacheKey pageKey = cacheKey;
// 处理参数对象
parameter = dialect.processParameterObject(ms, parameter, boundSql, pageKey);
// 调用方言获取分页sql
String pageSql = dialect.getPageSql(ms, boundSql, parameter, rowBounds, pageKey);
BoundSql pageBoundSql = new BoundSql(configuration, pageSql, boundSql.getParameterMappings(), parameter);
// 设置动态参数
for (String key : additionalParameters.keySet()) {
pageBoundSql.setAdditionalParameter(key, additionalParameters.get(key));
}
// 执行分页查询
resultList = executor.query(ms, parameter, RowBounds.DEFAULT, resultHandler, pageKey, pageBoundSql);
} else {
// 不执行分页的情况下,也不执行内存分页
resultList = executor.query(ms, parameter, RowBounds.DEFAULT, resultHandler, cacheKey, boundSql);
}
} else {
// rowBounds用参数值,不使用分页插件处理时,仍然支持默认的内存分页
resultList = executor.query(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);
}
return dialect.afterPage(resultList, parameter, rowBounds);
} finally {
dialect.afterAll();
}
} // 省略…… @Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
} @Override
public void setProperties(Properties properties) {
// 缓存count ms
msCountMap = CacheFactory.createCache(properties.getProperty("msCountCache"), "ms", properties);
String dialectClass = properties.getProperty("dialect");
if (StringUtil.isEmpty(dialectClass)) {
dialectClass = default_dialect_class;
}
try {
Class<?> aClass = Class.forName(dialectClass);
dialect = (Dialect) aClass.newInstance();
} catch (Exception e) {
throw new PageException(e);
}
dialect.setProperties(properties); String countSuffix = properties.getProperty("countSuffix");
if (StringUtil.isNotEmpty(countSuffix)) {
this.countSuffix = countSuffix;
} try {
// 反射获取BoundSql中的additionalParameters属性
additionalParametersField = BoundSql.class.getDeclaredField("additionalParameters");
additionalParametersField.setAccessible(true);
} catch (NoSuchFieldException e) {
throw new PageException(e);
}
}
}

简单看完 PageHelper 插件的实现代码之后,总结一下 MyBatis 框架中自定义插件的步骤:

  • 确定要被拦截的签名:根据 @Intercepts 以及 @Signature 注解指定需要拦截的参数;
  • 实现 Intercept 接口的 intercept()、plugin() 以及 setProperties() 方法。

4. 自定义一个MyPageHelper分页插件

本节中会借鉴 PageHelper 插件的实现思路来实现自定义一个 MyPageHelper 插件,以更好地理解 MyBatis 框架运行插件的流程。

4.1 MyPage类

本小节中实现了自定义的 MyPage 类,这是一个分页返回对象,封装了分页的相关信息以及分页的列表数据,如下所示:

@Getter
public class MyPage<E> extends ArrayList<E> { private static final long serialVersionUID = 2630741492557235098L;
/** 指定页码,从1开始 **/
@Setter
private Integer pageNum; /** 指定每页记录数 **/
@Setter
private Integer pageSize; /** 起始行 **/
@Setter
private Integer startIndex; /** 末行 **/
@Setter
private Integer endIndex; /** 总记录数 **/
private Long total; /** 总页数 **/
@Setter
private Integer pages; // 根据pageNum、pageSize以及total设置其它属性
public void setTotal(Long total) {
this.total = total;
this.pages = (int)(total / pageSize + (total % pageSize == 0 ? 0 : 1));
if (pageNum > pages) {
pageNum = pages;
}
this.startIndex = this.pageNum > 0 ? (this.pageNum - 1) * this.pageSize : 0;
this.endIndex = this.startIndex + this.pageSize * (this.pageNum > 0 ? 1 : 0);
} // 获取分页后的结果
public List<E> getResults() {
return this;
}
}

4.2 MyPageHelper类

进一步定义一个 MyPageHelper 类来辅助分页,该类的核心是利用 ThreadLocal 线程遍历存储分页信息,代码如下所示:

/**
* 分页帮助类
* @author chenliang258
* @date 2021/3/17 17:23
*/
@SuppressWarnings("rawtypes")
public class MyPageHelper { private static final ThreadLocal<MyPage> MY_PAGE_THREAD_LOCAL = new ThreadLocal<>(); public static void setMyPageThreadLocal(MyPage myPage) {
MY_PAGE_THREAD_LOCAL.set(myPage);
} public static MyPage geyMyPageThreadLocal() {
return MY_PAGE_THREAD_LOCAL.get();
} public static void clearMyPageThreadLocal() {
MY_PAGE_THREAD_LOCAL.remove();
} public static void startPage(Integer pageNum, Integer pageSize) {
MyPage myPage = new MyPage();
myPage.setPageNum(pageNum);
myPage.setPageSize(pageSize);
setMyPageThreadLocal(myPage);
}
}

4.3 MyPageInterceptor类

接下来就需要编写 Interceptor 接口的实现类来实现相应方法,这里定义了 MyPageInterceptor 类,代码如下:

package com.chiaki.mypagehelper;

import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ResultMap;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds; import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties; /**
* 分页拦截器实现
* @author chenliang258
* @date 2021/3/17 17:30
*/
@Intercepts({
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class})
})
public class MyPageInterceptor implements Interceptor { private Field field; @SuppressWarnings({"rawtypes", "unchecked"})
@Override
public Object intercept(Invocation invocation) throws Throwable {
Executor executor = (Executor)invocation.getTarget();
Object[] args = invocation.getArgs();
MappedStatement ms = (MappedStatement)args[0];
Object parameter = args[1];
RowBounds rowBounds = (RowBounds)args[2];
ResultHandler resultHandler = (ResultHandler)args[3];
CacheKey cacheKey;
BoundSql boundSql;
// 4个参数
if (args.length == 4) {
boundSql = ms.getBoundSql(parameter);
cacheKey = executor.createCacheKey(ms, parameter, rowBounds, boundSql);
}
// 6个参数
else {
cacheKey = (CacheKey)args[4];
boundSql = (BoundSql)args[5];
}
// 判断是否需要分页
MyPage myPage = MyPageHelper.geyMyPageThreadLocal();
// 不执行分页
if (myPage.getPageNum() <= 0) {
return executor.query(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);
}
// count查询
MappedStatement countMs = newCountMappedStatement(ms);
String sql = boundSql.getSql();
String countSql = "select count(1) from (" + sql + ") _count";
BoundSql countBoundSql =
new BoundSql(ms.getConfiguration(), countSql, boundSql.getParameterMappings(), parameter);
Map<String, Object> additionalParameters = (Map<String, Object>) field.get(boundSql);
for (Map.Entry<String, Object> additionalParameter : additionalParameters.entrySet()) {
countBoundSql.setAdditionalParameter(additionalParameter.getKey(), additionalParameter.getValue());
}
CacheKey countCacheKey = executor.createCacheKey(countMs, parameter, rowBounds, countBoundSql);
Object countResult = executor.query(countMs, parameter, RowBounds.DEFAULT, resultHandler, countCacheKey, countBoundSql);
Long count = (Long)((List)countResult).get(0);
myPage.setTotal(count);
// 分页查询
String pageSql = sql + " limit " + myPage.getStartIndex() + "," + myPage.getPageSize();
BoundSql pageBoundSql = new BoundSql(ms.getConfiguration(), pageSql, boundSql.getParameterMappings(), parameter);
for (Map.Entry<String, Object> additionalParameter : additionalParameters.entrySet()) {
pageBoundSql.setAdditionalParameter(additionalParameter.getKey(), additionalParameter.getValue());
}
CacheKey pageCacheKey = executor.createCacheKey(ms, parameter, rowBounds, pageBoundSql);
List listResult = executor.query(ms, parameter, RowBounds.DEFAULT, resultHandler, pageCacheKey, pageBoundSql);
myPage.addAll(listResult);
// 清空线程局部变量分页信息
MyPageHelper.clearMyPageThreadLocal();
return myPage;
} @Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
} @Override
public void setProperties(Properties properties) {
try {
field = BoundSql.class.getDeclaredField("additionalParameters");
field.setAccessible(true);
} catch (NoSuchFieldException | SecurityException e) {
e.printStackTrace();
}
} /**
* 创建count的MappedStatement
*
* @param ms 原始MappedStatement
* @return 新的带有分页信息的MappedStatement
*/
private MappedStatement newCountMappedStatement(MappedStatement ms) {
MappedStatement.Builder builder = new MappedStatement.Builder(ms.getConfiguration(), ms.getId() + "_count",
ms.getSqlSource(), ms.getSqlCommandType());
builder.resource(ms.getResource());
builder.fetchSize(ms.getFetchSize());
builder.statementType(ms.getStatementType());
builder.keyGenerator(ms.getKeyGenerator());
if (ms.getKeyProperties() != null && ms.getKeyProperties().length != 0) {
StringBuilder keyProperties = new StringBuilder();
for (String keyProperty : ms.getKeyProperties()) {
keyProperties.append(keyProperty).append(",");
}
keyProperties.delete(keyProperties.length() - 1, keyProperties.length());
builder.keyProperty(keyProperties.toString());
}
builder.timeout(ms.getTimeout());
builder.parameterMap(ms.getParameterMap());
// count查询返回值int
List<ResultMap> resultMaps = new ArrayList<>();
ResultMap resultMap = new ResultMap.Builder(ms.getConfiguration(), ms.getId() + "_count", Long.class,
new ArrayList<>(0)).build();
resultMaps.add(resultMap);
builder.resultMaps(resultMaps);
builder.resultSetType(ms.getResultSetType());
builder.cache(ms.getCache());
builder.flushCacheRequired(ms.isFlushCacheRequired());
builder.useCache(ms.isUseCache()); return builder.build();
}
}

4.4 MyPageHelper插件测试

要测试自定义的 MyPageHelper 插件,首先必须要在 mybatis-config.xml 配置文件中添加自定义插件的配置信息,如下所示:

<plugins>
<!-- 使用自定义插件MyPageHelper -->
<plugin interceptor="com.chiaki.mypagehelper.MyPageInterceptor" />
</plugins>

然后编写 MyPageHelper 插件的测试方法,如下所示:

@Test
public void testMyPageHelper() {
Integer pageNum = 2, pageSize = 3;
StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
MyPageHelper.startPage(pageNum, pageSize);
List<Student> students = studentMapper.findAll();
System.out.println(students);
}

运行测试方法后,其结果如下图所示。可以看出在数据库表中共有 4 条记录,在设置了 pageNum = 2, pageSize = 3 参数后,查询结果显示的是第二页的数据,仅此 1 条,结果符合预期,这也验证了本节中自定义 MyPageHelper 分页插件的正确性。

总结

本文首先介绍了 MyBatis 框架使用中比较实用的 Lombok 以及 PageHelper 插件,然后从 PageHelper 插件出发简单介绍了 MyBatis 框架中插件的解析与运行流程,并在此基础上实现了一个自定义的 MyPageHelper 分页插件。笔者认为在实际应用中不必重复造轮子,有好用的插件直接使用就行,大大提高开发效率。但是从另外一个角度看,所谓知其然也要知其所以然,从源码去理解实现原理并能够自己动手实现一遍对于个人的进步是非常有用的。本文中只是很简略地介绍了下 MyBatis 的插件解析与运行过程,实现的 MyPageHelper 插件也处于模仿的层面。读者感兴趣的话可以自行去探究源码,能够在模仿中创新是最好不过了!

参考资料

Lombok 官方社区:https://projectlombok.org/

PageHelper 官方社区:https://pagehelper.github.io/

MyBatis 官网:https://mybatis.org/mybatis-3/

MyBatis 源码仓库:https://github.com/mybatis/mybatis-3

浅析MyBatis(一):由一个快速案例剖析MyBatis的整体架构与运行流程

浅析MyBatis(二):手写一个自己的MyBatis简单框架

觉得有用的话就点个推荐吧~

浅析MyBatis(三):聊一聊MyBatis的实用插件与自定义插件的更多相关文章

  1. maven学习(五)插件和自定义插件

    插件是可以配置在settings.xml和pom.xml中的 插件目标: 在了解插件和生命周期的绑定关系之前,先来说一下插件目标.在实际项目构建的过程中,需要经历编译.打包等等许许多多的操作,为每个操 ...

  2. Mybatis(三):MyBatis缓存详解

    MyBatis缓存分为一级缓存和二级缓存 一级缓存 MyBatis的一级缓存指的是在一个Session域内,session为关闭的时候执行的查询会根据SQL为key被缓存(跟mysql缓存一样,修改任 ...

  3. Cordova与现有框架的结合,Cordova插件使用教程,Cordova自定义插件,框架集成Cordova,将Cordova集成到现有框架中

    一.框架集成cordova 将cordova集成到现有框架中 一般cordova工程是通过CMD命令来创建一个工程并添加Android.ios等平台,这样的创建方式可以完整的下载开发过程中所需要的的插 ...

  4. 深入学习jQuery自定义插件

    原文地址:jQuery自定义插件学习 1.定义插件的方法 对象级别的插件扩展,即为jQuery类的实例增加方法, 调用:$(选择器).函数名(参数);      $(‘#id’).myPlugin(o ...

  5. jQuery自定义插件--banner图滚动

    前言 jQuery是一个功能强大的库,提供了开发JavaScript项目所需的所有核心函数.很多时候我们使用jQuery的原因就是因为其使用插件的功能,然而,有时候我们还是需要使用自定义代码来扩展这些 ...

  6. Springboot 系列(十二)使用 Mybatis 集成 pagehelper 分页插件和 mapper 插件

    前言 在 Springboot 系列文章第十一篇里(使用 Mybatis(自动生成插件) 访问数据库),实验了 Springboot 结合 Mybatis 以及 Mybatis-generator 生 ...

  7. Mybatis框架(8)---Mybatis插件原理

    Mybatis插件原理 在实际开发过程中,我们经常使用的Mybaits插件就是分页插件了,通过分页插件我们可以在不用写count语句和limit的情况下就可以获取分页后的数据,给我们开发带来很大 的便 ...

  8. Mybatis分页-利用Mybatis Generator插件生成基于数据库方言的分页语句,统计记录总数 (转)

    众所周知,Mybatis本身没有提供基于数据库方言的分页功能,而是基于JDBC的游标分页,很容易出现性能问题.网上有很多分页的解决方案,不外乎是基于Mybatis本机的插件机制,通过拦截Sql做分页. ...

  9. spring与mybatis三种整合方法

    spring与mybatis三种整合方法 本文主要介绍Spring与Mybatis三种常用整合方法,需要的整合架包是mybatis-spring.jar,可通过链接 http://code.googl ...

随机推荐

  1. 图解 git stash

    图解 git stash # 暂存本地 变化 $ git stash # 复原 $ git stash pop The "git stash" command can help y ...

  2. Web 安全 & cookies & HttpOnly

    Web 安全 & cookies & HttpOnly cookie HttpOnly 禁止 js 读取 cookie 的方法 HttpOnly 实现原理 document.cooki ...

  3. react slot component with args

    react slot component with args how to pass args to react props child component https://codesandbox.i ...

  4. 小程序 & taro 踩坑指南

    小程序 & taro 踩坑指南 微信开发者工具, 不支持 react bug https://github.com/NervJS/taro/issues/5042 solution just ...

  5. C++算法代码——[TYVJ]单数?双数?

    题目来自:http://218.5.5.242:9018/JudgeOnline/problem.php?id=1178 题目描述 Bessie那惨无人道的二年级老师搞了一个有  N  (1  < ...

  6. 10_MySQL数据表的基本查询

    为了更好的练习数据表的操作,我们需要有些数据来供我们练习,这里给大家分享一份数据,大家可以拿去自己练习使用. 文件地址:https://files.cnblogs.com/files/waterr/d ...

  7. [Python] 基于 jieba 的中文分词总结

    目录 模块安装 开源代码 基本用法 启用Paddle 词性标注 调整词典 智能识别新词 搜索引擎模式分词 使用自定义词典 关键词提取 停用词过滤 模块安装 pip install jieba jieb ...

  8. Spark集成

    一.Spark 架构与优化器 1.Spark架构 (重点) 2.Spark优化器 二.Spark+SQL的API (重点) 1.DataSet简介 2.DataFrame简介 3.RDD与DF/DS的 ...

  9. IdentityServer4之持久化很顺手的事

    前言 原计划打算在春节期间多分享几篇技术文章的,但到最后一篇也没出,偷懒了吗?算是吧,过程是这样的:每次拿出电脑,在孩姥姥家的院子总有阳光沐浴,看不清屏幕,回屋又有点冷(在强行找理由),于是又带着娃遛 ...

  10. python进阶(4)文件操作

    文件操作 文件操作主要包括对文件内容的读写操作,这些操作是通过文件对象实现的,通过文件对象可以读写文本文件和二进制文件 open(file, mode='r', buffering=-1, encod ...