《看不懂你打我系列》之 —— 极简 PageHelper 源码解析

￡神魔★判官ぃ 2021-10-19 08:36 279阅读 0赞

PageHelper分页插件原理浅析

1.  PageHelper分页插件的使用
    
     *  引入依赖
        
            <dependency>
            	<groupId>com.github.pagehelper</groupId>
            	<artifactId>pagehelper</artifactId>
            	<version>5.1.6</version>
            </dependency>
     *  在mybatis全局配置文件中添加plugin配置
        
            <configuration>
            	<properties resource="properties/db.properties"></properties>
                
            	<plugins>
            		<plugin interceptor="com.github.pagehelper.PageInterceptor">
            			<property name="helperDialect" value="mysql"/>
            		</plugin>
            	</plugins>
            	
            	<environments default="development">
            		<environment id="development">
            			<transactionManager type="JDBC" />
            			<dataSource type="POOLED">
            				<property name="driver" value="${db.driver}" />
            				<property name="url" value="${db.url}" />
            				<property name="username" value="${db.username}" />
            				<property name="password" value="${db.password}" />
            			</dataSource>
            		</environment>
            	</environments>
            	<mappers>
            		<mapper resource="dao/UserMapper.xml" />
            	</mappers>
            </configuration>
     *  在DAO层进行分页查询
        
            public class PageHelperTest{ 
                private SqlSessionFactory sqlSessionFactory;
                @Before
            	public void init() { 
            		try { 
            			String resource = "mybatis-config.xml";
            			InputStream inputStream = Resources.getResourceAsStream(resource);
            			sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            		} catch (IOException e) { 
            			e.printStackTrace();
            		}
            	}
                
                @Test
            	public PageInfo<User> testPage() { 
            		SqlSession session = sqlSessionFactory.openSession();
                    //开启分页，只对最近一次的查询有分页的效果
                    //剧透一下，是使用了ThreadLocal来存储Page分页信息的
            		PageHelper.startPage(2,4);
                    //下面的查询会被PageHelper拦截，返回的结果其实是一个Page对象，Page继承自ArrayList
            		List<User> lists = session.selectList("findAll");
                    //mapper.xml里配置了一个<select id="findAll"> select * from user;</select>
            		PageInfo<User> pageInfo = new PageInfo<>(lists);
            		return pageInfo;
            	}
            }
2.  PageHelper插件工作原理
    
     *  首先，在全局配置文件里使用`<plugin>`标签，将PageHelper拦截器添加到配置中。实际，拦截器是对Executor起了作用，先来看拦截器是如何被配置的：
        
        进行全局配置文件的解析和装载时，就会将拦截器信息封装到了Configuration对象中，流程如下：
        
            String resource = "dao/SqlMapConfig.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            //下面的build方法，为全局配置文件的解析入口
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        
            public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { 
                try { 
                  XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
                  // parser.parse()：使用XPATH解析XML配置文件，将配置文件封装为Configuration对象
                  // 返回DefaultSqlSessionFactory对象，该对象拥有Configuration对象（封装配置文件信息）
                  return build(parser.parse());
                } catch (Exception e) { 
                  throw ExceptionFactory.wrapException("Error building SqlSession.", e);
                } finally { 
                  ErrorContext.instance().reset();
                  try { 
                    inputStream.close();
                  } catch (IOException e) { 
                  }
                }
              }
        
        继续看XMLConfigBuilder中的parse方法
        
            public Configuration parse() { 
                if (parsed) { 
                  throw new BuilderException("Each XMLConfigBuilder can only be used once.");
                }
                parsed = true;
                //XMLConfigBuilder中持有一个XPathParser
                //使用XPathParser，通过XPath语法，来
                parseConfiguration(parser.evalNode("/configuration"));
                return configuration;
            }
            
            private void parseConfiguration(XNode root) { 
                try { 
                  //下面的解析顺序，即解释了配置文件中的标签书写顺序
                  propertiesElement(root.evalNode("properties"));
                  Properties settings = settingsAsProperties(root.evalNode("settings"));
                  loadCustomVfs(settings);
                  loadCustomLogImpl(settings);
                  typeAliasesElement(root.evalNode("typeAliases"));
                  // 关键在这，解析<plugins>标签
                  pluginElement(root.evalNode("plugins"));
                  objectFactoryElement(root.evalNode("objectFactory"));
                  objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
                  reflectorFactoryElement(root.evalNode("reflectorFactory"));
                  settingsElement(settings);
                  environmentsElement(root.evalNode("environments"));
                  databaseIdProviderElement(root.evalNode("databaseIdProvider"));
                  typeHandlerElement(root.evalNode("typeHandlers"));
                  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()) { 
                    //循环遍历plugins标签下的子标签
                    String interceptor = child.getStringAttribute("interceptor");
                    Properties properties = child.getChildrenAsProperties();
                    Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
                    interceptorInstance.setProperties(properties);
                   //将当前拦截器添加到Configuration对象中
                    configuration.addInterceptor(interceptorInstance);
                  }
                }
              }
            
            //Configuration对象中
            public void addInterceptor(Interceptor interceptor) { 
            	interceptorChain.addInterceptor(interceptor);
                //Configuration持有一个InterceptorChain对象
                //InterceptorChain中持有一个List<Interceptor>对象
            }
        
        至此，装载拦截器流程完毕，Configuration对象被封装到了DefaultSqlSessionFactory里
     *  使用拦截器对Executor进行增强
        
        之后，我们调用openSession打开一个SqlSession，看看创建SqlSession时都做了些什么
        
            SqlSession session = sqlSessionFactory.openSession();
        
            //DefaultSqlSession中
            public SqlSession openSession() { 
                return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
            }
            
            private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) { 
                Transaction tx = null;
                try { 
                  // 获取数据源环境信息
                  final Environment environment = configuration.getEnvironment();
                  final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
                  tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
                  // 创建Executor执行器，关键在这里*****
                  final Executor executor = configuration.newExecutor(tx, execType);
                  // 创建DefaultSqlSession
                  return new DefaultSqlSession(configuration, executor, autoCommit);
                } catch (Exception e) { 
                  closeTransaction(tx); 
                  throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);
                } finally { 
                  ErrorContext.instance().reset();
                }
              }
        
        进入Configuration
        
            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);
            		}
            		// 插件增强，在这里使用插件对executor进行增强
            		executor = (Executor) interceptorChain.pluginAll(executor);
            		return executor;
            	}
        
        进入InterceptorChain
        
            public Object pluginAll(Object target) { 
                for (Interceptor interceptor : interceptors) { 
                  target = interceptor.plugin(target);
                }
                return target;
            }
        
        看到这里，就知道其实是通过Interceptor接口的plugin方法为纽带，来对Executor进行增强的（AOP)，这里，Interceptor即为PageHelper，所以接下来进入PageHelper
        
            //PageHelper
            public Object plugin(Object target) { 
               return target instanceof Executor ? Plugin.wrap(target, this) : target;
            }
        
            //Plugin 
            //这个Plugin是mybatis自带的接口，实现了InvocationHandler，也说明mybatis拦截器底层是通过JDK动态代理来实现的
            public static Object wrap(Object target, Interceptor interceptor) { 
                //前面入参过来，这里interceptor是PageHelper
                Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
                Class<?> type = target.getClass();
                Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
                if (interfaces.length > 0) { 
                    //下面是经典的JDK动态代理生成代码
                    //继续进入Plugin的构造函数看看
                  return Proxy.newProxyInstance(
                      type.getClassLoader(),
                      interfaces,
                      new Plugin(target, interceptor, signatureMap));
                }
                return target;
            }
            
            private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) { 
                this.target = target;
                this.interceptor = interceptor;
                this.signatureMap = signatureMap;
            }
            //只是进行了一些简单的变量设置
            
            //JDK动态代理，执行时会调用InvocationHandler中的invoke方法，所以我们接着看Plugin里面的invoke方法
            
            @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方法
                    //那我们就去PageHelper的intercept方法里一探究竟
                    return interceptor.intercept(new Invocation(target, method, args));
                  }
                  return method.invoke(target, args);
                } catch (Exception e) { 
                  throw ExceptionUtil.unwrapThrowable(e);
                }
            }
        
        啊
        
            //PageHelper
            public Object intercept(Invocation invocation) throws Throwable { 
                    if (this.autoRuntimeDialect) { 
                        SqlUtil sqlUtil = this.getSqlUtil(invocation);
                        return sqlUtil.processPage(invocation);
                    } else { 
                        if (this.autoDialect) { 
                            this.initSqlUtil(invocation);
                        }
            
                        return this.sqlUtil.processPage(invocation);
                    }
            }
        
            //SqlUtil
            public Object processPage(Invocation invocation) throws Throwable { 
                    Object var3;
                    try { 
                        Object result = this._processPage(invocation);
                        var3 = result;
                    } finally { 
                        clearLocalPage();
                    }
            
                    return var3;
            }
            
            private Object _processPage(Invocation invocation) throws Throwable { 
                    Object[] args = invocation.getArgs();
                    Page page = null;
                    if (this.supportMethodsArguments) { 
                        page = this.getPage(args);
                    }
                    RowBounds rowBounds = (RowBounds)args[2];
                    if (this.supportMethodsArguments && page == null || !this.supportMethodsArguments && getLocalPage() == null && rowBounds == RowBounds.DEFAULT) { 
                        return invocation.proceed();
                    } else { 
                        if (!this.supportMethodsArguments && page == null) { 
                            //SqlUtil里维护了一个ThreadLocal<Page>
                            //这里会从ThreadLocal中去取Page对象
                            //这个Page对象是在调用PageHelper.startPage()时，被添加到ThreadLocal里的
                            page = this.getPage(args);
                        }
            
                        return this.doProcessPage(invocation, page, args);
                    }
            }
            
            //下面是最最最终的执行
            //流程有点复杂
            //大概可以分为2步：
            //1. 修改入参中的MappedStatement，执行一次SQL查询，获取总数count,设置到Page对象中
            //（这一步可通过PageHelper.startPage(int pageNum,int pageSize,boolean count) 中的第三个参数来取消）
            //2. 通过Page对象里的分页信息，修改MappedStatement中的SqlSource，通过getBoundSql，在sql语句末尾添加 limit ?,? ，后通过StatementHandler，将分页信息绑定到入参，执行查询
            private Page doProcessPage(Invocation invocation, Page page, Object[] args) throws Throwable { 
                   //args是Executor执行query时的入参
                   //args[0] 为 MappedStatement
                   //args[1] 为 Object ，是SQL查询时的参数
                   //args[2] 为 RowBounds 貌似和分页有关
                   //agrs[3] 为ResultHandler 结果集处理器
                   //可以参考CachingExecutor的query方法
                    RowBounds rowBounds = (RowBounds)args[2];
                    MappedStatement ms = (MappedStatement)args[0];
                    if (!this.isPageSqlSource(ms)) { 
                        this.processMappedStatement(ms);
                    }
            
                   //这里设置Parser，可能的取值有MysqlParser,OracleParser,PostgreSQLParser等
                   //本例中为MysqlParser
                    ((PageSqlSource)ms.getSqlSource()).setParser(this.parser);
            
                    try { 
                        args[2] = RowBounds.DEFAULT;
                        if (this.isQueryOnly(page)) { 
                            Page var12 = this.doQueryOnly(page, invocation);
                            return var12;
                        }
            
                        if (page.isCount()) { 
                            //如果开启了查询总数，先查询总数
                            page.setCountSignal(Boolean.TRUE);
                            //这里args[0]即是Executor执行查询时入参的MappedStatement
                            //先将MappedStatement入参改为查询总数的Statement
                            args[0] = msCountMap.get(ms.getId());
                            //下面执行Executor查询，得到总数
                            Object result = invocation.proceed();
                            //将Executor查询入参的MappedStatement恢复
                            args[0] = ms;
                            //将记录的总条数，设置到Page对象中
                            page.setTotal((long)(Integer)((List)result).get(0));
                            if (page.getTotal() == 0L) { 
                                //若记录数量为0，则直接返回，不执行真正的查询
                                Page var7 = page;
                                return var7;
                            }
                        } else { 
                            page.setTotal(-1L);
                        }
            
                        if (page.getPageSize() > 0 && (rowBounds == RowBounds.DEFAULT && page.getPageNum() > 0 || rowBounds != RowBounds.DEFAULT)) { 
                            //存在分页信息时，进行分页查询
                            page.setCountSignal((Boolean)null);
                            //通过下面这一句，得到一个BoundSql，此时已经添加了limit ?,?
                            //args[1]是sql查询的参数，将会进行sql参数绑定
                            BoundSql boundSql = ms.getBoundSql(args[1]);
                            //这一句进行参数封装，将分页信息封装到args[1]中，后续会替换limit ?,?中的?
                            args[1] = this.parser.setPageParameter(ms, args[1], boundSql, page);
                            page.setCountSignal(Boolean.FALSE);
                            //执行查询
                            Object result = invocation.proceed();
                            //将结果封装为Page对象，并返回
                            page.addAll((List)result);
                        }
                    } finally { 
                        ((PageSqlSource)ms.getSqlSource()).removeParser();
                    }
            
                    return page;
            }
        
        下面通过一次debug过程，来从头到尾跟一遍PageHelper拦截器的执行
        
        下面是测试代码：
        
            public class TestPageHelper{ 
            private SqlSessionFactory sqlSessionFactory;
            	@Before
            	public void before() { 
            		try { 
            			String resource = "dao/SqlMapConfig.xml";
            			InputStream inputStream = Resources.getResourceAsStream(resource);
            			sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            		} catch (IOException e) { 
            			e.printStackTrace();
            		}
            	}
            	@Test
            	public void testPage() { 
            		SqlSession session = sqlSessionFactory.openSession();
            		PageHelper.startPage(2,4);
            		List<User> lists = session.selectList("findAll");
            		PageInfo<User> pageInfo = new PageInfo<User>(lists);
            		System.out.println(lists);
            	}
            }
        
        从SqlSessionFactory.openSession开始跟
        
        ![1566201858847.png][]
        
        ![1566201943366.png][]
        
        ![1566201992265.png][]
        
        ![1566202045498.png][]
        
        ![1566202160086.png][]
        
        至此，openSession跟完了，使用JDK动态代理对Executor进行了增强
        
        下面开始跟PageHelper.startPage
        
        ![1566202298807.png][]
        
        ![1566202432911.png][]
        
        下面开始跟SQL查询流程
        
        ![1566202501206.png][]
        
        ![1566202670656.png][]
        
        执行Executor的query之前，会执行PageHelper中的intercept方法，按照先前分析的，最终会进入到SqlUtil的doProcessPage方法，下面替换掉MappedStatement后，会执行Executor的query
        
        ![1566203370647.png][]
        
        执行query
        
        ![1566202766551.png][]
        
        后委托给BaseExecutor执行查询
        
        ![1566202911212.png][]
        
        最后会进入到BaseExecutor中的queryFromDatabase方法，随后进入SimpleExecutor的doQuery
        
        ![1566203057268.png][]
        
        第一次查询总数完成后，继续返回到SqlUtil的doProcessPage方法中，继续往下执行
        
        ![1566204080033.png][]
        
        先进入355，主要是将分页信息，封装到入参Object中
        
        ![1566204126557.png][]
        
        ![1566204238628.png][]
        
        ![1566204307524.png][]
        
        下面进入到getBoundSql
        
        ![1566204350073.png][]
        
        继续进入PageRawSqlSource的getBoundSql(PageRawSqlSource继承自PageSqlSource，这里是直接调用父类的方法)
        
        ![1566204444377.png][]
        
        继续看getPageBoundSql方法
        
        ![1566204502634.png][]  
        继续看PageStaticSqlSource中的getPageBoundSql，关键在于调用了MysqlParser的getPageSql
        
        ![1566204585579][]
        
        继续进入MysqlParser中去看看，最终找到了limit ? , ?  
        ![1566204678507][]
        
        再往后就是调用StatemenHandler对具体的SQL进行参数绑定，再执行查询，就不再赘述啦~
        
        下面列一下PageHelper涉及到的一些主要技术点作为总结：
        
         *  使用ThreadLocal存储Page分页信息（查询完后会清除）
         *  使用JDK动态代理来完成插件对Executor的拦截

第一遍跟，会觉得头晕，多跟几遍，再梳理一下类的结构关系，就会比较清晰一点。一些更加细节的部分没有列出来，如PageHelper拦截后，将MappedStatement中的SqlSource再进行了一次封装，封装成PageSqlSource，PageRawSqlSource，还有PageStaticSqlSource啥啥的（在SqlUtil的`doProcessPage`中的`this.processMappedStatement()`方法中，这个方法内还有将`select count(0) from user`添加到一个map里的操作），以及第一次查询总数时，是如何将`select * from user`替换成`select count(0) from user`（在`SqlParser`中的`sqlToCount`方法），有兴趣的胖友可以自行深入。本人技术有限，如有纰漏或错误的地方，欢迎各位大佬批评指正。

（完）

[1566201858847.png]: /images/20211018/699a03f1997442799505cecbd3ee3aea.png
[1566201943366.png]: /images/20211018/62c76a3ca7c94eb98be68f9deeede8d9.png
[1566201992265.png]: /images/20211018/8cf7e3cc9d2a42d28d714062e02480da.png
[1566202045498.png]: /images/20211018/fbd252e7904843b0af1c3a320cfe0a4d.png
[1566202160086.png]: /images/20211018/654006c643e4476c842de923043ec5a9.png
[1566202298807.png]: /images/20211018/e03212717e1d428b9bfd15279d6d901d.png
[1566202432911.png]: /images/20211018/0095d7e838dd4d68a11da96182b49548.png
[1566202501206.png]: /images/20211018/2f6ca87329e945a1bb03bfc886fd37de.png
[1566202670656.png]: /images/20211018/f2589517e0b9488593f9165b53644dc7.png
[1566203370647.png]: /images/20211018/f672e8d26aaf4d9b827ce7f584aff83c.png
[1566202766551.png]: /images/20211018/a41402d4a936498bba3a140b34602d6e.png
[1566202911212.png]: /images/20211018/3919dfe818bb4b609161f23072d396db.png
[1566203057268.png]: /images/20211018/fefe8deeee684a4799f1f404154328a1.png
[1566204080033.png]: /images/20211018/866ec89d0b2d4216afa4a125e568266d.png
[1566204126557.png]: /images/20211018/b88dc2a2875a42eeb2d6849716c8822f.png
[1566204238628.png]: /images/20211018/ef4188b14a0d47a09ec963167accb001.png
[1566204307524.png]: /images/20211018/f746c8cabec9449ab1c203c61d815bdd.png
[1566204350073.png]: /images/20211018/2d3d6539e9ce4f6c8a906bfcdbec023a.png
[1566204444377.png]: /images/20211018/62afdaa277a04af7b02a6356183cfe49.png
[1566204502634.png]: /images/20211018/1188c7b9c9834b3291f8de76812d692f.png
[1566204585579]: /images/20211018/dff0e340f350436faadcbc850900a9fe.png
[1566204678507]: /images/20211018/9a03f925db6a46b7b4143b4fac1c6bb1.png