文章目录

• • • 1、项目上出现了分页查询接口慢的问题，慢的原因是表数据量大，count查询很慢
    • 2、要解决count查询慢问题，一般有以下几种方案：
    • • 2.1、优化count查询语句，走索引、减少JOIN表
      • 2.2、分页接口的两次查询用多线程同时进行，节省一点时间
      • 2.3、第一次查询后缓存起来，设置一个合适的过期时间，缓存期间可以快速响应
      • 2.4、使用explain获取的预估行数
      • 2.5、转移数据到其他查询快的数据库，如Elasticsearch、ClickHouse
      • 3.代码编写

        1、项目上出现了分页查询接口慢的问题，慢的原因是表数据量大，count查询很慢

        分页查询接口有两次查询：

        • 一次查分页数据，比如20条：

          SELECT * FROM sys_user LIMIT 1,20;
          

          • 另一次查数据总量：

            SELECT COUNT(*) FROM sys_user;
            

            count查询需要一行行读数据，累加起来得到总量，效率很低。

            2、要解决count查询慢问题，一般有以下几种方案：

            2.1、优化count查询语句，走索引、减少JOIN表

            一行语句，没有可优化空间，pass

            2.2、分页接口的两次查询用多线程同时进行，节省一点时间

            查询LIMIT分页数据，靠前的数据一般都不慢，多线程增加代码复杂性，而且目前的问题是count耗时长，所以该方案也pass

            2.3、第一次查询后缓存起来，设置一个合适的过期时间，缓存期间可以快速响应

            简单可行，缺点是数据实时性不高，新增、删除的数量短期内不会更新，不适合用在高实时性的场景下

            2.4、使用explain获取的预估行数

            响应快，其原理是根据数据总大小和采样的行数据大小做计算得出的预估行数，这是一个近似值，不适合要求高精确度的场景

            2.5、转移数据到其他查询快的数据库，如Elasticsearch、ClickHouse

            既然MySQL不中用，那就换其他的存储引擎，虽然解决了查询慢的问题，但是工作量激增

            3.代码编写

            现在编写代码，写一个分页数量缓存工具类：PageCountCacheManager

            实现内容：

            提供缓存接口函数，支持设置缓存条件：查询时间超过指定值、查询数量超过指定值，当满足任一条件即可触发缓存机制。

            直接贴代码：

            import com.llp.utils.CacheUtil;
            import java.util.concurrent.Callable;
            import java.util.concurrent.TimeUnit;
            /**
             * 分页查询的数据总量缓存器 * * @author llp * @date 2023-11-22 10:28
             */
            public class PageCountCacheManager {
                /**
                 * 查询时间超过这个值就缓存，单位（秒）
                 */
                private static final long TIME = 5;
                /**
                 * 查询数量超过这个值就缓存
                 */
                private static final long AMOUNT = 100000;
                /**
                 * 缓存过期时间，单位（秒）
                 */
                private static final long EXPIRE_TIME = 60;
                /**
                 * 按查询时间来缓存，超过一定时间的查询就缓存起来
                 */
                public static long cacheByTime(String key, Callable task) {
                    key = "PageCount_Time_" + key;
                    return run(key, task, true, false, false, TIME, 0, EXPIRE_TIME);
                }
                public static long cacheByTime(String key, Callable task, long time, long expireTime) {
                    key = "PageCount_Time_" + key;
                    return run(key, task, true, false, false, time, 0, expireTime);
                }
                /**
                 * 按查询数量来缓存，超过一定数量的查询就缓存起来
                 */
                public static long cacheByAmount(String key, Callable task) {
                    key = "PageCount_Amount_" + key;
                    return run(key, task, false, true, false, 0, AMOUNT, EXPIRE_TIME);
                }
                public static long cacheByAmount(String key, Callable task, long amount, long expireTime) {
                    key = "PageCount_Amount_" + key;
                    return run(key, task, false, true, false, 0, amount, expireTime);
                }
                /**
                 * 结合查询时间和查询数量来缓存，当超过一定时间或一定数量就缓存起来
                 */
                public static long cacheByBoth(String key, Callable task) {
                    key = "PageCount_Both_" + key;
                    return run(key, task, false, false, true, TIME, AMOUNT, EXPIRE_TIME);
                }
                public static long cacheByBoth(String key, Callable task, long time, long amount, long expireTime) {
                    key = "PageCount_Both_" + key;
                    return run(key, task, false, false, true, time, amount, expireTime);
                }
                /*************** 私有方法 ***************/
                private static long run(String key, Callable task, boolean byTime, boolean byAmount, boolean byBoth, long time, long amount, long expireTime) {
                    long start = System.currentTimeMillis();
                    // 查数据
                     Long result = null; try {
                      result = task.call();
                       } catch (Exception e) {
                        e.printStackTrace(); 
                        } // 查询结果为空，令其为0 
                        if (result == null) { result = 0L; } 
                        if (byTime || byBoth) {
                         // 判断时间
                         long executionTime = System.currentTimeMillis() - start; if (executionTime > time) { 
                        // 缓存数据
                         CacheUtil.set(key, result, expireTime, TimeUnit.SECONDS); } } if (byAmount || byBoth) { 
                         // 判断数量 
                         if (result > amount) { 
                         // 缓存数据
                          CacheUtil.set(key, result, expireTime, TimeUnit.SECONDS); } } return result; } }
            

            其中CacheUtil是缓存类，可以是JVM内缓存，也可以是RedisTemplate缓存，这个依项目而定

            使用方式：

            //这是Service的查询函数 
            @Override public long countByCondition(BaseCondition condition){
                String key=this.getClass().getName();
                return PageCountCacheManager.cacheByTime(key,()->mapper.countByCondition(condition));
            }
            

             
             网站建设什么意思  设计师证怎么考  福州网站建设解决方案  新安网站  个人申请域名  我想创建一个网络平台