SpringBoot连接池druid&&redis实现缓存处理

目录

一、概要分析

二、集成连接池durid

一、连接池分类

 二、集成步骤

1、导入pom.xml

 2、更改yml文件

 三、测试

 三、集成集成缓存redis

   1、导入依赖

 2、更改yml文件

  3、写好配置类

CrossConfiguration：

RedisConfiguration：

3.1 、实现类中使用@cacheable注解开启缓存

​ 3.2、keyGenerator方法的使用

3.3、Template的使用

 4、写好帮助类

RedisUtil：

---

一、概要分析

在日常敲代码的过程中，代码繁多以及运行速度慢，为了提高代码运行速度，优化代码性能，将提供一下两种方法来解决

二、集成连接池durid

一、连接池分类

C3P0：是一个开放源代码的JDBC连接池，它在lib目录中与Hibernate一起发布，包括了实现jdbc3和jdbc2扩展规范说明的Connection 和Statement 池的DataSources 对象。

Proxool：是一个Java SQL Driver驱动程序，提供了对选择的其它类型的驱动程序的连接池封装。可以非常简单的移植到现存的代码中，完全可配置，快速、成熟、健壮。可以透明地为现存的JDBC驱动程序增加连接池功能。

Jakarta DBCP：DBCP是一个依赖Jakartacommons-pool对象池机制的数据库连接池。DBCP可以直接的在应用程序中使用。

BoneCP：是一个快速、开源的数据库连接池。帮用户管理数据连接，让应用程序能更快速地访问数据库。比C3P0/DBCP连接池速度快25倍。

Druid：Druid不仅是一个数据库连接池，还包含一个ProxyDriver（代理程序）、一系列内置的JDBC组件库、一个SQLParser。支持所有JDBC兼容的数据库，包括Oracle、MySql、Derby、Postgresql、SQL Server、H2等（Druid是一个关系型数据库连接池,是阿里巴巴的一个开源项目,Druid在监控,可扩展性,稳定性和性能方面具有比较明显的优势.通过Druid提供的监控功能,可以实时观察数据库连接池和SQL查询的工作情况.使用Druid在一定程度上可以提高数据库的访问技能.）

 二、集成步骤

1、新建模块

  2、导入pom依赖

    
com.alibaba    
druid-spring-boot-starter    
1.2.8

3、更改yml文件

server:
  port: 8080
spring:
  datasource:
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/crm?useSSL=false&serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&allowPublicKeyRetrieval=true
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      initial-size: 5                                       # 初始化大小
      min-idle: 10                                          # 最小连接数
      max-active: 20                                        # 最大连接数
      max-wait: 60000                                       # 获取连接时的最大等待时间
      min-evictable-idle-time-millis: 300000                # 一个连接在池中最小生存的时间，单位是毫秒
      time-between-eviction-runs-millis: 60000              # 多久才进行一次检测需要关闭的空闲连接，单位是毫秒
      filters: stat                                         # 配置扩展插件：stat-监控统计，log4j-日志，wall-防火墙（防止SQL注入），去掉后，监控界面的sql无法统计   ,wall
      validation-query: SELECT 1                            # 检测连接是否有效的 SQL语句，为空时以下三个配置均无效
      test-on-borrow: true                                  # 申请连接时执行validationQuery检测连接是否有效，默认true，开启后会降低性能
      test-on-return: true                                  # 归还连接时执行validationQuery检测连接是否有效，默认false，开启后会降低性能
      test-while-idle: true                                 # 申请连接时如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效，默认false，建议开启，不影响性能
      stat-view-servlet:
        enabled: true                                       # 是否开启 StatViewServlet
        allow: 127.0.0.1                                    # 访问监控页面 白名单，默认127.0.0.1
        deny: 192.168.56.1                                  # 访问监控页面 黑名单
        login-username: admin                               # 访问监控页面 登陆账号
        login-password: 123                                 # 访问监控页面 登陆密码
      filter:
        stat:
          enabled: true                                     # 是否开启 FilterStat，默认true
          log-slow-sql: true                                # 是否开启 慢SQL 记录，默认false
          slow-sql-millis: 5000                             # 慢 SQL 的标准，默认 3000,单位：毫秒
          merge-sql: false                                  # 合并多个连接池的监控数据，默认false
    redis:
      database: 0         #数据库索引
      host: 127.20.10.5     #主机位置
      port: 6379          #端口
      password: 123456           #密码
      jedis:
        pool:
          max-active: 8   #最大连接数
          max-wait: -1    #最大阻塞等待时间(负数表示没限制)
          max-idle: 8     #最大空闲
          min-idle: 0     #最小空闲
      timeout: 10000      #连接超时时间
logging:
  level:
    com.zxy.code.mapper: debug

4、写实体类 

package com.zxy.code.pojo;
 
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
 
/**
 * 学生表	student
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class Student {
    /**
     * 学生编号 主键 自增
     */
    private Long stuId;
 
    /**
     * 学生名字
     */
    private String stuName;
 
    /**
     * 学生电话
     */
    private String stuPhone;
 
    /**
     * 学生班级
     */
    private Long stuClass;
 
    /**
     * 学生地址
     */
    private String stuAddress;
}

5、mapper层 

package com.zxy.code.mapper;
 
import com.zxy.code.pojo.Student;
import org.springframework.stereotype.Repository;
import tk.mybatis.mapper.common.Mapper;
 
//让当前类成为一个bean,被spring容器所管理
@Repository
public interface StudentMapper extends Mapper {
 
}

6、启动类进行管理mapper

Springboot05Application.java类：

package com.zxy.code;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import tk.mybatis.spring.annotation.MapperScan;
 
@SpringBootApplication
@MapperScan("com.zxy.code.mapper")
//开启切面的自动代理
@EnableAspectJAutoProxy
//开启事务管理器
@EnableTransactionManagement
public class Springboot05Application {
 
    public static void main(String[] args) {
        SpringApplication.run(Springboot05Application.class, args);
    }
 
}

7、service层

导入PageBean分页与PageAspect切面

PageBean分页：

package com.zxy.code.util;
 
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
 
import javax.servlet.http.HttpServletRequest;
import java.util.Map;
 

@Data
@NoArgsConstructor
@AllArgsConstructor
public class PageBean {
 
    private int total;
    private int page = 1;
    private int rows = 5;
    private boolean pagination = true;
    private String url;
    private Map ms;
 
    public void setMs(Map ms) {
        this.ms = ms;
    }
 
    public int calcStartIndex() {
        return (page - 1) * rows;
    }
 
    public int calcMaxPage() {
        return total % rows == 0 ? total / rows : total / rows + 1;
    }
 
    public int nextPage() {
        return page + 1 > calcMaxPage() ? calcMaxPage() : page + 1;
    }
 
    public int prevPage() {
        return page - 1 > 1 ? page - 1 : 1;
    }
 
    public void setRequest(HttpServletRequest req) {
        setUrl(req.getRequestURL().toString());
        setMs(req.getParameterMap());
        String page = req.getParameter("page");
        if (page == null) {
            setPage(1);
        } else {
            setPage(Integer.parseInt(page));
        }
        String rows = req.getParameter("rows");
        if (rows == null) {
            setRows(5);
        } else {
            setRows(Integer.parseInt(rows));
        }
        String pagination = req.getParameter("pagination");
        if (pagination != null && "false".equals(pagination)) {
            setPagination(false);
        }
    }
 
}

PageAspect切面：

package com.zxy.code.aspect;
 
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.zxy.code.util.PageBean;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;


//让此类成为一个bean
@Component
@Aspect
@Slf4j
public class PageAspect {
 
    @Around(value = "execution(* *..*Service.*Pager(..))")
    public Object invoke(ProceedingJoinPoint point) throws Throwable {
        PageBean pageBean = null;
        for (Object e : point.getArgs()) {
            if (e instanceof PageBean) {
                pageBean = (PageBean) e;
                break;
            }
        }
        if (pageBean != null && pageBean.isPagination()) {
            PageHelper.startPage(pageBean.getPage(), pageBean.getRows());
        }
        Object obj = point.proceed(point.getArgs());
        if (obj != null) {
            if (obj instanceof Page) {
                Page page = (Page) obj;
                PageInfo pageInfo = new PageInfo(page);
                pageBean.setTotal(new Long(pageInfo.getTotal()).intValue());
                return pageInfo.getList();
            }
        }
        return obj;
    }
 
}

接口StudentService.java:

package com.zxy.code.service;
 
import com.zxy.code.pojo.Student;
import com.zxy.code.util.PageBean;
 
import java.util.List;
 
public interface StudentService {
 
    List findPager(PageBean pageBean);
 
}

 实现接口StudentServiceImpl：

package com.zxy.code.service;
 
import com.zxy.code.mapper.StudentMapper;
import com.zxy.code.pojo.Student;
import com.zxy.code.util.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.util.List;
 
@Service
public class StudentServiceImpl implements StudentService {
 
    @Autowired
    private StudentMapper mapper;
 
    @Override
    public List findPager(PageBean pageBean) {
        return mapper.selectAll();
    }
 
}

 8、测试

Springboot05ApplicationTests ：

package com.zxy.code;
 
import com.zxy.code.service.StudentService;
import com.zxy.code.util.PageBean;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
 
@SpringBootTest
class Springboot05ApplicationTests {
 
    @Autowired
    private StudentService service;
 
    @Test
    void contextLoads() {
        PageBean pageBean=new PageBean();
        service.findPager(pageBean).forEach(System.out::println);
    }
 
}

效果

数据查询出来后，下一步如果想知道查询了那些语句，那么这里就需要用到数据源连接池监控“监控地址（http://localhost:8080/druid/login.html） ”这里就可以看见你查询那些语句，和执行时间多久。好处是使用Druid在一定程度上可以提高数据库的访问技能.，方便对数据进行整理。

分页插件yml 

pagehelper : # https://pagehelper.github.io/docs/howtouse

# 是否启用分页合理化。如果启用 , 当 page<1 时 , 会自动查询第一页的数据

# 当 page>maxPages 时 , 自动查询最后一页数据

# 不启用的 , 以上两种情况都会返回空数据

reasonable : true

# 分页插件会从查询方法的参数值中 , 自动根据上面 params 配置的字段中取值 , 查找到合适的值时就会

自动分页

supportMethodsArguments : true

# 默认值为 false, 当该参数设置为 true 时 , 如果 pageSize=0 或者 RowBounds.limit = 0 就

会查询出全部的结果

page-size-zero : true

# 指定数据库 , 不指定的话会默认自动检测数据库类型

helper-dialect : mysq

 三、集成集成缓存redis

   1、导入依赖

    
org.springframework.boot    
spring-boot-starter-data-redis

 2、更改yml文件

redis:
  database: 0         #数据库索引
  host:      #主机位置
  port:           #端口
  password:            #密码
  jedis:
    pool:
      max-active: 8   #最大连接数
      max-wait: -1    #最大阻塞等待时间(负数表示没限制)
      max-idle: 8     #最大空闲
      min-idle: 0     #最小空闲
  timeout: 10000      #连接超时时间

3、controller层

package com.lv.code.controller;
 
import com.lv.code.service.StudentService;
import com.lv.code.util.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import javax.servlet.http.HttpServletRequest;
 
//输出json数据
@RestController
//访问路径
@RequestMapping("stu")
public class StudentController {
 
    @Autowired
    private StudentService service;
 
    @GetMapping("/all")
    public Object index(HttpServletRequest request){
        PageBean pageBean=new PageBean();
        pageBean.setRequest(request);
        return service.findPager(pageBean);
    }
 
}

  4、写好配置类

CrossConfiguration：

package com.zxy.code.conf;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;


/**
 * @author zjjt
 */
@Configuration
public class CrossConfiguration extends WebMvcConfigurerAdapter {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry
                /*可以跨域的路径*/
                .addMapping("/**")
                /*可以跨域的ip*/
                .allowedOrigins("*")
                /*可以跨域的方法*/
                .allowedMethods("*")
                /*设置预检请求多就失效*/
                .maxAge(6000)
                /*允许携带的头部*/
                .allowedHeaders("*");
    }

}

RedisConfiguration：

package com.zxy.code.conf;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.util.ClassUtils;

import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.time.Duration;

/**
 * @author zjjt
 */
@Configuration
@EnableCaching //开启缓存
public class RedisConfiguration extends CachingConfigurerSupport {

    //@Bean 相当于 @Component，只不过Bean可以写在方法上面，内在跟Component是一样的
    @Bean
    @Primary
    CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .computePrefixWith(cacheName -> cacheName + ":-cache-:")
                /*设置缓存过期时间*/
                .entryTtl(Duration.ofHours(1))
                /*禁用缓存空值,不缓存null校验*/
                .disableCachingNullValues()
                /*设置CacheManager的值序列化方式为json序列化,可使用加入@Class属性*/
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(
                        new GenericJackson2JsonRedisSerializer()
                ));
        /*使用RedisCacheConfiguration创建RedisCacheManager*/
        RedisCacheManager manager = RedisCacheManager.builder(factory)
                .cacheDefaults(cacheConfiguration)
                .build();
        return manager;
    }

    @Bean
    @Primary
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(factory);
        RedisSerializer stringSerializer = new StringRedisSerializer();
        /* key序列化 */
        redisTemplate.setKeySerializer(stringSerializer);
        /* value序列化 */
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        /* Hash key序列化 */
        redisTemplate.setHashKeySerializer(stringSerializer);
        /* Hash value序列化 */
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    @Primary
    @Override
    public KeyGenerator keyGenerator() {
        return (Object target, Method method, Object... params) -> {
            final int NO_PARAM_KEY = 0;
            final int NULL_PARAM_KEY = 53;
            StringBuilder key = new StringBuilder();
            /* Class.Method: */
            key.append(target.getClass().getSimpleName())
                    .append(".")
                    .append(method.getName())
                    .append(":");
            if (params.length == 0) {
                return key.append(NO_PARAM_KEY).toString();
            }
            int count = 0;
            for (Object param : params) {
                /* 参数之间用,进行分隔 */
                if (0 != count) {
                    key.append(',');
                }
                if (param == null) {
                    key.append(NULL_PARAM_KEY);
                } else if (ClassUtils.isPrimitiveArray(param.getClass())) {
                    int length = Array.getLength(param);
                    for (int i = 0; i < length; i++) {
                        key.append(Array.get(param, i));
                        key.append(',');
                    }
                } else if (ClassUtils.isPrimitiveOrWrapper(param.getClass()) || param instanceof String) {
                    key.append(param);
                } else {
                    /*JavaBean一定要重写hashCode和equals*/
                    key.append(param.hashCode());
                }
                count++;
            }
            return key.toString();
        };
    }

}

cachemManager缓存管理器

redisTemplate直接用它操作redis里面的内容 

keyGenerator 主键生成器

3.1 、实现类中使用@cacheable注解开启缓存

  @Cacheable(cacheNames = "aa",cacheManager = "cacheManager")    //用来声明方法是
    public List findPager(PageBean pageBean){
        return  mapper.selectAll();
    }

cacheNames是缓存的名字用来做分类的，查看缓存时方便，可以在类上进行注解，表示所有的方法的缓存名字都为指定名字

cacheManager是缓存管理器

第一次运行会出现sql语句，然后数据会进入redis缓存中

  当修改cacheManager时

 redis

 3.2、keyGenerator方法的使用

 

 redis：

key用来标识方法的结果，由键去找值，找不到进数据库，要去缓存用户信息，我们一般把用户的id作为键

spel表达式使用#取值

例如

 @Override
    @Cacheable(key ="#pageBean.page")    //用来声明方法是
    public List findPager(PageBean pageBean){
        return  mapper.selectAll();
    }

cachePut用来更新缓存，用来做修改

cacheEvict用来删除缓存，通过键key

3.3、Template的使用

 4、写好帮助类

RedisUtil：

package com.zxy.code.util;

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.data.redis.RedisSystemException;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.connection.jedis.JedisConnection;
import org.springframework.data.redis.connection.lettuce.LettuceConnection;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.stereotype.Component;

import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.TimeUnit;

/**
 * Redis工具类
 * 

 * 声明: 此工具只简单包装了redisTemplate的大部分常用的api,没有包装redisTemplate所有的api
 * 如果对此工具类中的功能不太满意,或对StringRedisTemplate提供的api不太满意,
 * 那么可自行实现相应的{@link StringRedisTemplate}类中的对应execute方法,以达
 * 到自己想要的效果; 至于如何实现,则可参考源码或{@link LockOps}中的方法
 * 

 * 注: 此工具类依赖spring-boot-starter-data-redis类库
 * 注: 更多javadoc细节,可详见{@link RedisOperations}
 * 

 * 统一说明一: 方法中的key、 value都不能为null
 * 统一说明二: 不能跨数据类型进行操作,否者会操作失败/操作报错
 * 如: 向一个String类型的做Hash操作,会失败/报错......等等
 */
@Slf4j
@Component
@SuppressWarnings("unused")
public class RedisUtil implements ApplicationContextAware {

    /**
     * 使用StringRedisTemplate(,其是RedisTemplate的定制化升级)
     */
    private static StringRedisTemplate redisTemplate;

    private static final ObjectMapper mapper = new ObjectMapper();

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        RedisUtil.redisTemplate = applicationContext.getBean(StringRedisTemplate.class);
    }

    /**
     * key相关操作
     */
    public static class KeyOps {

        /**
         * 根据key,删除redis中的对应key-value
         * 

         * 注: 若删除失败,则返回false
         * 

         * 若redis中,不存在该key,那么返回的也是false
         * 所以,不能因为返回了false,就认为redis中一定还存
         * 在该key对应的key-value
         *
         * @param key 要删除的key
         * @return 删除是否成功
         */
        public static Boolean delete(String key) {
            log.info("delete(...) => key -> {}", key);
            // 返回值只可能为true/false,不可能为null
            Boolean result = redisTemplate.delete(key);
            log.info("delete(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 根据keys,批量删除key-value
         * 

         * 注: 若redis中,不存在对应的key,那么计数不会加1,即:
         * redis中存在的key-value里,有名为a1、a2的key,
         * 删除时,传的集合是a1、a2、a3,那么返回结果为2
         *
         * @param keys 要删除的key集合
         * @return 删除了的key-value个数
         */
        public static long delete(Collection keys) {
            log.info("delete(...) => keys -> {}", keys);
            Long count = redisTemplate.delete(keys);
            log.info("delete(...) => count -> {}", count);
            if (count == null) {
                throw new RedisOpsResultIsNullException();
            }
            return count;
        }

        /**
         * 将key对应的value值进行序列化,并返回序列化后的value值
         * 

         * 注: 若不存在对应的key,则返回null
         * 注: dump时,并不会删除redis中的对应key-value
         * 注: dump功能与restore相反
         *
         * @param key 要序列化的value的key
         * @return 序列化后的value值
         */
        public static byte[] dump(String key) {
            log.info("dump(...) =>key -> {}", key);
            byte[] result = redisTemplate.dump(key);
            log.info("dump(...) => result -> {}", result);
            return result;
        }

        /**
         * 将给定的value值,反序列化到redis中,形成新的key-value
         *
         * @param key        value对应的key
         * @param value      要反序列的value值
         *                   注: 这个值可以由{@link this#dump(String)}获得
         * @param timeToLive 反序列化后的key-value的存活时长
         * @param unit       timeToLive的单位
         * @throws RedisSystemException 如果redis中已存在同样的key时,抛出此异常
         */
        public static void restore(String key, byte[] value, long timeToLive, TimeUnit unit) {
            restore(key, value, timeToLive, unit, false);
        }

        /**
         * 将给定的value值,反序列化到redis中,形成新的key-value
         *
         * @param key     value对应的key
         * @param value   要反序列的value值
         *                注: 这个值可以由{@link this#dump(String)}获得
         * @param timeout 反序列化后的key-value的存活时长
         * @param unit    timeout的单位
         * @param replace 若redis中已经存在了相同的key,是否替代原来的key-value
         * @throws RedisSystemException 如果redis中已存在同样的key,且replace为false时,抛出此异常
         */
        public static void restore(String key, byte[] value, long timeout, TimeUnit unit, boolean replace) {
            log.info("restore(...) => key -> {},value -> {},timeout -> {},unit -> {},replace -> {}",
                    key, value, timeout, unit, replace);
            redisTemplate.restore(key, value, timeout, unit, replace);
        }

        /**
         * redis中是否存在,指定key的key-value
         *
         * @param key 指定的key
         * @return 是否存在对应的key-value
         */
        public static boolean hasKey(String key) {
            log.info("hasKey(...) => key -> {}", key);
            Boolean result = redisTemplate.hasKey(key);
            log.info("hasKey(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 给指定的key对应的key-value设置: 多久过时
         * 

         * 注:过时后,redis会自动删除对应的key-value
         * 注:若key不存在,那么也会返回false
         *
         * @param key     指定的key
         * @param timeout 过时时间
         * @param unit    timeout的单位
         * @return 操作是否成功
         */
        public static boolean expire(String key, long timeout, TimeUnit unit) {
            log.info("expire(...) => key -> {},timeout -> {},unit -> {}", key, timeout, unit);
            Boolean result = redisTemplate.expire(key, timeout, unit);
            log.info("expire(...) => result is -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 给指定的key对应的key-value设置: 什么时候过时
         * 

         * 注:过时后,redis会自动删除对应的key-value
         * 注:若key不存在,那么也会返回false
         *
         * @param key  指定的key
         * @param date 啥时候过时
         * @return 操作是否成功
         */
        public static boolean expireAt(String key, Date date) {
            log.info("expireAt(...) => key -> {},date -> {}", key, date);
            Boolean result = redisTemplate.expireAt(key, date);
            log.info("expireAt(...) => result is -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 找到所有匹配pattern的key,并返回该key的结合.
         * 

         * 提示:若redis中键值对较多,此方法耗时相对较长,慎用！慎用！慎用！
         *
         * @param pattern 匹配模板
         *                注: 常用的通配符有:
         *                ?    有且只有一个;
         *                *     >=0个;
         * @return 匹配pattern的key的集合 可能为null
         */
        public static Set keys(String pattern) {
            log.info("keys(...) => pattern -> {}", pattern);
            Set keys = redisTemplate.keys(pattern);
            log.info("keys(...) => keys -> {}", keys);
            return keys;
        }

        /**
         * 将当前数据库中的key对应的key-value,移动到对应位置的数据库中
         * 

         * 注:单机版的redis,默认将存储分为16个db,index为0 到 15
         * 注:同一个db下,key唯一； 但是在不同db中,key可以相同
         * 注:若目标db下,已存在相同的key,那么move会失败,返回false
         *
         * @param key     定位要移动的key-value的key
         * @param dbIndex 要移动到哪个db
         * @return 移动是否成功
         * 注: 若目标db下,已存在相同的key,那么move会失败,返回false
         */
        public static boolean move(String key, int dbIndex) {
            log.info("move(...) => key  -> {},dbIndex -> {}", key, dbIndex);
            Boolean result = redisTemplate.move(key, dbIndex);
            log.info("move(...) =>result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 移除key对应的key-value的过期时间,使该key-value一直存在
         * 

         * 注: 若key对应的key-value,本身就是一直存在(无过期时间的),那么persist方法会返回false;
         * 若没有key对应的key-value存在,本那么persist方法会返回false;
         *
         * @param key 定位key-value的key
         * @return 操作是否成功
         */
        public static boolean persist(String key) {
            log.info("persist(...) => key -> {}", key);
            Boolean result = redisTemplate.persist(key);
            log.info("persist(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 获取key对应的key-value的过期时间
         * 

         * 注: 若key-value永不过期,那么返回的为-1
         * 注: 若不存在key对应的key-value,那么返回的为-2
         * 注:若存在零碎时间不足1 SECONDS,则(大体上)四舍五入到SECONDS级别
         *
         * @param key 定位key-value的key
         * @return 过期时间(单位s)
         */
        public static long getExpire(String key) {
            return getExpire(key, TimeUnit.SECONDS);
        }

        /**
         * 获取key对应的key-value的过期时间
         * 

         * 注: 若key-value永不过期,那么返回的为-1
         * 注: 若不存在key对应的key-value,那么返回的为-2
         * 注:若存在零碎时间不足1 unit,则(大体上)四舍五入到unit别
         *
         * @param key 定位key-value的key
         * @return 过期时间(单位unit)
         */
        public static long getExpire(String key, TimeUnit unit) {
            log.info("getExpire(...) =>key -> {},unit is -> {}", key, unit);
            Long result = redisTemplate.getExpire(key, unit);
            log.info("getExpire(...) => result ->  {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 从redis的所有key中,随机获取一个key
         * 

         * 注: 若redis中不存在任何key-value,那么这里返回null
         *
         * @return 随机获取到的一个key
         */
        public static String randomKey() {
            String result = redisTemplate.randomKey();
            log.info("randomKey(...) => result is -> {}", result);
            return result;
        }

        /**
         * 重命名对应的oldKey为新的newKey
         * 

         * 注: 若oldKey不存在,则会抛出异常.
         * 注: 若redis中已存在与newKey一样的key,
         * 那么原key-value会被丢弃,
         * 只留下新的key,以及原来的value
         * 示例说明: 假设redis中已有 (keyAlpha,valueAlpha) 和 (keyBeta,valueBeat),
         * 在使用rename(keyAlpha,keyBeta)替换后,redis中只会剩下(keyBeta,valueAlpha)
         *
         * @param oldKey 旧的key
         * @param newKey 新的key
         * @throws RedisSystemException 若oldKey不存在时,抛出此异常
         */
        public static void rename(String oldKey, String newKey) {
            log.info("rename(...) => oldKey -> {},newKey -> {}", oldKey, newKey);
            redisTemplate.rename(oldKey, newKey);
        }

        /**
         * 当redis中不存在newKey时,重命名对应的oldKey为新的newKey
         * 否者不进行重命名操作
         * 

         * 注: 若oldKey不存在,则会抛出异常.
         *
         * @param oldKey 旧的key
         * @param newKey 新的key
         * @throws RedisSystemException 若oldKey不存在时,抛出此异常
         */
        public static boolean renameIfAbsent(String oldKey, String newKey) {
            log.info("renameIfAbsent(...) => oldKey -> {},newKey -> {}", oldKey, newKey);
            Boolean result = redisTemplate.renameIfAbsent(oldKey, newKey);
            log.info("renameIfAbsent(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 获取key对应的value的数据类型
         * 

         * 注: 若redis中不存在该key对应的key-value,那么这里返回NONE
         *
         * @param key 用于定位的key
         * @return key对应的value的数据类型
         */
        public static DataType type(String key) {
            log.info("type(...) => key -> {}", key);
            DataType result = redisTemplate.type(key);
            log.info("type(...) => result -> {}", result);
            return result;
        }
    }

    /**
     * string相关操作
     */
    public static class StringOps {

        /**
         * 设置key-value
         * 

         * 注: 若已存在相同的key,那么原来的key-value会被丢弃
         *
         * @param key   key
         * @param value key对应的value
         */
        public static void set(String key, String value) {
            log.info("set(...) => key -> {},value -> {}", key, value);
            redisTemplate.opsForValue().set(key, value);
        }

        /**
         * 处理redis中key对应的value值,将第offset位的值,设置为1或0
         * 

         * 说明: 在redis中,存储的字符串都是以二级制的进行存在的; 如存储的key-value里,值为abc,实际上,
         * 在redis里面存储的是011000010110001001100011,前8为对应a,中间8为对应b,后面8位对应c
         * 示例：这里如果setBit(key,6,true)的话,就是将索引位置6的那个数,设置值为1,值就变成
         * 了011000110110001001100011
         * 追注:offset即index,从0开始
         * 

         * 注: 参数value为true,则设置为1；参数value为false,则设置为0
         * 

         * 注: 若redis中不存在对应的key,那么会自动创建新的
         * 注: offset可以超过value在二进制下的索引长度
         *
         * @param key    定位value的key
         * @param offset 要改变的bit的索引
         * @param value  改为1或0,true - 改为1,false - 改为0
         * @return set是否成功
         */
        public static boolean setBit(String key, long offset, boolean value) {
            log.info("setBit(...) => key -> {},offset -> {},value -> {}", key, offset, value);
            Boolean result = redisTemplate.opsForValue().setBit(key, offset, value);
            log.info("setBit(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 设置key-value
         * 

         * 注: 若已存在相同的key,那么原来的key-value会被丢弃
         *
         * @param key     key
         * @param value   key对应的value
         * @param timeout 过时时长
         * @param unit    timeout的单位
         */
        public static void setEx(String key, String value, long timeout, TimeUnit unit) {
            log.info("setEx(...) => key -> {},value -> {},timeout -> {},unit -> {}",
                    key, value, timeout, unit);
            redisTemplate.opsForValue().set(key, value, timeout, unit);
        }

        /**
         * 若不存在key时,向redis中添加key-value,返回成功/失败
         * 若存在,则不作任何操作,返回false
         *
         * @param key   key
         * @param value key对应的value
         * @return set是否成功
         */
        public static boolean setIfAbsent(String key, String value) {
            log.info("setIfAbsent(...) => key -> {},value -> {}", key, value);
            Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value);
            log.info("setIfAbsent(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 若不存在key时,向redis中添加一个(具有超时时长的)key-value,返回成功/失败
         * 若存在,则不作任何操作,返回false
         *
         * @param key     key
         * @param value   key对应的value
         * @param timeout 超时时长
         * @param unit    timeout的单位
         * @return set是否成功
         */
        public static boolean setIfAbsent(String key, String value, long timeout, TimeUnit unit) {
            log.info("setIfAbsent(...) => key -> {},value -> {},key -> {},value -> {}", key, value, timeout, unit);
            Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value, timeout, unit);
            log.info("setIfAbsent(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 从(redis中key对应的)value的offset位置起(包含该位置),用replaceValue替换对应长度的值
         * 

         * 举例说明:
         * 1.假设redis中存在key-value ("ds","0123456789"); 调
         * 用setRange("ds","abcdefghijk",3)后,redis中该value值就变为了[012abcdefghijk]
         * 

         * 2.假设redis中存在key-value ("jd","0123456789");调
         * 用setRange("jd","xyz",3)后,redis中该value值就变为了[012xyz6789]
         * 

         * 3.假设redis中存在key-value ("ey","0123456789");调
         * 用setRange("ey","qwer",15)后,redis中该value值就变为了[0123456789     qwer]
         * 注:case3比较特殊,offset超过了原value的长度了,中间就会有一些空格来填充,但是如果在程序
         * 中直接输出的话,中间那部分空格可能会出现乱码
         *
         * @param key          定位key-value的key
         * @param replaceValue 要替换的值
         * @param offset       起始位置
         */
        public static void setRange(String key, String replaceValue, long offset) {
            log.info("setRange(...) => key -> {},replaceValue -> {},offset -> {}", key, replaceValue, offset);
            redisTemplate.opsForValue().set(key, replaceValue, offset);
        }

        /**
         * 获取到key对应的value的长度
         * 

         * 注: 长度等于{@link String#length}
         * 注: 若redis中不存在对应的key-value,则返回值为0.
         *
         * @param key 定位value的key
         * @return value的长度
         */
        public static long size(String key) {
            log.info("size(...) => key -> {}", key);
            Long result = redisTemplate.opsForValue().size(key);
            log.info("size(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 批量设置 key-value
         * 

         * 注: 若存在相同的key,则原来的key-value会被丢弃
         *
         * @param maps key-value 集
         */
        public static void multiSet(Map maps) {
            log.info("multiSet(...) => maps -> {}", maps);
            redisTemplate.opsForValue().multiSet(maps);
        }

        /**
         * 当redis中,不存在任何一个keys时,才批量设置 key-value,并返回成功/失败.
         * 否者,不进行任何操作,并返回false
         * 

         * 即: 假设调用此方法时传入的参数map是这样的: {k1=v1,k2=v2,k3=v3}
         * 那么redis中,k1、k2、k3都不存在时,才会批量设置key-value;
         * 否则不会设置任何key-value
         * 

         * 注: 若存在相同的key,则原来的key-value会被丢弃
         * 

         * 注:
         *
         * @param maps key-value 集
         * @return 操作是否成功
         */
        public static boolean multiSetIfAbsent(Map maps) {
            log.info("multiSetIfAbsent(...) => maps -> {}", maps);
            Boolean result = redisTemplate.opsForValue().multiSetIfAbsent(maps);
            log.info("multiSetIfAbsent(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 增/减 整数
         * 

         * 注: 负数则为减
         * 注: 若key对应的value值不支持增/减操作(即: value不是数字),那么会
         * 抛出org.springframework.data.redis.RedisSystemException
         *
         * @param key       用于定位value的key
         * @param increment 增加多少
         * @return 增加后的总值
         * @throws RedisSystemException key对应的value值不支持增/减操作时
         */
        public static long incrBy(String key, long increment) {
            log.info("incrBy(...) => key -> {},increment -> {}", key, increment);
            Long result = redisTemplate.opsForValue().increment(key, increment);
            log.info("incrBy(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 增/减 浮点数
         * 

         * 注: 慎用浮点数,会有精度问题
         * 如: 先 RedisUtil.StringOps.set("ds","123");
         * 然后再RedisUtil.StringOps.incrByFloat("ds",100.6);
         * 就会看到精度问题
         * 注: 负数则为减
         * 注: 若key对应的value值不支持增/减操作(即: value不是数字),那么会
         * 抛出org.springframework.data.redis.RedisSystemException
         *
         * @param key       用于定位value的key
         * @param increment 增加多少
         * @return 增加后的总值
         * @throws RedisSystemException key对应的value值不支持增/减操作时
         */
        public static double incrByFloat(String key, double increment) {
            log.info("incrByFloat(...) => key -> {},increment -> {}", key, increment);
            Double result = redisTemplate.opsForValue().increment(key, increment);
            log.info("incrByFloat(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 追加值到末尾
         * 

         * 注: 当redis中原本不存在key时,那么（从效果上来看）此方法就等价于{@link this#set(String, String)}
         *
         * @param key   定位value的key
         * @param value 要追加的value值
         * @return 追加后, 整个value的长度
         */
        public static int append(String key, String value) {
            log.info("append(...) => key -> {},value -> {}", key, value);
            Integer result = redisTemplate.opsForValue().append(key, value);
            log.info("append(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 根据key,获取到对应的value值
         *
         * @param key key-value对应的key
         * @return 该key对应的值
         * 注: 若key不存在,则返回null
         */
        public static String get(String key) {
            log.info("get(...) => key -> {}", key);
            String result = redisTemplate.opsForValue().get(key);
            log.info("get(...) => result -> {} ", result);
            return result;
        }

        /**
         * 对(key对应的)value进行截取,截取范围为[start,end]
         * 

         * 注: 若[start,end]的范围不在value的范围中,那么返回的是空字符串 ""
         * 注: 若value只有一部分在[start,end]的范围中,那么返回的是value对应部分的内容(即:不足的地方,并不会以空来填充)
         *
         * @param key   定位value的key
         * @param start 起始位置 (从0开始)
         * @param end   结尾位置 (从0开始)
         * @return 截取后的字符串
         */
        public static String getRange(String key, long start, long end) {
            log.info("getRange(...) => kry -> {}", key);
            String result = redisTemplate.opsForValue().get(key, start, end);
            log.info("getRange(...) => result -> {} ", result);
            return result;
        }

        /**
         * 给指定key设置新的value,并返回旧的value
         * 

         * 注: 若redis中不存在key,那么此操作仍然可以成功,不过返回的旧值是null
         *
         * @param key      定位value的key
         * @param newValue 要为该key设置的新的value值
         * @return 旧的value值
         */
        public static String getAndSet(String key, String newValue) {
            log.info("getAndSet(...) => key -> {},value -> {}", key, newValue);
            String oldValue = redisTemplate.opsForValue().getAndSet(key, newValue);
            log.info("getAndSet(...) => oldValue -> {}", oldValue);
            return oldValue;
        }

        /**
         * 获取(key对应的)value在二进制下,offset位置的bit值
         * 

         * 注: 当offset的值在(二进制下的value的)索引范围外时,返回的也是false
         * 

         * 示例:
         * RedisUtil.StringOps.set("akey","a");
         * 字符串a,转换为二进制为01100001
         * 那么getBit("akey",6)获取到的结果为false
         *
         * @param key    定位value的key
         * @param offset 定位bit的索引
         * @return offset位置对应的bit的值(true - 1, false - 0)
         */
        public static boolean getBit(String key, long offset) {
            log.info("getBit(...) => key -> {},offset -> {}", key, offset);
            Boolean result = redisTemplate.opsForValue().getBit(key, offset);
            log.info("getBit(...) => result -> {}", result);
            if (result == null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 批量获取value值
         * 

         * 注: 若redis中,对应的key不存在,那么该key对应的返回的value值为null
         *
         * @param keys key集
         * @return value值集合
         */
        public static List multiGet(Collection keys) {
            log.info("multiGet(...) => keys -> {}", keys);
            List result = redisTemplate.opsForValue().multiGet(keys);
            log.info("multiGet(...) => result -> {}", result);
            return result;
        }
    }

    /**
     * hash相关操作
     * 

     * 提示: 简单的,可以将redis中hash的数据结构看作是 Map>
     */
    public static class HashOps {

        /**
         * 向key对应的hash中,增加一个键值对entryKey-entryValue
         * 

         * 注: 同一个hash里面,若已存在相同的entryKey,那么此操作将丢弃原来的entryKey-entryValue,
         * 而使用新的entryKey-entryValue
         *
         * @param key        定位hash的key
         * @param entryKey   要向hash中增加的键值对里的 键
         * @param entryValue 要向hash中增加的键值对里的 值
         */
        public static void hPut(String key, String entryKey, String entryValue) {
            log.info("hPut(...) => key -> {},entryKey -> {},entryValue -> {}", key, entryKey, entryValue);
            redisTemplate.opsForHash().put(key, entryKey, entryValue);
        }

        /**
         * 向key对应的hash中,增加maps(即: 批量增加entry集)
         * 

         * 注: 同一个hash里面,若已存在相同的entryKey,那么此操作将丢弃原来的entryKey-entryValue,
         * 而使用新的entryKey-entryValue
         *
         * @param key  定位hash的key
         * @param maps 要向hash中增加的键值对集
         */
        public static void hPutAll(String key, Map maps) {
            log.info("hPutAll(...) => key -> {},maps -> {}", key, maps);
            redisTemplate.opsForHash().putAll(key, maps);
        }

        /**
         * 当key对应的hash中,不存在entryKey时,才(向key对应的hash中,)增加entryKey-entryValue
         * 否则,不进行任何操作
         *
         * @param key        定位hash的key
         * @param entryKey   要向hash中增加的键值对里的 键
         * @param entryValue 要向hash中增加的键值对里的 值
         * @return 操作是否成功
         */
        public static boolean hPutIfAbsent(String key, String entryKey, String entryValue) {
            log.info("hPutIfAbsent(...) => key -> {},entryKey -> {},entryValue -> {}",
                    key, entryKey, entryValue);
            Boolean result = redisTemplate.opsForHash().putIfAbsent(key, entryKey, entryValue);
            log.info("hPutIfAbsent(...) => result -> {}", result);
            if (result != null) {
                throw new RedisOpsResultIsNullException();
            }
            return result;
        }

        /**
         * 获取到key对应的hash里面的对应字段的值
         * 

         * 注: 若redis中不存在对应的key,则返回null
         * 若key对应的hash中不存在对应的entryKey,也会返回null
         *
         * @param key      定位hash的key
         * @param entryKey 定位hash里面的entryValue的entryKey
         * @return key对应的hash里的entryKey对应的entryValue值
         */
        public static Object hGet(String key, String entryKey) {
            log.info("hGet(...) => key -> {},entryKey -> {}", key, entryKey);
            Object entryValue = redisTemplate.opsForHash().get(key, entryKey);
            log.info("hGet(...) => entryValue -> {}", entryValue);
            return entryValue;
        }

        /**
         * 获取到key对应的hash(即: 获取到key对应的Map)
         * 

         * 注: 若redis中不存在对应的key,则返回一个没有任何entry的空的Map(,而不是返回null)
         *
         * @param key 定位hash的key
         * @return key对应的hash
         */
        public static Map hGetAll(String key) {
            log.info("hGetAll(...) => key -> {}", key);
            Map result = redisTemplate.opsForHash().entries(key);
            log.info("hGetAll(...) => result -> {}", result);
            return result;
        }

        /**
         * 批量获取(key对应的)hash中的entryKey的entryValue
         * 

         * 注: 若hash中对应的entryKey不存在,那么返回的对应的entryValue值为null
         * 注: redis中key不存在,那么返回的List中,每个元素都为null
         * 追注: 这个List本身不为null,size也不为0,只是每个list中的每个元素为null而已
         *
         * @param key       定位hash的key
         * @param entryKeys 需要获取的hash中的字段集
         * @return hash中对应entryKeys的对应entryValue集
         */
        public static List