2021一路有你,2022我们继续加油!你的肯定是我最大的动力
博主在参加博客之星评比,点击链接 , https://bbs.csdn.net/topics/603957267 疯狂打Call!五星好评 感谢
前言
面试官:用过pagehelper做分页把,你说一下pagehelper的分页实现原理。额…此时你只能说我不知道。如果你事先看了我接下来的这篇文章,相信你一定也把这个面试题答得很好。
认识Mybatis插件(拦截器)
SpringMVC的拦截器相信大家都清楚,作用是在Controller执行前或执行后拦截器请求从而实现对请求做增强,比如:登录检查等。在mybais中也有拦截器(当然它应该叫插件,我觉得叫拦截器更贴切),它拦截的是发向数据库的请求,达到增强Mybatis的目的,道理都差不多。
下面的文字是Mybatis官方文档对拦截器的描述
MyBatis 允许你在映射语句执行过程中的某一点进行拦截调用。默认情况下,MyBatis 允许使用插件来拦截的方法调用包括:
• Executor(update, query, flushStatements, commit, rollback,getTransaction, close,isClosed)
• ParameterHandler(getParameterObject, setParameters)
• ResultSetHandler(handleResultSets, handleOutputParameters)
• StatementHandler(prepare, parameterize, batch, update, query)
通过 MyBatis 提供的强大机制,使用插件是非常简单的,只需实现 Interceptor 接口,并指定想要拦截的方法签名即可
这句话告诉我们,Mybatis的拦截器会对四个类进行拦截,Executor执行器,ParameterHandler参数处理器,ResultSetHandler结果处理器,StatementHandler 语句处理器。待会儿带大家去看相关的源码。
PageHelper的使用和源码解析
PageHelper是一个分页插件,使用它我们在做分页查询的时候不需要编写查询总条数的SQL,以及查询列表的SQL不需要指定Limit 。我们只需要把分页条件交给PageHelper,它就可以帮我们自动生成查询总条数的SQL,以及在查询列表的SQL后面自动加上 Limit。PageHelper 就是一个Mybatis的拦截器。
下面我们来简单使用一下PageHelper,首先需要导入PageHelper的依赖
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>4.1.4</version>
</dependency>
第二步,在mybatis-config.xml配置插件 PageHelper
<plugins>
<plugin interceptor="com.github.pagehelper.PageHelper">
<!-- 指定方言,Mysql数据库 -->
<property name="dialect" value="mysql"/>
</plugin>
</plugins>
第三步,编写查询列表的SQL
<select id="selectList" resultMap="resultMap">
select * from student
</select>
第四步,使用PageHelper查询结果
@Test
public void testInterceptor() throws IOException {
//设置分页信息
Page page = PageHelper.startPage(1, 10, true);
//================================================================================
//加载配置
InputStream inputStream= Resources.getResourceAsStream("mybatis-config.xml");
//创建一个sqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
//Page pageInfo = (Page)sqlSession.selectList("cn.whale.mapper.StudentMapper.selectList");
StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
//==================================================================================
//结果以Page来接收
Page pageInfo = (Page) mapper.selectList();
System.out.println(pageInfo.getTotal());
pageInfo.getResult().stream().forEach( System.out::println);
}
测试结果如下
看到这个结果是不是觉得很有意思,我并没有编写select count(0) from student
这条查询总条数的SQL,但是该SQL被执行了,同时还给查询列表的SQL增加了limit 分页条件。
接下来我们分析一下PageHelper的实现原理,首先看一下 com.github.pagehelper.PageHelper
这个类com.github.pagehelper.PageHelper
@Intercepts({@Signature(
//拦截器Executor的query方法
type = Executor.class,
method = "query",
//方法的参数,拦截拥有这四个参数的query方法
args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}
)})
public class PageHelper implements Interceptor {
//....省略....
}
首先 PageHelper 实现了 Interceptor接口,Mybatis的拦截器都需要实现该接口。类上通过@Intercepts指定了只需要拦截Executor执行器的 “query” 方法。
拦截器接口源码如下
public interface Interceptor {
//拦截器方法,拦截器的核心方法
Object intercept(Invocation invocation) throws Throwable;
//该方法的参数 target就是拦截器的目标类,plugin方法中需要对target做增强
Object plugin(Object target);
//设置属性,Properties是mybatis-config.xml对拦截器配置中的属性
void setProperties(Properties properties);
}
我们看一下 PageHelper 的三个方法,先看plugin方法 :com.github.pagehelper.PageHelper#plugin
public Object plugin(Object target) {
//如果是Executor就对target做增强,否则不做任何处理,直接返回target
if (target instanceof Executor) {
//把target交给Plugin.wrap ,this就是PageHelper拦截器类
return Plugin.wrap(target, this);
} else {
return target;
}
}
如果target是Executor就对target做增强,否则不做任何处理,直接返回target,看一下 Plugin.wrap做了什么
public class Plugin implements InvocationHandler {
//原生对象
private final Object target;
//拦截器
private final Interceptor interceptor;
//方法
private final Map<Class<?>, Set<Method>> signatureMap;
private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) {
this.target = target;
this.interceptor = interceptor;
this.signatureMap = signatureMap;
}
//对target做增强,因为pageHelper只是拦截Executor,所以target是 Executor比如CacheingExector, interceptor是拦截器类即:PageHelper
public static Object wrap(Object target, Interceptor interceptor) {
//1.拿到拦截器类上的@Intercepts 指定的方法签名@Signature,即:要拦截器什么方法比如:query方法
Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
//拿到目标类的class,比如:org.apache.ibatis.executor.CachingExecutor
Class<?> type = target.getClass();
Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
if (interfaces.length > 0) {
//2.使用JDK动态代理为target生成代理类
return Proxy.newProxyInstance(
type.getClassLoader(),
interfaces,
//3.Plugin是一个 InvocationHandler
new Plugin(target, interceptor, signatureMap));
}
return target;
}
//对象执行会被invoke方法拦截到 ,比如在执行CachingExecutor#query方法的时候会被invoke方法拦截
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
//4.拿到执行到Method
Set<Method> methods = signatureMap.get(method.getDeclaringClass());
//5.判断当前方法是否包含在要拦截的方法中
if (methods != null && methods.contains(method)) {
//6.如果方法需要被拦截,调用拦截器的intercept方法,也就是PageHelper的intercept方法
//把拦截的原生对象,方法对象,参数对象封装成Invocation
return interceptor.intercept(new Invocation(target, method, args));
}
//7.如果方法没有被拦截,就直接调用
return method.invoke(target, args);
} catch (Exception e) {
throw ExceptionUtil.unwrapThrowable(e);
}
}
有学习过JDK动态代理的同学是能够看得懂上面的代码,使用Proxy为被拦截的对象生成代理类,并解析拦截器上的@Intercepts的@Signature属性来得到要拦截的方法。
当对象方法被执行就会被Plugin#invoke拦截到,Plugin是一个InvocationHandler,其中的invoke会拦截器对象方法的调用。在invoke方法中判断了方法是否需要拦截,如果需要调用interceptor.intercept对原生对象做增强。如果方法不需要拦截就直接调用方法,不走拦截器。
接下来代码走到 com.github.pagehelper.PageHelper#intercept
//Invocation 是对方法调用的封装,其中包括:target类 ;method ;arg参数
public Object intercept(Invocation invocation) throws Throwable {
//自动获取方言
if (autoRuntimeDialect) {
SqlUtil sqlUtil = getSqlUtil(invocation);
return sqlUtil.processPage(invocation);
} else {
//自动获取dialect,如果没有setProperties或setSqlUtilConfig,也可以正常进行
if (autoDialect) {
initSqlUtil(invocation);
}
//1.重点看这里,使用SqlUtil处理分页
return sqlUtil.processPage(invocation);
}
}
//处理分页
public Object processPage(Invocation invocation) throws Throwable {
try {
//2.处理分页
Object result = _processPage(invocation);
return result;
} finally {
//处理分页数据,分页数据是保存在SqlUtil中的 ThreadLocal<Page>中
clearLocalPage();
}
}
private Object _processPage(Invocation invocation) throws Throwable {
//方法参数
final Object[] args = invocation.getArgs();
Page page = null;
//支持方法参数时,会先尝试获取Page
if (supportMethodsArguments) {
page = getPage(args);
}
//分页信息,里面包括了pageNum和pageSize.默认是0到Integer的最大值
RowBounds rowBounds = (RowBounds) args[2];
//支持方法参数时,如果page == null就说明没有分页条件,不需要分页查询
//是否支持接口参数来传递分页参数,默认false。就是不支持我们自己传入分页参数
if ((supportMethodsArguments && page == null)
//当不支持分页参数时,判断LocalPage和RowBounds判断是否需要分页
|| (!supportMethodsArguments && SqlUtil.getLocalPage() == null && rowBounds == RowBounds.DEFAULT)) {
return invocation.proceed();
} else {
//不支持分页参数时,page==null,这里需要获取
if (!supportMethodsArguments && page == null) {
//【重点】我们自己没有传入分页对象,所以代码会走这里
page = getPage(args);
}
//【重点】 处理分页查询,该方法中会先查询count,再查询list
return doProcessPage(invocation, page, args);
}
}
在 PageHelper#intercept 拦截方法中调用了 SqlUtil.processPage 来处理分页,该方法中会判断是否支持接口传入分页对象来分页,默认是supportMethodsArguments=false。代码会来到 com.github.pagehelper.SqlUtil#getPage 获取分页对象Page
public Page getPage(Object[] args) {
//【重要】 这里是拿到分页信息,使用的一个ThreadLocal<Page>来存储的
Page page = getLocalPage();
...省略...
//分页合理化
if (page.getReasonable() == null) {
page.setReasonable(reasonable);
}
//当设置为true的时候,如果pagesize设置为0(或RowBounds的limit=0),就不执行分页,返回全部结果
if (page.getPageSizeZero() == null) {
page.setPageSizeZero(pageSizeZero);
}
return page;
}
在SqlUtil#getPage中,如果我们自己没有在方法中传入分页对象,那么会从 com.github.pagehelper.SqlUtil#LOCAL_PAGE 获取分页对象,它是一个ThreadLocal<Page>
, 那这个分页对象是在什么时候保存进去的呢?就是在我们最开始测试代码中执行Page page = PageHelper.startPage(1, 10, true);
的时候,就会把pageNum和pageSize封装成 Page对象存储到SqlUtil中的一个ThreadLocal<Page>
中。
拿到Page分页对象后,代码来到com.github.pagehelper.SqlUtil#doProcessPage ,处理分页查询,该方法中会先查询count,再查询list
private Page doProcessPage(Invocation invocation, Page page, Object[] args) throws Throwable {
//保存RowBounds状态
RowBounds rowBounds = (RowBounds) args[2];
//获取原始的ms
MappedStatement ms = (MappedStatement) args[0];
//判断并处理为PageSqlSource
if (!isPageSqlSource(ms)) {
//[重要]1.处理MappedStatment,因为要生成一个count语句所以该方法中会
//新建count查询和分页查询的MappedStatement ,id会加上_COUNT,比如:
//cn.whale.StudentMapper.selectList会变成cn.whale.StudentMapper.selectList_COUNT
processMappedStatement(ms);
}
//设置当前的parser,后面每次使用前都会set,ThreadLocal的值不会产生不良影响
//【重要】 给 PageSqlSource设置parse。PageSqlSource表示从 XML 文件或注释读取的映射语句的内容
//PageSqlSource中有一个 ThreadLocal<Parser> ,Parser是pagehelper提供的SQL解析器比如:MysqlParser
((PageSqlSource)ms.getSqlSource()).setParser(parser);
try {
//忽略RowBounds-否则会进行Mybatis自带的内存分页
args[2] = RowBounds.DEFAULT;
//如果只进行排序 或 pageSizeZero的判断
if (isQueryOnly(page)) {
return doQueryOnly(page, invocation);
}
//简单的通过total的值来判断是否进行count查询
if (page.isCount()) {
page.setCountSignal(Boolean.TRUE);
//替换MS
args[0] = msCountMap.get(ms.getId());
//【重要】查询总数
Object result = invocation.proceed();
//还原ms
args[0] = ms;
//【重要】设置总数
page.setTotal((Integer) ((List) result).get(0));
if (page.getTotal() == 0) {
return page;
}
} else {
page.setTotal(-1l);
}
//pageSize>0的时候执行分页查询,pageSize<=0的时候不执行相当于可能只返回了一个count
if (page.getPageSize() > 0 &&
((rowBounds == RowBounds.DEFAULT && page.getPageNum() > 0)
|| rowBounds != RowBounds.DEFAULT)) {
//将参数中的MappedStatement替换为新的qs
page.setCountSignal(null);
//拿到原本的SQL
BoundSql boundSql = ms.getBoundSql(args[1]);
//设置分页,信息,啊page总的开始也和每页条数设置到args[1]
args[1] = parser.setPageParameter(ms, args[1], boundSql, page);
page.setCountSignal(Boolean.FALSE);
//【重要】执行分页查询
Object result = invocation.proceed();
//【重要】得到处理结果
page.addAll((List) result);
}
} finally {
((PageSqlSource)ms.getSqlSource()).removeParser();
}
//返回结果
return page;
}
方法稍微比较复杂,总共做了这些事情
- processMappedStatement(ms); 新建count查询和分页查询的MappedStatement
- ((PageSqlSource)ms.getSqlSource()).setParser(parser); 给 PageSqlSource设置parse。PageSqlSource表示从 XML 文件或注释读取的映射语句的内容,PageSqlSource中有一个
ThreadLocal<Parser>
,Parser是Pagehelper提供的SQL解析器比如:MysqlParser
public class MysqlParser extends AbstractParser {
@Override
public String getPageSql(String sql) {
StringBuilder sqlBuilder = new StringBuilder(sql.length() + 14);
sqlBuilder.append(sql);
//处理SQL的分页条件【重要重要重要】
sqlBuilder.append(" limit ?,?");
return sqlBuilder.toString();
}
在MysqlParser中处理了分页SQL,那么对于查询Count Sql是在哪儿生成的呢?是在com.github.pagehelper.parser.`SqlParser#getSimpleCountSql`中
public String getSimpleCountSql(final String sql) {
isSupportedSql(sql);
StringBuilder stringBuilder = new StringBuilder(sql.length() + 40);
stringBuilder.append("select count(0) from (");
stringBuilder.append(sql);
stringBuilder.append(") tmp_count");
return stringBuilder.toString();
}
SqlParser存储在MysqlParser的父类AbstractParser中,他们的继承体系如下。
![202401201945461092.png][]
- Object result = invocation.proceed(); 查询总条数,然后把总条数设置给结果对象 page。该方法会触发
CachingExecutor#query
的调用,方法中会调用 PageSqlSource#getBoundSql 去生成查询count的SQL,而底层最终会调用SqlParser#getSimpleCountSql
解析查询count的SQL,然后执行count查询。 - 然后就是执行分页查询,一样是执行 invocation.proceed() ,在Page中有个countSignal信号来标记是该生成count的sql还是分页sql, 这一次依然会执行CachingExecutor#query,因为countSignal信号的改变,这次会触发
MysqlParser#getPageSql
拼接分页的SQL - 最后把条数和列表转到Page中返回,Page继承了ArrayList,对中总条数和数据列表进行了封装
public class Page<E> extends ArrayList<E> {
private static final long serialVersionUID = 1L;
/**
* 页码,从1开始
*/
private int pageNum;
/**
* 页面大小
*/
private int pageSize;
/**
* 起始行
*/
private int startRow;
/**
* 末行
*/
private int endRow;
/**
* 总数
*/
private long total;
/**
* 总页数
*/
private int pages;
/**
* 包含count查询
*/
private boolean count;
//列表就是自己
public List<E> getResult() {
return this;
}
内容比较多,还是要稍微总结一下
- 首先我们通过 PageHelper.startPage(1, 10, true) 来指定分页信息,该分页会被封装成Page对象,保存到SqlUtil#LOCAL_PAGE 一个ThreadLocal总,方便后面查询的时候使用
- PageHelper提供了拦截器类 com.github.pagehelper.PageHelper 它是 Interceptor的子类 ,它通过 @Intercepts(@Signature 注解来指定只需要拦截器 Executor 的 query 方法。
- 在PageHelper中的plugin方法中为原生类也就是 Executor 生成代理。代理类通过Plugin#wrap来做增强,Plugin实现了InvocationHandler(JDK动态代理) ,复写了invoke方法。当 Executor被执行的时候会被invoke方法拦截。
- 在Plugin#invoke方法中会判断当前方法是否满足拦截条件(query方法),如果需要拦截就会执行 PageHelper#intercept方法去执行查询。
- 在PageHelper#intercept方法中会从SqlUtil#LOCAL_PAGE中拿到Page分页对象,然后会根据MappedStatement生成count和list的MappedStatement
- 接着会给MappedStatement的PageSqlSource设置MysqlParser解析器,在MysqlParser#getPageSql 中负责给SQL增加分页条件 limit。在MysqlParser的父类AbstractParser中包含了一个SqlParser ,它提供了getSimpleCountSql方法负责拼接查询count的sql。
- 当PageHelper#intercept 分页拦截器方法被执行,会先执行查询count的SQL,底层调用了SqlParser#getSimpleCountSql 来生成count的SQL。然后会执行查询list的SQL,底层调用了MysqlParser#getPageSql来获取给list增加分页limit。
- 最后把count和list封装到Page对象返回,Page本身继承了ArrayList。
Mybatis中的拦截器执行流程
上面我们详细分析了PageHelper的执行原理,现在我们来分析一下Mybatis是如何执行拦截器的。在第一章我们知道,mybatis-config.xml中配置的<plugin interceptor="com.github.pagehelper.PageHelper">
在执行SqlSessionFactoryBuilder.builder的时候,会通过XMLConfigBuilder解析<Plugins/>
,然后添加到Configuration中的InterceptorChain拦截器链中 ,见:org.apache.ibatis.builder.xml.XMLConfigBuilder#pluginElement
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).newInstance();
//设置属性
interceptorInstance.setProperties(properties);
//添加到拦截器链
configuration.addInterceptor(interceptorInstance);
}
}
}
上面我们有介绍过,拦截器可以拦截Executor 执行器;ParameterHandler 参数处理器;ResultSetHandler 结果处理器;StatementHandler 语句执行器。在创建这四种对象的时候会把对象交给 interceptor.plugin 方法做处理
。我们一个一个看,首先是在创建 Executor的时候Configuration#newExecutor
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
executorType = executorType == null ? defaultExecutorType : executorType;
executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
Executor executor;
if (ExecutorType.BATCH == executorType) {
executor = new BatchExecutor(this, transaction);
} else if (ExecutorType.REUSE == executorType) {
executor = new ReuseExecutor(this, transaction);
} else {
executor = new SimpleExecutor(this, transaction);
}
if (cacheEnabled) {
executor = new CachingExecutor(executor);
}
//重点,把CachingExecutor 交给 interceptorChain去处理
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
下面是pluginAll方法的代码org.apache.ibatis.plugin.InterceptorChain#pluginAll
public class InterceptorChain {
private final List<Interceptor> interceptors = new ArrayList<Interceptor>();
public Object pluginAll(Object target) {
for (Interceptor interceptor : interceptors) {
//把要拦截的对象交给interceptor.plugin
target = interceptor.plugin(target);
}
return target;
}
...省略...
比如对于PageHelper来说plugin方法就是通过代理的方式对target做增强。该方法有四个地方被调用,分别对应了四个对象的创建
下面是其他三个对象的创建方法,都在Configuration中
public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
//交给拦截器去做处理
parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
return parameterHandler;
}
public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
ResultHandler resultHandler, BoundSql boundSql) {
ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
//交给拦截器去做处理
resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
return resultSetHandler;
}
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;
}
那么拦截器是在什么时候执行intercept方法的呢?因为在拦截器的interceptor.plugin方法中我们为要拦截的对象做了代理,参考PageHelper。以CachingExecutor 为例,当CachingExecutor#query被调用就会触发 Plugin#invoke
,因为它本身是一个InvocationHandler
。在invoke方法中会真正触发interceptor.intercept
方法的调用。
定义拦截器做参数增强
我们这里来做一个案例,自定义拦截器给SQL传入一个条件参数把默认的参数替换掉,我的SQL如下
<select id="selectByUsername" resultMap="resultMap">
select * from student where username = #{username}
</select>
我的测试代码如下
List<Student> students =
sqlSession.selectList("cn.whale.mapper.StudentMapper.selectByUsername","ls");
students.stream().forEach( System.out::println);
记住我上面的参数传入的是“ls” , 然后定义拦截器
//拦截StatementHandler的prepare方法
@Intercepts(value = { @Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class , Integer.class})})
public class MyInterceptor implements Interceptor {
private Properties properties;
@Override
public Object intercept(Invocation invocation) throws Throwable {
//获取statementHandler
StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
//获取绑定sql
BoundSql boundSql = statementHandler.getBoundSql();
//获取参数
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
//筛选动态list参数,并加密后重新赋值
for (int i = 0; i < parameterMappings.size(); i++) {
ParameterMapping parameterMapping = parameterMappings.get(i);
if (parameterMapping.getMode() != ParameterMode.OUT) {
String propertyName = parameterMapping.getProperty();
System.out.println("参数名 = "+propertyName);
Object parameterObject = boundSql.getParameterObject();
System.out.println("原本的参数 = "+parameterObject);
//替换参数值
parameterObject = properties.getProperty("username");
System.out.println("替换后的参数 = "+parameterObject);
boundSql.setAdditionalParameter(propertyName,parameterObject );
}
}
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
//只是对ParameterHandler做增强
if (target instanceof StatementHandler) {
return Plugin.wrap(target, this);
} else {
return target;
}
}
@Override
public void setProperties(Properties properties) {
//加载配置
this.properties = properties;
}
}
解释一下这个拦截器
- 拦截器上拦截的是StatementHandler 的 prepare 方法,拦截该方法可以对参数做修改
- 先在 plugin方法中我做了判断,只对 StatementHandler 做拦截,然后使用 Plugin.wrap 对 StatementHandler生成代理。
- 在 setProperties 方法中我们把拦截器的配置属性保存给Properties成员变量
- 在 intercept 方法中,我们拿到 boundSql,把Properties中的username值覆盖给boundSql中的参数值,完成参数的替换
测试效果如下
说在最后
其实我个人并不是很喜欢pagehelper这种分页插件,虽然可以自动生成分页sql来减少我们的工作量,但是它从某种程度上来说会影响性能。一是生成SQL需要时间,二是它自动生成的查询count的sql是根据查询list的sql来的,比如:查询list的sql关联了10张表,那么查询count的sql也会关联10张表。可能这并不是最优的SQL,所以我还是喜欢自己写分页查询自己控制SQL。
文章结束,喜欢就给我去点个五星好评吧。2021一路有你,2022我们继续加油!你的肯定是我最大的动力
博主在参加博客之星评比,点击链接 , https://bbs.csdn.net/topics/603957267 疯狂打Call!五星好评 感谢。