springboot2.2.2企业级项目整合redis与redis 工具类大全

1.springboot2.2.2整合redis教程很多，为此编写了比较完整的redis工具类，符合企业级开发使用的工具类

2.springboot与redis maven相关的依赖

<dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-parent</artifactId>
                <version>2.2.2.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
        <!--redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

3.application.yml中加入redis相关的配置

server:
  port: 8080
  servlet:
    context-path: /project/v101
    session:
      timeout: 3600s
    tomcat:
      uri-encoding: utf-8

spring:
  # 对象属性值，为 null，则不显示属性名
  jackson:
    default-property-inclusion: non_null
  datasource:
    name: demo
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=GMT%2B8
    # driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      initialSize: 5
      minIdle: 5
      maxActive: 20
      maxWait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1 FROM DUAL
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      poolPreparedStatements: true
      maxPoolPreparedStatementPerConnectionSize: 20
      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      filters: stat,wall,log4j
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      # 自定义属性，用于druid监控界面的账号、密码配置
      servlet:
        username: root
        password: root
  http:
    log-request-details: true

  servlet:
    multipart:
      max-file-size: 20MB
      max-request-size: 30MB
      file-size-threshold: 0
      enabled: true
　# redis配置
  redis:
    host: localhost
    port: 6379
    password: 123456
    database: 0

mybatis-plus:
  global-config:
    db-config:
      logic-delete-value: 1 # 逻辑已删除值(默认为 0)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 1)
  mapper-locations: classpath:mapper/**/*Mapper.xml
  #  config-location: classpath:mybatis-config.xml
  # MyBaits 别名包扫描路径，通过该属性可以给包中的类注册别名
  type-aliases-package: com.houtang.saas.pms.domain.entity
  configuration:
    # 开启驼峰匹配
    map-underscore-to-camel-case: true
    # 这个配置使全局的映射器启用或禁用缓存。系统默认值是true
    cache-enabled: true
    # 全局启用或禁用延迟加载。当禁用时，所有关联对象都会即时加载。系统默认值是true
    lazy-loading-enabled: true
    # 允许或不允许多种结果集从一个单独的语句中返回（需要适合的驱动）。系统默认值是true
    multiple-result-sets-enabled: true
    # 使用列标签代替列名。不同的驱动在这方便表现不同。参考驱动文档或充分测试两种方法来决定所使用的驱动
    use-column-label: true
    # 允许 JDBC 支持生成的键。需要适合的驱动。如果设置为 true 则这个设置强制生成的键被使用，尽管一些驱动拒绝兼容但仍然有效（比如Derby）
    use-generated-keys: false
    # 配置默认的执行器。SIMPLE 执行器没有什么特别之处。REUSE 执行器重用预处理语句。BATCH 执行器重用语句和批量更新
    default-executor-type: simple
    # 设置超时时间，它决定驱动等待一个数据库响应的时间
    default-statement-timeout: 25000

pagehelper:
  helper-dialect: mysql
  reasonable: true
  support-methods-arguments: true
  params: count=countSql

4.编写自定义redis配置类（由于springboot 整合的redisTemplate<Object,Object> 只能操作Object对象，通过源码可以看出，SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个StringRedisTemplate,使用时需要写很多类型转换代码,用起来不切实际需求）

/**
 * redis配置类
 *
 * @author : ywb
 * @createdDate : 2019/12/31
 * @updatedDate
 */
@Configuration
public class RedisConfig {

    /**
     * 自定义 redisTemplate<String, Object>
     *
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        // 不转换值为 null 的对象
        // om.setSerializationInclusion(JsonInclude.Include.NON_NULL);

        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key 采用 string 的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // value 采用 jackson 的序列化方式
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash 的 key 采用 string 的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // hash 的 value 采用 jackson 的序列化方式
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

5.拦截器使用实例（拦截请求时，获取redis中的token信息，对redis中指定键对应的数据设置失效时间）

/**
 * 请求拦截器
 * @author : ywb
 * @createdDate : 2019/12/31
 * @updatedDate
 */
@Component
public class RequestInterceptor implements HandlerInterceptor {

    private static Log LOGGER = LogFactory.getLog(RequestInterceptor.class);

    @Autowired
    private RedisUtils redisUtils;

    /**
     * 请求之前执行
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //获取token
        String token = request.getHeader("token");
        DataCheck.isTrue(StringUtils.isBlank(token), ResultMessage.NO_TOKEN.getMsg());
//        String timestamp = request.getHeader("timestamp");
//        //获取生成的随机数
//        String random = request.getHeader("random");
//        //获取加密后的签名信息
//        String sign = request.getHeader("sign");
//        //组合token+timestamp+random
////        String pwd = token.concat(timestamp).concat(random);
//        //SHA-256哈希加密算法
//        String pwd = token;
//        MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
//        byte[] hash = messageDigest.digest(pwd.getBytes("UTF-8"));
//        //通过SHA-256哈希加密算法生成签名信息
//        String newSign = Hex.encodeHexString(hash);
        //查询redis存储的用户信息
        String redisUser = Constant.REDIS_USERID.replace("@uuid", token);
        if (!StringUtils.isBlank(redisUser) && redisUtils.exists(redisUser)) {
            //更新登录有效时间(续命)
            redisUtils.expire(redisUser, Constant.REDIS_USERID_TIMEOUT);
            return true;
        } else {
            throw new DataValidationException(ResultMessage.REQUEST_ERROR.getMsg());
        }
    }

    /**
     * 请求之后生成视图之前执行
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    /**
     * 最后执行，一般用于释放资源
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

6.编写比较完整的redis工具类RedisUtils

/**
 * Redis工具类<br>
 * <b>使用方法：</b>直接在类中使用@Autowired方法注入即可
 * @author : ywb
 * @createdDate : 2019/12/31
 * @updatedDate
 */
@Slf4j
@Component
public final class RedisUtils {

    /**
     * 从 spring 容器中注入自定义的 redisTemplate
     */
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 对 redis 中指定键对应的数据设置失效时间
     *
     * @param key  键
     * @param time 时间（秒），time要大于0
     * @return
     */
    public boolean expire(String key, long time) {
        boolean result = false;

        try {
            if (StringUtils.isNotBlank(key) && time > 0) {
                result = this.redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
        }

        return result;
    }

    /**
     * 从 redis 中根据指定的 key 获取已设置的过期时间
     *
     * @param key 键，不能为null
     * @return 时间（秒），返回0代表为永久有效
     */
    public long getExpire(String key) {
        long time = 0L;

        try {
            if (StringUtils.isNotBlank(key)) {
                time = this.redisTemplate.getExpire(key, TimeUnit.SECONDS);
            }
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
        }
        return time;
    }

    /**
     * 判断 redis 中是否存在指定的 key
     *
     * @param key 键，不能为null
     * @return true表示存在，false表示不存在
     */
    public boolean exists(String key) {
        boolean result = false;

        try {
            if (StringUtils.isNotBlank(key)) {
                result = this.redisTemplate.hasKey(key);
            }
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
        }
        return result;
    }

    /**
     * 从 redis 中移除指定 key 对应的数据
     *
     * @param keys 可以传一个值或多个
     */
    @SuppressWarnings("unchecked")
    public long remove(String... keys) {
        long count = 0L;

        if (keys != null && keys.length > 0) {
            if (keys.length == 1) {
                boolean result = this.redisTemplate.delete(keys[0]);

                if (result) {
                    count = keys.length;
                }
            } else {
                count = this.redisTemplate.delete(CollectionUtils.arrayToList(keys));
            }
        }
        return count;
    }

    // ============================ String =============================
    /**
     * 从 redis 中获取指定 key 对应的 string 数据
     *
     * @param key 键，不能为null
     * @return key 对应的字符串数据
     */
    public <T> T get(String key) {
        T t = null;

        try {
            if (StringUtils.isNotBlank(key)) {
                t = (T) this.redisTemplate.opsForValue().get(key);
            }
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
        }
        return t;
    }

    /**
     * 从 redis 中获取指定 key 对应的 string 数据，并转换为 T 类型
     *
     * @param key   键，不能为null
     * @param clazz 类型，从 redis 获取后的对象直接转换为 T 类型
     * @return key 对应的数据
     */
    public <T> T get(String key, Class<T> clazz) {
        T t = null;

        try {
            if (StringUtils.isNotBlank(key)) {
                String str = (String) this.redisTemplate.opsForValue().get(key);

                t = this.stringToBean(str, clazz);
            }
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return null;
        }

        return t;
    }

    /**
     * 判断 redis 中指定 key 的数据对应偏移位置的 bit 位是否为 1
     *
     * @param key    键，不能为null
     * @param offset 偏移位置
     * @return true表示存在，false表示不存在
     */
    public boolean getBit(String key, long offset) {
        boolean result = false;

        try {
            if (StringUtils.isNotBlank(key)) {
                result = this.redisTemplate.opsForValue().getBit(key, offset);
            }
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
        }

        return result;
    }

    /**
     * 将指定的 key, value 放到 redis 中
     *
     * @param key   键，不能为null
     * @param value 值，不能为null
     * @return true表示成功，false表示失败
     */
    public <T> boolean set(String key, T value) {
        boolean result = false;

        try {
            if (StringUtils.isNotBlank(key)) {
                this.redisTemplate.opsForValue().set(key, value);

                result = true;
            }
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
        }

        return result;
    }

    /**
     * 将指定的 key, value 放到 redis 中，并设置过期时间
     *
     * @param key   键，不能为null
     * @param value 值，不能为null
     * @param time  时间（秒），time要大于0，如果time小于等于0，将设置无限期
     * @return true表示成功，false表示失败
     */
    public <T> boolean set(String key, T value, long time) {
        try {
            if (time > 0) {
                this.redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                this.set(key, value);
            }
            return true;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return false;
        }
    }

    /**
     * 将 redis 中指定 key 对应数据的偏移位置的 bit 位设置为 0/1
     *
     * @param key    键，不能为null
     * @param offset 偏移位置
     * @param flag   true表示设置为1，false表示设置为0
     * @return true表示成功，false表示失败
     */
    public boolean setBit(String key, long offset, boolean flag) {
        boolean result = false;

        try {
            if (StringUtils.isNotBlank(key)) {
                this.redisTemplate.opsForValue().setBit(key, offset, flag);

                result = true;
            }
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
        }

        return result;
    }

    /**
     * 对 redis 中指定 key 的数据递增，并返回递增后的值
     *
     * @param key   键，不能为null
     * @param delta 要增加几（大于0）
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0。");
        }

        return this.redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 对 redis 中指定 key 的数据递减，并返回递减后的值
     *
     * @param key   键，不能为null
     * @param delta 要减少几（大于0）
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0。");
        }

        return this.redisTemplate.opsForValue().decrement(key, delta);
    }

    // ================================ hashmap=================================

    /**
     * 判断 redis 中指定 key 对应的 hash 表中是否有 hashKey
     *
     * @param key     键，不能为null
     * @param hashKey hash表中的键，不能为null
     * @return true表示存在，false表示不存在
     */
    public boolean hexists(String key, String hashKey) {
        return this.redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
     * 从 redis 中获取指定 key 对应的 hash 表中的指定 hashKey 所对应的值
     *
     * @param key     键，不能为null
     * @param hashKey hash表中的键，不能为null
     * @return 值
     */
    @SuppressWarnings("unchecked")
    public <T> T hget(String key, String hashKey) {
        return (T) this.redisTemplate.opsForHash().get(key, hashKey);
    }

    /**
     * 向 redis 中指定 key 对应的 hash 表（如果 hash 表不存在则自动创建）中放入 hashKey,value 数据
     *
     * @param key     键，不能为null
     * @param hashKey hash表中的键，不能为null
     * @param value   值，不能为null
     * @return true表示成功，false表示失败
     */
    public <T> boolean hset(String key, String hashKey, T value) {
        try {
            this.redisTemplate.opsForHash().put(key, hashKey, value);
            return true;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return false;
        }
    }

    /**
     * 向 redis 中指定 key 对应的 hash 表（如果 hash 表不存在则自动创建）中放入 hashKey,value 数据，并设置过期时间
     *
     * @param key     键，不能为null
     * @param hashKey hash表中的键，不能为null
     * @param value   值，不能为null
     * @param time    过期时间（秒），注意:如果已存在的hash表有时间，这里将会替换原有的时间
     * @return true表示成功，false表示失败
     */
    public <T> boolean hset(String key, String hashKey, T value, long time) {
        try {
            this.redisTemplate.opsForHash().put(key, hashKey, value);
            if (time > 0) {
                this.expire(key, time);
            }
            return true;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return false;
        }
    }

    /**
     * 删除 redis 中指定 key 对应的 hash 表中等于 hashKeys 的数据
     *
     * @param key      键，不能为null
     * @param hashKeys hash表中的键，可以使多个，不能为null
     */
    public <T> void hdel(String key, T... hashKeys) {
        this.redisTemplate.opsForHash().delete(key, hashKeys);
    }

    /**
     * 从 redis 中获取指定 key 对应的 hash 表，并返回相应的 map 对象
     *
     * @param key 键，不能为null
     * @return map对象，包含所有的键值对
     */
    public Map<?, ?> hmget(String key) {
        return this.redisTemplate.opsForHash().entries(key);
    }

    /**
     * 向 redis 中放入指定 key，并设置对应的数据类型为 map
     *
     * @param key 键，不能为null
     * @param map 多个键值对应的map，不能为null
     * @return true表示成功，false表示失败
     */
    public boolean hmset(String key, Map<String, ?> map) {
        try {
            this.redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return false;
        }
    }

    /**
     * 向 redis 中放入指定 key，并设置对应的数据类型为 map 以及过期时间
     *
     * @param key  键，不能为null
     * @param map  对应多个键值，不能为null
     * @param time 时间（秒），time要大于0，如果time小于等于0，将设置无限期
     * @return true表示成功，false表示失败
     */
    public boolean hmset(String key, Map<String, ?> map, long time) {
        try {
            this.redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                this.expire(key, time);
            }
            return true;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return false;
        }
    }

    /**
     * 对 redis 中指定 key 对应的 hash 表（如果 hash 表不存在则自动创建）递增，并返回新增后的值
     *
     * @param key   键，不能为null
     * @param item  项，不能为null
     * @param delta 要增加几（大于0）
     * @return 新增后的值
     */
    public double hincr(String key, String item, double delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0。");
        }

        return this.redisTemplate.opsForHash().increment(key, item, delta);
    }

    /**
     * 对 redis 中指定 key 对应的 hash 表（如果 hash 表不存在则自动创建）递增，并返回新增后的值
     *
     * @param key   键，不能为null
     * @param item  项，不能为null
     * @param delta 要减少几（大于0）
     * @return
     */
    public double hdecr(String key, String item, double delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0。");
        }

        return this.redisTemplate.opsForHash().increment(key, item, -delta);
    }

    /**
     * 从 redis 中移除指定 key 对应 hash 表中键为 values 的数据
     *
     * @param key    键，不能为null
     * @param values 值，不能为null
     * @return 移除的个数
     */
    public <T> long hremove(String key, T... values) {
        try {
            Long count = this.redisTemplate.opsForHash().delete(key, values);
            return count;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return 0;
        }
    }

    // ============================set=============================

    /**
     * 判断 redis 中是否存在指定 key 对应的 set 对象
     *
     * @param key   键，不能为null
     * @param value 值，不能为null
     * @return true表示存在，false表示不存在
     */
    public <T> boolean sexists(String key, T value) {
        try {
            return this.redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return false;
        }
    }

    /**
     * 从 redis 中根据指定 key 对应的值，并返回 set 对象
     *
     * @param key 键，不能为null
     * @return
     */
    public Set<?> sget(String key) {
        try {
            return this.redisTemplate.opsForSet().members(key);
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return null;
        }
    }

    /**
     * 向 redis 中放入指定 key 和数据，并设置其数据类型为 set
     *
     * @param key    键，不能为null
     * @param values 值，不能为null
     * @return 成功个数
     */
    public <T> long sset(String key, T... values) {
        try {
            return this.redisTemplate.opsForSet().add(key, values);
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return 0;
        }
    }

    /**
     * 向 redis 中放入指定 key 和数据，并设置其数据类型为 set 以及过期时间
     *
     * @param key    键，不能为null
     * @param time   过期时间（秒），注意:如果已存在的hash表有时间，这里将会替换原有的时间
     * @param values 值，不能为null
     * @return 成功个数
     */
    public <T> long sset(String key, long time, T... values) {
        try {
            Long count = this.redisTemplate.opsForSet().add(key, values);
            if (time > 0) {
                expire(key, time);
            }
            return count;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return 0;
        }
    }

    /**
     * 获取 redis 中指定 key 对应 set 的大小
     *
     * @param key 键，不能为null
     * @return
     */
    public long ssize(String key) {
        try {
            return this.redisTemplate.opsForSet().size(key);
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return 0;
        }
    }

    /**
     * 从 redis 中移除指定 key 对应 set 中键为 values 的数据
     *
     * @param key    键，不能为null
     * @param values 值，不能为null
     * @return 移除的个数
     */
    public <T> long sremove(String key, T... values) {
        try {
            Long count = this.redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return 0;
        }
    }

    // =============================== list =================================

    /**
     * 从 redis 中获取指定 key 对应 list 的大小
     *
     * @param key 键，不能为null
     * @return
     */
    public long lsize(String key) {
        try {
            return this.redisTemplate.opsForList().size(key);
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return 0;
        }
    }

    /**
     * 从 redis 中获取指定 key 对应 list 中 index 位置的值
     *
     * @param key   键，不能为null
     * @param index 当index>=0时，0为表头，1为第二个元素，依次类推；当index<0时，-1为表尾，-2为倒数第二个元素，依次类推
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> T lindex(String key, long index) {
        try {
            return (T) this.redisTemplate.opsForList().index(key, index);
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return null;
        }
    }

    /**
     * 从 redis 中获取指定 key 对应 list 指定范围的值（start~end设置为0~-1将返回所有值）
     *
     * @param key   键，不能为null
     * @param start 起始位置，0表示起始位置
     * @param end   结束位置，-1表示结束位置
     * @return
     */
    public List<?> lget(String key, long start, long end) {
        try {
            return this.redisTemplate.opsForList().range(key, start, end);
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return null;
        }
    }

    /**
     * 向 redis 中放入指定 key，并设置数组类型为 list，将 value 加入到 list 尾部
     *
     * @param key   键，不能为null
     * @param value 值，不能为null
     * @return
     */
    public <T> boolean lset(String key, T value) {
        try {
            this.redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return false;
        }
    }

    /**
     * 向 redis 中放入指定 key，并设置数组类型为 list，将 value 加入到 list 尾部，同时设置过期时间
     *
     * @param key   键，不能为null
     * @param value 值，不能为null
     * @param time  时间（秒），time要大于0，如果time小于等于0，将设置无限期
     * @return
     */
    public <T> boolean lset(String key, T value, long time) {
        try {
            this.redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                this.expire(key, time);
            }
            return true;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return false;
        }
    }

    /**
     * 向 redis 中放入指定 key，并设置数组类型为 list，并以 value 填入 list
     *
     * @param key   键，不能为null
     * @param value 值，不能为null
     * @return
     */
    public boolean lset(String key, List value) {
        try {
            this.redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return false;
        }
    }

    /**
     * 向 redis 中放入指定 key，并设置数组类型为 list，并以 value 填入 list，同时设置过期时间
     *
     * @param key   键，不能为null
     * @param value 值，不能为null
     * @param time  时间（秒），time要大于0，如果time小于等于0，将设置无限期
     * @return
     */
    public boolean lset(String key, List value, long time) {
        try {
            this.redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                this.expire(key, time);
            }
            return true;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return false;
        }
    }

    /**
     * 将 redis 中指定 key 对应的 list 数据中指定 index 位置的数据更新为 value
     *
     * @param key   键，不能为null
     * @param index 索引
     * @param value 值，不能为null
     * @return
     */
    public <T> boolean lupdate(String key, long index, T value) {
        try {
            this.redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return false;
        }
    }

    /**
     * 从 redis 中指定 key 对应的 list 中移除 n 个值为 value 的数据
     *
     * @param key   键，不能为null
     * @param count 移除多少个
     * @param value 值，不能为null
     * @return 移除的个数
     */
    public <T> long lremove(String key, long count, T value) {
        try {
            Long remove = this.redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
            return 0;
        }
    }

    /**
     * 根据指定的类型转换字符串/JSON字符串为相应的对象
     *
     * @param value 字符串/JSON字符串
     * @param clazz 类型
     * @param <T>   任意类型
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> T stringToBean(String value, Class<T> clazz) {
        if (value == null || value.length() <= 0 || clazz == null) {
            return null;
        }

        if (clazz == byte.class || clazz == Byte.class) {
            return (T) Byte.valueOf(value);
        } else if (clazz == int.class || clazz == Integer.class) {
            return (T) Integer.valueOf(value);
        } else if (clazz == long.class || clazz == Long.class) {
            return (T) Long.valueOf(value);
        } else if (clazz == double.class || clazz == Double.class) {
            return (T) Double.valueOf(value);
        } else if (clazz == float.class || clazz == Float.class) {
            return (T) Float.valueOf(value);
        } else if (clazz == String.class) {
            return (T) value;
        } else {
            return JSONUtil.toBean(value, clazz);
        }
    }

    /**
     * 将 bean 转换为字符串/JSON字符串
     *
     * @param value 任意类型对象
     * @return 字符串/JSON字符串
     */
    public <T> String beanToString(T value) {
        if (value == null) {
            return null;
        }

        Class<?> clazz = value.getClass();
        if (clazz == byte.class || clazz == Byte.class) {
            return "" + value;
        } else if (clazz == int.class || clazz == Integer.class) {
            return "" + value;
        } else if (clazz == long.class || clazz == Long.class) {
            return "" + value;
        } else if (clazz == double.class || clazz == Double.class) {
            return "" + value;
        } else if (clazz == float.class || clazz == Float.class) {
            return "" + value;
        } else if (clazz == String.class) {
            return (String) value;
        } else {
            return JSONUtil.toJsonStr(value);
        }
    }