- 优化缓存

book-dao/src/main/java/com/book/dao/VO/BookContent.java

@@ -2,6 +2,8 @@ package com.book.dao.VO;
 
 import lombok.Data;
 
+import java.io.Serializable;
+
 /**
  * created in 2021/8/21
  * Project: book-store
@@ -9,8 +11,9 @@ import lombok.Data;
  * @author win7
  */
 @Data
-public class BookContent {
+public class BookContent implements Serializable {
 
+ private static final long serialVersionUID = -8599473525331400600L;
  private String bookId;
  private String chapterId;
  private String content;

book-dao/src/main/java/com/book/dao/VO/BookContentVO.java

@@ -2,8 +2,11 @@ package com.book.dao.VO;
 
 import lombok.Data;
 
+import java.io.Serializable;
+
 @Data
-public class BookContentVO {
+public class BookContentVO implements Serializable {
+    private static final long serialVersionUID = 229935419604844370L;
     Long userId;
     Long bookId;
     Long contentId;

book-dao/src/main/java/com/book/dao/VO/BookRes.java

@@ -3,7 +3,10 @@ package com.book.dao.VO;
 import com.book.dao.cps.pojo.Book;
 import lombok.Data;
 
+import java.io.Serializable;
+
 @Data
-public class BookRes extends Book {
+public class BookRes extends Book implements Serializable {
+    private static final long serialVersionUID = -7572631958864158089L;
     String categoryName;
 }

book-dao/src/main/java/com/book/dao/VO/Chapter.java

@@ -2,6 +2,8 @@ package com.book.dao.VO;
 
 import lombok.Data;
 
+import java.io.Serializable;
+
 /**
  * created in 2021/8/16
  * Project: book-store
@@ -9,7 +11,8 @@ import lombok.Data;
  * @author win7
  */
 @Data
-public class Chapter {
+public class Chapter implements Serializable {
+    private static final long serialVersionUID = -4313574529147628483L;
     /**
      * 书籍 id
      */

book-dao/src/main/java/com/book/dao/VO/ManageBlockResourceRes.java

@@ -3,8 +3,11 @@ package com.book.dao.VO;
 import com.book.dao.cps.pojo.ManageBlockResource;
 import lombok.Data;
 
+import java.io.Serializable;
+
 @Data
-public class ManageBlockResourceRes extends ManageBlockResource {
+public class ManageBlockResourceRes extends ManageBlockResource implements Serializable {
+    private static final long serialVersionUID = -3938279380576346128L;
     private String bookName;
     private String bookDescription;
 

book-dao/src/main/java/com/book/dao/VO/QueryVO.java

@@ -2,9 +2,12 @@ package com.book.dao.VO;
 
 import lombok.Data;
 
+import java.io.Serializable;
+
 @Data
-public class QueryVO {
+public class QueryVO implements Serializable {
 
+    private static final long serialVersionUID = 4136129873137198418L;
     String query;
 
     int page;

book-dao/src/main/java/com/book/dao/VO/UserRecentReadVO.java

@@ -3,8 +3,11 @@ package com.book.dao.VO;
 import com.book.dao.cpsshard.entity.UserRecentlyRead;
 import lombok.Data;
 
+import java.io.Serializable;
+
 @Data
-public class UserRecentReadVO extends UserRecentlyRead {
+public class UserRecentReadVO extends UserRecentlyRead implements Serializable {
+    private static final long serialVersionUID = -2477698203403737639L;
     int page;
     int size;
 }

book-server/src/main/java/com/book/server/common/entity/Result.java

@@ -16,6 +16,7 @@ import java.io.Serializable;
 @NoArgsConstructor
 @AllArgsConstructor
 public class Result<T> implements Serializable {
+    private static final long serialVersionUID = 8144902804416826469L;
     private boolean success;
     private Integer code;
     private String message;

book-server/src/main/java/com/book/server/service/impl/BookServiceImpl.java

@@ -42,7 +42,6 @@ import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.*;
-import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
 @Service
@@ -100,7 +99,7 @@ public class BookServiceImpl implements BookService {
     }
 
     public List<BookRes> getRecommendFromCache(QueryVO queryVO) {
-        String key = "recommend_" + queryVO.getSex() + "_" + queryVO.getPage() + "_" + queryVO.getSize();
+        String key = getKey("recommend", queryVO.getSex(), queryVO.getPage(), queryVO.getSize());
         Object o = redisUtil.get(key);
         if (o == null) {
             return setRecommendCache(key, queryVO);
@@ -128,7 +127,7 @@ public class BookServiceImpl implements BookService {
 
     private synchronized ArrayList<BlockRes> setBlockByPageIdCache(Integer pageId) {
         //缓存
-        String key = pageId.toString();
+        String key = getKey("block", pageId.toString());
         Object o = redisUtil.get(key);
         if (o != null) {
             return (ArrayList<BlockRes>) o;
@@ -278,17 +277,16 @@ public class BookServiceImpl implements BookService {
         }
 
         //缓存
-        String key = "chaptersByBookId" + bookId;
+        String key = getKey("chapters", bookId);
         Object o = redisUtil.get(key);
         if (o != null) {
             return (List<Chapter>) o;
         } else {
-            return setChaptersByBookIdCache(bookId);
+            return setChaptersByBookIdCache(key, bookId);
         }
     }
 
-    private synchronized List<Chapter> setChaptersByBookIdCache(Long bookId) {
-        String key = "chaptersByBookId" + bookId;
+    private synchronized List<Chapter> setChaptersByBookIdCache(String key, Long bookId) {
         Object o = redisUtil.get(key);
         if (o != null) {
             return (List<Chapter>) o;
@@ -335,7 +333,7 @@ public class BookServiceImpl implements BookService {
 
     @Override
     public List<SearchKeyword> getSearchKeywordBySex(String sex) {
-        String key = "getSearchKeywordBySex" + sex;
+        String key = getKey("searchKeyword", sex);
         Object o = redisUtil.get(key);
         if (o != null) {
             return (List<SearchKeyword>) o;
@@ -378,7 +376,7 @@ public class BookServiceImpl implements BookService {
 
     @Override
     public List<BookRes> smartRecommand(QueryVO queryVO) {
-        String key = "smartRecommand_" + queryVO.getSex();
+        String key = getKey("smartRecommand", queryVO.getSex());
         Object o = redisUtil.get(key);
         if (o == null) {
             List<BookRes> bookRes = setSmartRecommandCache(queryVO, key);
@@ -460,7 +458,7 @@ public class BookServiceImpl implements BookService {
                     // 更新免费看点到 user
                     int i = userMapper.updateUserKandian(user, user.getKandian(), freeCount - book.getPrice(), DateUtils.getNow());
                     checkUpdate(i);
-                    updateUserByIdCache(user.getId());
+                    redisUtil.remove(getUserKey(user.getId()));
 
                 } else if (user.getKandian() + freeCount > book.getPrice()) { //免费+充值足够
                     Integer left = user.getKandian() + freeCount;
@@ -525,7 +523,7 @@ public class BookServiceImpl implements BookService {
     }
 
     private BookContent getBookContent(BookContentVO bookContentVO) {
-        String key = "" + bookContentVO.getBookId() + bookContentVO.getContentId();
+        String key = getKey("bookContent", bookContentVO.getBookId(), bookContentVO.getContentId());
         Object o = redisUtil.get(key);
         if (o != null) {
             return (BookContent) o;
@@ -870,7 +868,7 @@ public class BookServiceImpl implements BookService {
      * @return
      */
     public int getDefaultFreeChapterNum() {
-        String key = "defaultFreeChapterNum";
+        String key = getKey("defaultFreeChapterNum");
         Object o = redisUtil.get(key);
         if (o == null) {
             int book_free_chapter_num = setBook_free_chapter_num(key);
@@ -891,17 +889,16 @@ public class BookServiceImpl implements BookService {
     }
 
     public Book getBookById(Long id) {
-        String key = "book" + id;
+        String key = getKey("book", id);
         Object o = redisUtil.get(key);
         if (o == null) {
-            return updateBookByIdToRedis(id);
+            return updateBookByIdToRedis(key, id);
         } else {
             return (Book) o;
         }
     }
 
-    public synchronized Book updateBookByIdToRedis(Long id) {
-        String key = "book" + id;
+    public synchronized Book updateBookByIdToRedis(String key, Long id) {
         Object o = redisUtil.get(key);
         if (o != null) {
             return (Book) o;
@@ -912,7 +909,7 @@ public class BookServiceImpl implements BookService {
     }
 
     public User getUserById(Long id) {
-        String key = "user" + id;
+        String key = getUserKey(id);
         Object o = redisUtil.get(key);
         if (o == null) {
             return updateUserByIdCache(id);
@@ -921,8 +918,12 @@ public class BookServiceImpl implements BookService {
         }
     }
 
+    private String getUserKey(Long id) {
+        return getKey("user", id);
+    }
+
     public synchronized User updateUserByIdCache(Long id) {
-        String key = "user" + id;
+        String key = getUserKey(id);
         Object o = redisUtil.get(key);
         if (o != null) {
             return (User) o;
@@ -933,7 +934,7 @@ public class BookServiceImpl implements BookService {
     }
 
     public String getCategoryName(Integer id) {
-        String key = "category";
+        String key = getKey("category");
         Object o = redisUtil.hashGet(key, id);
         if (o == null) {
             String name = setCategoryCache(id, key);
@@ -956,16 +957,12 @@ public class BookServiceImpl implements BookService {
                 name = x.getName();
             }
         }
-        redisTemplate.expire(key, redisUtil.getRandomTime(), TimeUnit.MINUTES);
+        redisUtil.expire(key);
         return name;
     }
 
-
-    @Autowired
-    private RedisTemplate redisTemplate;
-
     public String getEditBookContentById(Long bookId, Long chapterId) {
-        String key = "edit_book" + bookId + chapterId;
+        String key = getKey("edit_book", bookId, chapterId);
         Object o = redisUtil.get(key);
         if (o == null) {
             return null;
@@ -974,8 +971,16 @@ public class BookServiceImpl implements BookService {
         }
     }
 
+    public String getKey(Object... keys) {
+        StringBuilder sb = new StringBuilder("t_");
+        for (Object key : keys) {
+            sb.append(key).append("_");
+        }
+        return sb.toString();
+    }
+
     public synchronized void updateEditBookById(Long bookId, Long chapterId) {
-        String key = "edit_book" + bookId + chapterId;
+        String key = getKey("edit_book", bookId, chapterId);
         EditBook obj = editBookMapper.selectOneByExampleSelective(
                 EditBookExample.newAndCreateCriteria()
                         .andBookIdEqualTo(bookId)
@@ -991,7 +996,7 @@ public class BookServiceImpl implements BookService {
         List<EditBook> editBooks = editBookMapper.selectByExampleSelective(EditBookExample.newAndCreateCriteria().example(),
                 EditBook.Column.bookId, EditBook.Column.chapterId, EditBook.Column.content);
         editBooks.forEach(x -> {
-            String key = "edit_book" + x.getBookId() + x.getChapterId();
+            String key = getKey("edit_book", x.getBookId(), x.getChapterId());
             redisUtil.set(key, x.getContent());
         });
     }

book-server/src/main/java/com/book/server/utils/RedisUtil.java

@@ -3,6 +3,9 @@ package com.book.server.utils;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.*;
+import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
 import org.springframework.stereotype.Service;
 
 import java.io.Serializable;
@@ -14,9 +17,20 @@ import java.util.concurrent.TimeUnit;
 @Service
 @Slf4j
 public class RedisUtil {
-    @Autowired
+
     private RedisTemplate redisTemplate;
 
+    @Autowired(required = false)
+    public void setRedisTemplate(RedisTemplate redisTemplate) {
+        RedisSerializer stringSerializer = new StringRedisSerializer();//序列化为String
+        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);//序列化为Json
+        redisTemplate.setKeySerializer(stringSerializer);
+        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
+        redisTemplate.setHashKeySerializer(stringSerializer);
+        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
+        this.redisTemplate = redisTemplate;
+    }
+
     /**
      * set value
      *
@@ -36,6 +50,10 @@ public class RedisUtil {
         return result;
     }
 
+    public boolean expire(final String key) {
+        return redisTemplate.expire(key, getRandomTime(), TimeUnit.MINUTES);
+    }
+
     /**
      * set value with expireTime
      *

book-server/src/main/resources/application-dev.yml

@@ -1,121 +0,0 @@
-server:
-  port: 9999
-spring:
-  servlet:
-    multipart:
-      max-file-size: 100MB
-      max-request-size: 100MB
-  datasource:
-    cps:
-      type: com.alibaba.druid.pool.DruidDataSource
-      driver-class-name: com.mysql.cj.jdbc.Driver
-      jdbc-url: jdbc:mysql://121.41.100.198:3306/test_cps?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
-      username: root
-      password: root
-      #下面为连接池补充设置
-      druid:
-        initial-size: 5 # 初始化
-        max-active: 5 # 最大
-        min-idle: 5 # 最小
-        max-wait: 6000 # 超时时间
-        time-between-eviction-runs-millis: 60000 # 每分钟检查一次空闲链接
-        min-evictable-idle-time-millis: 300000 # 空闲链接可以保持多久而不被驱逐
-        # 检测链接是否有效的query
-        validation-query: SELECT 1 FROM DUAL
-        test-while-idle: true # 检测到链接空闲时，验证是否有效
-        test-on-borrow: false # 申请链接时，不检测
-        test-on-return: false # 返回链接时，不检测
-        pool-prepared-statements: false # 是否缓存preparedStatement,oracle打开，mysql关闭
-        # 如果上面开启了游标，这里要设置一下大小，例如 50
-        max-pool-prepared-statement-per-connection-size: -1
-        # 统计、监控配置
-        filters: stat,wall # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
-        # 合并执行的相同sql，避免因为参数不同而统计多条sql语句；开启慢sql记录
-        connect-properties: config.stat.mergeSql=true;config.stat.slowSqlMillis=500
-        use-global-data-source-stat: true # 合并多个DruidDataSource的监控数据
-        stat-view-servlet:
-          enabled: true
-          login-username: tianyun
-          login-password: tianyunperfect
-          allow: # 默认运行所有
-          deny: # 默认即可
-          reset-enable: true
-    polar:
-      type: com.alibaba.druid.pool.DruidDataSource
-      driver-class-name: com.mysql.cj.jdbc.Driver
-      jdbc-url: jdbc:mysql://121.41.100.198:3306/polardb?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
-      username: root
-      password: root
-      #下面为连接池补充设置
-      druid:
-        initial-size: 5 # 初始化
-        max-active: 5 # 最大
-        min-idle: 5 # 最小
-        max-wait: 6000 # 超时时间
-        time-between-eviction-runs-millis: 60000 # 每分钟检查一次空闲链接
-        min-evictable-idle-time-millis: 300000 # 空闲链接可以保持多久而不被驱逐
-        # 检测链接是否有效的query
-        validation-query: SELECT 1 FROM DUAL
-        test-while-idle: true # 检测到链接空闲时，验证是否有效
-        test-on-borrow: false # 申请链接时，不检测
-        test-on-return: false # 返回链接时，不检测
-        pool-prepared-statements: false # 是否缓存preparedStatement,oracle打开，mysql关闭
-        # 如果上面开启了游标，这里要设置一下大小，例如 50
-        max-pool-prepared-statement-per-connection-size: -1
-        # 统计、监控配置
-        filters: stat,wall # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
-        # 合并执行的相同sql，避免因为参数不同而统计多条sql语句；开启慢sql记录
-        connect-properties: config.stat.mergeSql=true;config.stat.slowSqlMillis=500
-        use-global-data-source-stat: true # 合并多个DruidDataSource的监控数据
-        stat-view-servlet:
-          enabled: true
-          login-username: tianyun
-          login-password: tianyunperfect
-          allow: # 默认运行所有
-          deny: # 默认即可
-          reset-enable: true
-    cpsshard:
-      type: com.alibaba.druid.pool.DruidDataSource
-      driver-class-name: com.mysql.cj.jdbc.Driver
-      jdbc-url: jdbc:mysql://121.41.100.198:3306/test_cps_shard_192?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
-      username: root
-      password: root
-      #下面为连接池补充设置
-      druid:
-        initial-size: 5 # 初始化
-        max-active: 5 # 最大
-        min-idle: 5 # 最小
-        max-wait: 6000 # 超时时间
-        time-between-eviction-runs-millis: 60000 # 每分钟检查一次空闲链接
-        min-evictable-idle-time-millis: 300000 # 空闲链接可以保持多久而不被驱逐
-        # 检测链接是否有效的query
-        validation-query: SELECT 1 FROM DUAL
-        test-while-idle: true # 检测到链接空闲时，验证是否有效
-        test-on-borrow: false # 申请链接时，不检测
-        test-on-return: false # 返回链接时，不检测
-        pool-prepared-statements: false # 是否缓存preparedStatement,oracle打开，mysql关闭
-        # 如果上面开启了游标，这里要设置一下大小，例如 50
-        max-pool-prepared-statement-per-connection-size: -1
-        # 统计、监控配置
-        filters: stat,wall # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
-        # 合并执行的相同sql，避免因为参数不同而统计多条sql语句；开启慢sql记录
-        connect-properties: config.stat.mergeSql=true;config.stat.slowSqlMillis=500
-        use-global-data-source-stat: true # 合并多个DruidDataSource的监控数据
-        stat-view-servlet:
-          enabled: true
-          login-username: tianyun
-          login-password: tianyunperfect
-          allow: # 默认运行所有
-          deny: # 默认即可
-          reset-enable: true
-  redis:
-    database: 0
-    host: 127.0.0.1
-    port: 6379
-    password:
-    jedis:
-      pool:
-        max-active: 8
-        max-wait: -1
-        max-idle: 8
-        min-idle: 0

book-server/src/main/resources/application-test.yml

@@ -1,52 +0,0 @@
-server:
-  port: 9999
-
-spring:
-  datasource:
-    type: com.alibaba.druid.pool.DruidDataSource
-    driver-class-name: com.mysql.cj.jdbc.Driver
-    url: jdbc:mysql://www.tianyunperfect.cn:3306/test_cps?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
-    username: test_cps
-    password: xKysDECnJLXkMYdJ
-    #下面为连接池补充设置
-    druid:
-      initial-size: 5 # 初始化
-      max-active: 5 # 最大
-      min-idle: 5 # 最小
-      max-wait: 6000 # 超时时间
-      time-between-eviction-runs-millis: 60000 # 每分钟检查一次空闲链接
-      min-evictable-idle-time-millis: 300000 # 空闲链接可以保持多久而不被驱逐
-      # 检测链接是否有效的query
-      validation-query: SELECT 1 FROM DUAL
-      test-while-idle: true # 检测到链接空闲时，验证是否有效
-      test-on-borrow: false # 申请链接时，不检测
-      test-on-return: false # 返回链接时，不检测
-      pool-prepared-statements: false # 是否缓存preparedStatement,oracle打开，mysql关闭
-      # 如果上面开启了游标，这里要设置一下大小，例如 50
-      max-pool-prepared-statement-per-connection-size: -1
-      # 统计、监控配置
-      filters: stat,wall # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
-      # 合并执行的相同sql，避免因为参数不同而统计多条sql语句；开启慢sql记录
-      connect-properties: config.stat.mergeSql=true;config.stat.slowSqlMillis=500
-      use-global-data-source-stat: true # 合并多个DruidDataSource的监控数据
-      stat-view-servlet:
-        enabled: true
-        login-username: tianyun
-        login-password: tianyunperfect
-        allow: # 默认运行所有
-        deny: # 默认即可
-        reset-enable: true
-
-
-mybatis:
-  type-aliases-package: com.book.server.entity
-  mapper-locations: classpath:mapper/*Mapper.xml
-
-
-# 设置debug模式下打印mysql
-logging:
-  level:
-    com:
-      book:
-        server:
-          mapper: debug

book-server/src/main/resources/application.yml

@@ -1,4 +1,121 @@
+server:
+  port: 9999
 spring:
-  # 环境 dev:开发环境|test:测试环境|prod:生产环境
-  profiles:
-    active: dev #激活的配置文件
+  servlet:
+    multipart:
+      max-file-size: 100MB
+      max-request-size: 100MB
+  datasource:
+    cps:
+      type: com.alibaba.druid.pool.DruidDataSource
+      driver-class-name: com.mysql.cj.jdbc.Driver
+      jdbc-url: jdbc:mysql://121.41.100.198:3306/test_cps?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
+      username: root
+      password: root
+      #下面为连接池补充设置
+      druid:
+        initial-size: 5 # 初始化
+        max-active: 5 # 最大
+        min-idle: 5 # 最小
+        max-wait: 6000 # 超时时间
+        time-between-eviction-runs-millis: 60000 # 每分钟检查一次空闲链接
+        min-evictable-idle-time-millis: 300000 # 空闲链接可以保持多久而不被驱逐
+        # 检测链接是否有效的query
+        validation-query: SELECT 1 FROM DUAL
+        test-while-idle: true # 检测到链接空闲时，验证是否有效
+        test-on-borrow: false # 申请链接时，不检测
+        test-on-return: false # 返回链接时，不检测
+        pool-prepared-statements: false # 是否缓存preparedStatement,oracle打开，mysql关闭
+        # 如果上面开启了游标，这里要设置一下大小，例如 50
+        max-pool-prepared-statement-per-connection-size: -1
+        # 统计、监控配置
+        filters: stat,wall # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
+        # 合并执行的相同sql，避免因为参数不同而统计多条sql语句；开启慢sql记录
+        connect-properties: config.stat.mergeSql=true;config.stat.slowSqlMillis=500
+        use-global-data-source-stat: true # 合并多个DruidDataSource的监控数据
+        stat-view-servlet:
+          enabled: true
+          login-username: tianyun
+          login-password: tianyunperfect
+          allow: # 默认运行所有
+          deny: # 默认即可
+          reset-enable: true
+    polar:
+      type: com.alibaba.druid.pool.DruidDataSource
+      driver-class-name: com.mysql.cj.jdbc.Driver
+      jdbc-url: jdbc:mysql://121.41.100.198:3306/polardb?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
+      username: root
+      password: root
+      #下面为连接池补充设置
+      druid:
+        initial-size: 5 # 初始化
+        max-active: 5 # 最大
+        min-idle: 5 # 最小
+        max-wait: 6000 # 超时时间
+        time-between-eviction-runs-millis: 60000 # 每分钟检查一次空闲链接
+        min-evictable-idle-time-millis: 300000 # 空闲链接可以保持多久而不被驱逐
+        # 检测链接是否有效的query
+        validation-query: SELECT 1 FROM DUAL
+        test-while-idle: true # 检测到链接空闲时，验证是否有效
+        test-on-borrow: false # 申请链接时，不检测
+        test-on-return: false # 返回链接时，不检测
+        pool-prepared-statements: false # 是否缓存preparedStatement,oracle打开，mysql关闭
+        # 如果上面开启了游标，这里要设置一下大小，例如 50
+        max-pool-prepared-statement-per-connection-size: -1
+        # 统计、监控配置
+        filters: stat,wall # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
+        # 合并执行的相同sql，避免因为参数不同而统计多条sql语句；开启慢sql记录
+        connect-properties: config.stat.mergeSql=true;config.stat.slowSqlMillis=500
+        use-global-data-source-stat: true # 合并多个DruidDataSource的监控数据
+        stat-view-servlet:
+          enabled: true
+          login-username: tianyun
+          login-password: tianyunperfect
+          allow: # 默认运行所有
+          deny: # 默认即可
+          reset-enable: true
+    cpsshard:
+      type: com.alibaba.druid.pool.DruidDataSource
+      driver-class-name: com.mysql.cj.jdbc.Driver
+      jdbc-url: jdbc:mysql://121.41.100.198:3306/test_cps_shard_192?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
+      username: root
+      password: root
+      #下面为连接池补充设置
+      druid:
+        initial-size: 5 # 初始化
+        max-active: 5 # 最大
+        min-idle: 5 # 最小
+        max-wait: 6000 # 超时时间
+        time-between-eviction-runs-millis: 60000 # 每分钟检查一次空闲链接
+        min-evictable-idle-time-millis: 300000 # 空闲链接可以保持多久而不被驱逐
+        # 检测链接是否有效的query
+        validation-query: SELECT 1 FROM DUAL
+        test-while-idle: true # 检测到链接空闲时，验证是否有效
+        test-on-borrow: false # 申请链接时，不检测
+        test-on-return: false # 返回链接时，不检测
+        pool-prepared-statements: false # 是否缓存preparedStatement,oracle打开，mysql关闭
+        # 如果上面开启了游标，这里要设置一下大小，例如 50
+        max-pool-prepared-statement-per-connection-size: -1
+        # 统计、监控配置
+        filters: stat,wall # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
+        # 合并执行的相同sql，避免因为参数不同而统计多条sql语句；开启慢sql记录
+        connect-properties: config.stat.mergeSql=true;config.stat.slowSqlMillis=500
+        use-global-data-source-stat: true # 合并多个DruidDataSource的监控数据
+        stat-view-servlet:
+          enabled: true
+          login-username: tianyun
+          login-password: tianyunperfect
+          allow: # 默认运行所有
+          deny: # 默认即可
+          reset-enable: true
+  redis:
+    database: 0
+    host: 127.0.0.1
+    port: 6379
+    password:
+    lettuce:
+      pool:
+        max-active: 8
+        max-wait: -1
+        max-idle: 8
+        min-idle: 0