wen Mybatis 插件使用及源码分析
Mybatis 插件
Mybatis插件主要是通过JDK动态代理实现的，插件可以针对接口中的方法进行代理增强，在Mybatis中比较重要的接口如下：
Executor：sql执行器，包含多个实现类，比如SimpleExecutorStatementHander：sql语句处理器，用于将sql语句与Statement的映射，实现类有：PrepareStatementHandler、SimpleStatementHandler、CallBackStatementHandlerParameterHandler：用于参数处理，将传入的参数一一的解析并将类型解析出来，会用到TypeHandler,最终这些数据会用于StatementHandler进行数据的映射，比如？对应的值的映射ResultSetHandler：结果值的处理器，用于数据在查询出来之后，将数据通过ResultSet把数据映射给返回值类型的类上，通过反射（内省）处理映射数据
Mybatis插件的使用
Mybatis插件使用通过@Intercepts注解进行接口的绑定，如下定义一个插件类
/**
* @author <a href="2360564660@qq.com">redwinter</a>
* @since 1.0
**/
@Intercepts({@Signature(
type = StatementHandler.class,
method = "prepare",
args = {Connection.class, Integer.class}
)})
@Slf4j
public class MyPlugin implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
log.info("对方法进行增强....");
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
log.info("获取属性值：{}", properties);
}
}
然后需要将定义的插件配置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>
<!-- 引用db.properties配置文件 -->
<properties resource="db.properties"/>
<!--在 MyBatis 配置文件 mybatis-config.xml 里面添加一项 setting 来选择其它日志实现，
可选的值有：SLF4J、LOG4J、LOG4J2、JDK_LOGGING、COMMONS_LOGGING、STDOUT_LOGGING、NO_LOGGING，
或者是实现了 org.apache.ibatis.logging.Log 接口，且构造方法以字符串为参数的类完全限定名。-->
<settings>
<!-- 打印sql日志 -->
<setting name="logImpl" value="STDOUT_LOGGING" />
<!--开启二级缓存-->
<setting name="cacheEnabled" value="true"/>
</settings>
<typeAliases>
<package name="com.redwinter.study.mybatis.model"/>
</typeAliases>
<!--mybatis插件的配置 -->
<plugins>
<plugin interceptor="mybatis.plugins.MyPlugin">
<property name="redwinter" value="冬玲"/>
</plugin>
<plugin interceptor="com.github.pagehelper.PageInterceptor">
<!--不能配置方言，配置后分页失效-->
<!-- <property name="dialect" value="com.github.pagehelper.dialect.rowbounds.MySqlRowBoundsDialect"/>-->
</plugin>
</plugins>
<!--
development : 开发模式
work : 工作模式
-->
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<!-- 配置数据库连接信息 -->
<dataSource type="POOLED">
<!-- value属性值引用db.properties配置文件中配置的值 -->
<property name="driver" value="${driver}" />
<property name="url" value="${url}" />
<property name="username" value="${name}" />
<property name="password" value="${password}" />
</dataSource>
</environment>
</environments>
<mappers>
<!-- <mapper resource="mappers/UserMapper.xml"/>-->
<package name="mybatis.mapper"/>
</mappers>
</configuration>
这样就可以生效了，当我们执行数据查询的时候，只要是执行了StatementHandler#prepare方法，那么都会执行到自定的逻辑增强
日志如下：
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1386958]
16:02:38.260 [main] INFO mybatis.plugins.MyPlugin - 对方法进行增强....
==> Preparing: update user set name = ?, age = ? where id = ?
==> Parameters: 李四(String), 19(Integer), 1(Integer)
<== Updates: 1
Committing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1386958]
Cache Hit Ratio [mybatis.mapper.UserMapper]: 0.5
16:02:38.303 [main] INFO mybatis.plugins.MyPlugin - 对方法进行增强....
==> Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<== Columns: id, age, name
<== Row: 1, 19, 李四
<== Total: 1
false
源码分析
首先我们自定义的插件，需要配置到xml文件中，然后在启动程序的时候，会先创建SqlSession，那么在之前需要进行xml的解析，在Mybatis中解析时通过SqlSessionFactoryBuilder创建一个SqlSessionFactory，然后在通过SqlSessionFactory创建一个SqlSession。在这个过程中，SqlSesssionFactoryBuilder会去创建一个XmlConfigBuilder去解析Xml配置，在XmlConfigBuilder的构造函数中会创建Configuration类，这个类中保存了Mybatis的所有配置。
然后XmlConfigBuilder调用parse方法开始解析配置，解析时会根据xml中的配置一一解析，并且解析是有顺序的以来，解析的顺序是：
properties用于配置外部资源的属性配置，比如配置jdbc的配置文件用于下面的环境信息配置settings用于设置Mybatis内置的设置，比如日志、缓存等，这些配置其实都是Configuration类中的setter方法的配置，Mybatis使用反射（内省）将Configuration的属性通过Properties对象key-value一一进行了对应。typeAliases用于配置别名的配置，在Mybatis中默认了很多的别名，比如Java的基本数据类型，常用了的集合对象，日期对象等都进行了提前的别名配置，这些配置都会注册到TypeAliasRegistry的一个Map中。plugins用于插件的配置，比如自定义的插件，Mybatis的插件是通过JDK动态代理进行增强操作的，Mybatis提供了Interceptor接口，最终会将这些接口全部加载Interceptor加入到InterceptorChain中的List集合中。objectFactory、objectWrapperFactory、reflectorFactory这些不怎么常用enviroments用于配置环境信息的，比如JDBC数据源的信息，这个配置可以配置多个环境，比如开发环境，生产环境等databaseIdProvider这个也不常用typeHandlers类型处理器的配置mappers用于配置Mapper.xml的配置或者Mapper接口的配置，可以配置包路径，xml的路径资源
SqlSessionFactoryBuilder#build方法：
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
try {
// 创建一个解析xml的构建器，构造函数中会创建一个Configuration类
XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
// 解析xml配置
return build(parser.parse());
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error building SqlSession.", e);
} finally {
ErrorContext.instance().reset();
try {
if (inputStream != null) {
inputStream.close();
}
} catch (IOException e) {
// Intentionally ignore. Prefer previous error.
}
}
}
创建XMLConfiBuilder类
private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
super(new Configuration());
ErrorContext.instance().resource("SQL Mapper Configuration");
this.configuration.setVariables(props);
this.parsed = false;
this.environment = environment;
this.parser = parser;
}
创建Configuration类
public Configuration() {
// 添加别名
typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);
typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
typeAliasRegistry.registerAlias("LRU", LruCache.class);
typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
typeAliasRegistry.registerAlias("WEAK", WeakCache.class);
typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);
typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);
typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);
typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);
languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
languageRegistry.register(RawLanguageDriver.class);
}
创建TypeAliasRegistry类
private final Map<String, Class<?>> typeAliases = new HashMap<>();
public TypeAliasRegistry() {
// 注册别名，最终全部会注册到Map中
registerAlias("string", String.class);
registerAlias("byte", Byte.class);
registerAlias("char", Character.class);
registerAlias("character", Character.class);
registerAlias("long", Long.class);
registerAlias("short", Short.class);
registerAlias("int", Integer.class);
registerAlias("integer", Integer.class);
registerAlias("double", Double.class);
registerAlias("float", Float.class);
registerAlias("boolean", Boolean.class);
registerAlias("byte[]", Byte[].class);
registerAlias("char[]", Character[].class);
registerAlias("character[]", Character[].class);
registerAlias("long[]", Long[].class);
registerAlias("short[]", Short[].class);
registerAlias("int[]", Integer[].class);
registerAlias("integer[]", Integer[].class);
registerAlias("double[]", Double[].class);
registerAlias("float[]", Float[].class);
registerAlias("boolean[]", Boolean[].class);
registerAlias("_byte", byte.class);
registerAlias("_char", char.class);
registerAlias("_character", char.class);
registerAlias("_long", long.class);
registerAlias("_short", short.class);
registerAlias("_int", int.class);
registerAlias("_integer", int.class);
registerAlias("_double", double.class);
registerAlias("_float", float.class);
registerAlias("_boolean", boolean.class);
registerAlias("_byte[]", byte[].class);
registerAlias("_char[]", char[].class);
registerAlias("_character[]", char[].class);
registerAlias("_long[]", long[].class);
registerAlias("_short[]", short[].class);
registerAlias("_int[]", int[].class);
registerAlias("_integer[]", int[].class);
registerAlias("_double[]", double[].class);
registerAlias("_float[]", float[].class);
registerAlias("_boolean[]", boolean[].class);
registerAlias("date", Date.class);
registerAlias("decimal", BigDecimal.class);
registerAlias("bigdecimal", BigDecimal.class);
registerAlias("biginteger", BigInteger.class);
registerAlias("object", Object.class);
registerAlias("date[]", Date[].class);
registerAlias("decimal[]", BigDecimal[].class);
registerAlias("bigdecimal[]", BigDecimal[].class);
registerAlias("biginteger[]", BigInteger[].class);
registerAlias("object[]", Object[].class);
registerAlias("map", Map.class);
registerAlias("hashmap", HashMap.class);
registerAlias("list", List.class);
registerAlias("arraylist", ArrayList.class);
registerAlias("collection", Collection.class);
registerAlias("iterator", Iterator.class);
registerAlias("ResultSet", ResultSet.class);
}
调用XMLConfigBuilder#parse方法
public Configuration parse() {
if (parsed) {
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
}
parsed = true;
// 解析配置，从根的configuration的标签开始
parseConfiguration(parser.evalNode("/configuration"));
return configuration;
}
private void parseConfiguration(XNode root) {
try {
// issue #117 read properties first
propertiesElement(root.evalNode("properties"));
Properties settings = settingsAsProperties(root.evalNode("settings"));
loadCustomVfs(settings);
// 加载自定义的日志打印
loadCustomLogImpl(settings);
// 解析别名
typeAliasesElement(root.evalNode("typeAliases"));
// 添加插件
pluginElement(root.evalNode("plugins"));
objectFactoryElement(root.evalNode("objectFactory"));
objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
reflectorFactoryElement(root.evalNode("reflectorFactory"));
// 设置默认的配置
settingsElement(settings);
// read it after objectFactory and objectWrapperFactory issue #631
// 解析环境信息
environmentsElement(root.evalNode("environments"));
databaseIdProviderElement(root.evalNode("databaseIdProvider"));
// 解析类型处理器标签
typeHandlerElement(root.evalNode("typeHandlers"));
// 解析mappers标签
mapperElement(root.evalNode("mappers"));
} catch (Exception e) {
throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
}
}
解析插件标签：
private void pluginElement(XNode parent) throws Exception {
if (parent != null) {
for (XNode child : parent.getChildren()) {
String interceptor = child.getStringAttribute("interceptor");
Properties properties = child.getChildrenAsProperties();
Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).getDeclaredConstructor().newInstance();
interceptorInstance.setProperties(properties);
// 将插件全部加入到配置中,最终会加载到InterceptorChain类的List集合中
configuration.addInterceptor(interceptorInstance);
}
}
}
当我们调用方法执行Sql的时候，Mybatis会通过SqlSession去委派调用Executor的接口的方法进行执行。比如我们调用selectList(statementId) 去执行查询，那么会调用：
private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
try {
// 获取Mapper中解析的配置，这个类中存放了sql语句，返回类型，参数类型等
MappedStatement ms = configuration.getMappedStatement(statement);
return executor.query(ms, wrapCollection(parameter), rowBounds, handler);
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
调用query方法就会委派到Executor接口的实现类BaseExecutor类中进行执行：
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
// 获取sql语句，解析出sql语句，参数类型，参数值等数据
BoundSql boundSql = ms.getBoundSql(parameter);
// 创建一个缓存key，用于缓存存储使用
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
调用query重载方法：如果缓存中有，那么就从缓存中获取，如果没有那么执行数据库查询
@SuppressWarnings("unchecked")
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
if (closed) {
throw new ExecutorException("Executor was closed.");
}
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
List<E> list;
try {
queryStack++;
// 从缓存中获取数据
list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
if (list != null) {
handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
// 查询数据从数据库
list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
} finally {
queryStack--;
}
if (queryStack == 0) {
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
// issue #601
deferredLoads.clear();
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
// issue #482
clearLocalCache();
}
}
return list;
}
最终会中到SimpleExecutor实现类的doQuery方法去真正执行查询：
@Override
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
Statement stmt = null;
try {
// 获取配置
Configuration configuration = ms.getConfiguration();
// 创建一个StatementHandler
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
stmt = prepareStatement(handler, ms.getStatementLog());
return handler.query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
在调用newStatementHandler方法是会执行到插件的pluginAll方法，执行动态代理的创建代理对象：
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
// 这里拿到的是一个代理对象
statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
return statementHandler;
}
拦截器链去调用pluginAll，然后调用Interceptor的plugin方法创建代理对象:
public Object pluginAll(Object target) {
for (Interceptor interceptor : interceptors) {
// 遍历所有的插件，然后执行plugin方法，获取到代理的对象
target = interceptor.plugin(target);
}
return target;
}
// Interceptor的默认接口方法plugin
default Object plugin(Object target) {
return Plugin.wrap(target, this);
}
// Plugin类中的包装创建一个代理对象
public static Object wrap(Object target, Interceptor interceptor) {
// 获取类和方法集合
Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
Class<?> type = target.getClass();
// 目标的接口，代理生成的接口
Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
if (interfaces.length > 0) {
// 创建一个jdk动态代理
return Proxy.newProxyInstance(
type.getClassLoader(),
interfaces,
new Plugin(target, interceptor, signatureMap));
}
return target;
}
这样的话就完成了拦截器插件的代理对象的创建，这里创建出来的代理对象就是StatementHandler，在前面自定义的插件，配置的是拦截StatementHandler#prepare方法，那么在哪里执行的呢？
回到Executor接口实现类SimpleExecutor了中doQuery方法，这个方法中会去创建一个预编译SQL处理器，执行prepareStatement方法：
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
Statement stmt;
// 获取一个数据库连接
Connection connection = getConnection(statementLog);
// 获取Statement 这里可能获取到PrepareStatement 、SimpleStatement、CallbackStatement
stmt = handler.prepare(connection, transaction.getTimeout());
// 设置参数
handler.parameterize(stmt);
return stmt;
}
这里的话就会调用prepare方法，这个方法就是自定义插件配置需要拦截的方法，由于这个handler是一个代理对象，我们都知道只要是代理对象，只要执行代理对象的任何方法都会去执行InvoketionHandler接口的invoke方法，当执行到这个方法的时候就会调用到我们自定义的插件类中intercept方法：
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
Set<Method> methods = signatureMap.get(method.getDeclaringClass());
if (methods != null && methods.contains(method)) {
// 如果拦截的方法与执行的方法一致那么执行intercept方法进行增加强
return interceptor.intercept(new Invocation(target, method, args));
}
// 如果不是则执行方法即可
return method.invoke(target, args);
} catch (Exception e) {
throw ExceptionUtil.unwrapThrowable(e);
}
}
所以只要我们执行了sql查询，那么都会通过JDK动态代理创建的代理对象去执行到这个增强方法。
插件的扩展
在Mybatis中有个分页的插件叫PageHelper，这个插件就是使用了Mybatis插件机制完成的，当然还有比如早期的TkMapper插件。接下来分析一下PageHelper是如何实现分页机制的。
引入依赖：
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.3.0</version>
</dependency>
然后在mybatis-config.xml配置文件中配置插件让分页插件生效：
<plugins>
<plugin interceptor="mybatis.plugins.MyPlugin">
<property name="redwinter" value="冬玲"/>
</plugin>
<plugin interceptor="com.github.pagehelper.PageInterceptor">
<!--不能配置方言，配置后分页失效-->
<!-- <property name="dialect" value="com.github.pagehelper.dialect.rowbounds.MySqlRowBoundsDialect"/>-->
</plugin>
</plugins>
然后就可以直接使用了：
@Test
public void testPageHelper() {
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
// 设置分页参数
PageHelper.startPage(1, 2);
List<User> users = mapper.selectAll();
// 构建分页信息
PageInfo<User> pageInfo = new PageInfo<User>(users);
System.out.println(pageInfo);
}
日志如下：
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@14a2528]
11:06:43.511 [main] INFO mybatis.plugins.MyPlugin - 对方法进行增强....
==> Preparing: SELECT count(0) FROM user
==> Parameters:
<== Columns: count(0)
<== Row: 3
<== Total: 1
Cache Hit Ratio [mybatis.mapper.UserMapper]: 0.0
11:06:43.562 [main] INFO mybatis.plugins.MyPlugin - 对方法进行增强....
==> Preparing: select * from user LIMIT ?
==> Parameters: 2(Integer)
<== Columns: id, age, name
<== Row: 1, 19, 李四
<== Row: 2, null, 里斯
<== Total: 2
PageInfo{pageNum=1, pageSize=2, size=2, startRow=1, endRow=2, total=3, pages=2, list=Page{count=true, pageNum=1, pageSize=2, startRow=0, endRow=2, total=3, pages=2, reasonable=false, pageSizeZero=false}[User(id=1, age=19, name=李四), User(id=2, age=0, name=里斯)], prePage=0, nextPage=2, isFirstPage=true, isLastPage=false, hasPreviousPage=false, hasNextPage=true, navigatePages=8, navigateFirstPage=1, navigateLastPage=2, navigatepageNums=[1, 2]}
可以看到这里执行了两条sql语句，一个是查询总条数，一个是分页查询，那PageHelper怎么实现的呢？
PageHelper 分页源码解析
由于我们在mybatis-config.xml中配置了分页插件，那么直接进PageInterceptor这个类去看看，找到intercept方法：
@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];
}
checkDialectExists();
//对 boundSql 的拦截处理
if (dialect instanceof BoundSqlInterceptor.Chain) {
boundSql = ((BoundSqlInterceptor.Chain) dialect).doBoundSql(BoundSqlInterceptor.Type.ORIGINAL, boundSql, cacheKey);
}
List resultList;
//调用方法判断是否需要进行分页，如果不需要，直接返回结果
if (!dialect.skip(ms, parameter, rowBounds)) {
//判断是否需要进行 count 查询
if (dialect.beforeCount(ms, parameter, rowBounds)) {
//查询总数
Long count = count(executor, ms, parameter, rowBounds, null, boundSql);
//处理查询总数，返回 true 时继续分页查询，false 时直接返回
if (!dialect.afterCount(count, parameter, rowBounds)) {
//当查询总数为 0 时，直接返回空的结果
return dialect.afterPage(new ArrayList(), parameter, rowBounds);
}
}
resultList = ExecutorUtil.pageQuery(dialect, executor,
ms, parameter, rowBounds, resultHandler, boundSql, cacheKey);
} else {
//rowBounds用参数值，不使用分页插件处理时，仍然支持默认的内存分页
resultList = executor.query(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);
}
return dialect.afterPage(resultList, parameter, rowBounds);
} finally {
if(dialect != null){
dialect.afterAll();
}
}
}
根据Debug发现这返回的对象实际上是一个Page对象，这个对象继承ArrayList，所以在查询多个数据时可以直接通过List集合获取，最终在分装到PageInfo对象中就完成了分页数据的封装。那么这些分页数据是何时设置进去的呢？
实际上在进行PageHelper.startPage(1, 2);时，这个参数设置在ThreadLocal中，在PageMethod类中：
/**
* 开始分页
*
* @param pageNum 页码
* @param pageSize 每页显示数量
* @param count 是否进行count查询
* @param reasonable 分页合理化,null时用默认配置
* @param pageSizeZero true且pageSize=0时返回全部结果，false时分页,null时用默认配置
*/
public static <E> Page<E> startPage(int pageNum, int pageSize, boolean count, Boolean reasonable, Boolean pageSizeZero) {
Page<E> page = new Page<E>(pageNum, pageSize, count);
page.setReasonable(reasonable);
page.setPageSizeZero(pageSizeZero);
//当已经执行过orderBy的时候
Page<E> oldPage = getLocalPage();
if (oldPage != null && oldPage.isOrderByOnly()) {
page.setOrderBy(oldPage.getOrderBy());
}
setLocalPage(page);
return page;
}
调用setLocalPage方法就会设置到ThreadLocal中：
protected static final ThreadLocal<Page> LOCAL_PAGE = new ThreadLocal<Page>();
protected static boolean DEFAULT_COUNT = true;
/**
* 设置 Page 参数
*
* @param page
*/
protected static void setLocalPage(Page page) {
LOCAL_PAGE.set(page);
}
在执行查询的到时候会调用到getLocalPage方法获取ThreadLocal中的参数，然后设置到分页参数中并构建出sql语句用于分页查询，在执行完之后会在finally中调用clearPage清除掉ThreadLoacl中的数据。
