美文网首页
springboot redis整合笔记

springboot redis整合笔记

作者: 我是电饭煲 | 来源:发表于2020-03-30 19:43 被阅读0次

    引入

    <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
            </dependency>
    

    application.yml配置

    spring:
      redis:
        password:
        database: 0
        port: 6379
        lettuce:
          pool:
            max-active: 100
            max-idle: 10
            min-idle: 2
            max-wait: 10000
        host: localhost
        timeout: 10000
    

    redis配置

    /**
     * Redis 配置类
     *
     * @author yuanfeng
     * @version 1.0
     * @date 2019-06-09 下午3:35
     */
    @Configuration
    public class RedisConfig {
    
        /**
         * 设置序列化机制
         *
         * @param template
         */
        private void setSerializer(RedisTemplate template) {
            FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer(Object.class);
            // key采用String的序列化方式
            template.setKeySerializer(new StringRedisSerializer());
            // hash的key采用String的序列化方式
            template.setHashKeySerializer(new StringRedisSerializer());
            // value序列化方式采用fastjson
            template.setValueSerializer(fastJsonRedisSerializer);
            // hash的value序列化方式采用fastjson
            template.setHashValueSerializer(fastJsonRedisSerializer);
        }
    
        /**
         * StringRedisTemplate
         *
         * @param redisConnectionFactory
         * @return
         */
        @Bean
        @ConditionalOnMissingBean(StringRedisTemplate.class)
        public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
            StringRedisTemplate template = new StringRedisTemplate();
            template.setConnectionFactory(redisConnectionFactory);
            setSerializer(template);
            return template;
        }
    
        /**
         * 
         * @param factory
         * @return
         */
        @Bean("redisTemplate")
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
            RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
            template.setConnectionFactory(factory);
            setSerializer(template);
            template.afterPropertiesSet();
            return template;
        }
    }
    

    定义序列化方式

    /**
     * FastJson的Redis序列化器
     *
     * @author rqh
     * @version 1.0
     * @date 2019-07-06
     */
    public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
    
        private Class<T> clazz;
    
        private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
    
        public FastJsonRedisSerializer(Class<T> clazz) {
            super();
            this.clazz = clazz;
            // 兼容其他组件的FastJson序列化机制
            ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        }
    
        @Override
        public byte[] serialize(T t) throws SerializationException {
            if (null == t) {
                return new byte[0];
            }
            return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
        }
    
        @Override
        public T deserialize(byte[] bytes) throws SerializationException {
            if (null == bytes || bytes.length <= 0) {
                return null;
            }
            String result = new String(bytes, DEFAULT_CHARSET);
            return (T) JSON.parseObject(result, clazz);
        }
    }
    

    缓存工具接口

    /**
     * 缓存工具接口
     *
     * @author yuanfeng
     * @version 1.0
     * @date 2019-07-07
     */
     interface CacheUtil {
    
        /**
         * 判断key是否存在
         *
         * @param key 键
         * @return true 存在 false 不存在
         */
          boolean hasKey(String key);
    
        /**
         * 删除缓存
         *
         * @param key 可以传一个值或多个
         */
          void del(String... key);
    
        /**
         * 普通缓存获取
         *
         * @param key   键
         * @param clazz 类型
         * @return 值
         */
          <T> T get(String key, Class<T> clazz);
    
        /**
         * 普通缓存获取
         *
         * @param key 键
         * @return 值
         */
          <T> T get(String key);
    
        /**
         * 普通缓存放入
         *
         * @param key   键
         * @param value 值
         * @return true 成功 false 失败
         * @Param expireSecond 过期时间
         */
          boolean set(String key, long expireSecond, Object value);
    
    
        /**
         * 持久化普通缓存放入
         *
         * @param key   键
         * @param value 值
         * @return true 成功 false 失败
         */
          boolean setPersist(String key, Object value);
    
        /**
         * 递增
         *
         * @param key   键
         * @param delta 要增加几(大于0)
         * @return
         */
          long incr(String key, long delta);
    
        /**
         * 递减
         *
         * @param key   键
         * @param delta 要减少几(小于0)
         * @return
         */
          long decr(String key, long delta);
    
        /**
         * Hash Get
         *
         * @param key  键
         * @param field 项
         * @return 值
         */
          Object hget(String key, Object field);
    
        /**
         * Hash Get
         *
         * @param key   键
         * @param item  项
         * @param clazz 类型
         * @return 值
         */
         <T> T hget(String key, String item, Class<T> clazz);
    
        /**
         * 获取Hash对应的所有键值
         *
         * @param key 键
         * @return 对应的多个键值
         */
          Map<Object, Object> hmget(String key);
    
        /**
         *  HSET key field value
         * 将哈希表 key 中的字段 field 的值设为 value 。
         *
         * @param key 键
         * @param field 键
         * @param value 值
         * @return true 成功 false 失败
         */
         boolean hmset(String key, Object field, Object value, long expireSecond);
    
        /**
         * Hash Set
         *
         * @param key 键
         * @param map 对应多个键值
         * @return true 成功 false 失败
         */
          boolean hmset(String key, long expireSecond, Map<Object, Object> map);
    
        /**
         * 向一张Hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @return true 成功 false 失败
         */
          boolean hset(String key, String item, Object value);
    
          boolean hset(String key, long expireSecond, String item, Object value);
    
        /**
         * 删除Hash表中的值
         *
         * @param key  键
         * @param item 项
         */
          void hdel(String key, Object... item);
    
        /**
         * 判断Hash表中是否有该项的值
         *
         * @param key  键
         * @param item 项
         * @return true 存在 false 不存在
         */
          boolean hHasKey(String key, String item);
    
        /**
         * Hash递增 如果不存在,就会创建一个并把新增后的值返回
         *
         * @param key  键
         * @param item 项
         * @param by   要增加几(大于0)
         * @return
         */
          double hincr(String key, String item, double by);
    
        /**
         * Hash递减
         *
         * @param key  键
         * @param item 项
         * @param by   要减少几(小于0)
         * @return
         */
          double hdecr(String key, String item, double by);
    
        /**
         * 根据key获取Set中的所有值
         *
         * @param key 键
         * @return
         */
          Set<Object> sGet(String key);
    
        /**
         * 根据key获取Set中的所有值
         *
         * @param key   键
         * @param clazz 类型
         * @return
         */
          <T> Set<T> sGet(String key, Class<T> clazz);
    
        /**
         * 根据value从一个Set中查询,是否存在
         *
         * @param key   键
         * @param value 值
         * @return true 存在 false 不存在
         */
          boolean sHasKey(String key, Object value);
    
        /**
         * 将数据放入Set缓存
         *
         * @param key    键
         * @param values 值
         * @return 成功个数
         */
          long sSet(String key, Object... values);
    
          long sSet(String key, long expireSecond, Object... values);
    
        /**
         * 获取Set缓存的长度
         *
         * @param key 键
         * @return
         */
          long sGetSetSize(String key);
    
        /**
         * 移除值为value的key
         *
         * @param key    键
         * @param values 值
         * @return 移除的个数
         */
          long setRemove(String key, Object... values);
    
        /**
         * 获取List缓存的内容
         *
         * @param key   键
         * @param start 开始
         * @param end   结束 0 到 -1代表所有值
         * @return
         */
          List<Object> lGet(String key, long start, long end);
    
        /**
         * 获取List缓存的内容
         *
         * @param key   键
         * @param start 开始
         * @param end   结束 0 到 -1代表所有值
         * @param clazz 类型
         * @return
         */
          <T> List<T> lGet(String key, long start, long end, Class<T> clazz);
    
        /**
         * 获取List缓存的长度
         *
         * @param key 键
         * @return
         */
          long lGetListSize(String key);
    
        /**
         * 通过索引获取List中的值
         *
         * @param key   键
         * @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
         * @return
         */
          Object lGetIndex(String key, long index);
    
        /**
         * 通过索引获取List中的值
         *
         * @param key   键
         * @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
         * @param clazz 类型
         * @return
         */
          <T> List<T> lGetIndex(String key, long index, Class<T> clazz);
    
        /**
         * 将List放入缓存
         *
         * @param key   键
         * @param value 值
         * @return
         */
          boolean lSet(String key, long expireSecond, Object value);
    
        /**
         * 将List放入缓存
         *
         * @param key   键
         * @param value 值
         * @return
         */
          boolean lSet(String key, long expireSecond, List<Object> value);
    
        /**
         * 根据索引修改List中的某条数据
         *
         * @param index 索引
         * @param value 值
         * @return
         */
          boolean lUpdateIndex(String key, long index, Object value);
    
        /**
         * 移除N个值为value的key
         *
         * @param key   键
         * @param count 移除多少个
         * @param value 值
         * @return 移除的个数
         */
          long lRemove(String key, long count, Object value);
    
    }
    
    

    缓存工具实现类

    /**
     * Redis 工具类
     *
     * @author yuanfneg
     * @version 1.0
     * @date 2019-06-09 下午3:42
     */
    @Slf4j
    public class RedisCacheUtil implements CacheUtil {
    
        /**
         * 单例对象
         */
        private static RedisCacheUtil cacheUtil;
    
        /**
         * RedisTemplate
         */
        private static RedisTemplate<String, Object> redisTemplate;
    
        /**
         * 禁止实例化
         */
        private RedisCacheUtil() {
    
        }
    
        /**
         * 获取单例对象,强烈建议通过CacheHelper统一获取缓存工具类
         *
         * @return
         */
        public static RedisCacheUtil getInstance() {
            if (cacheUtil == null) {
                synchronized (RedisCacheUtil.class) {
                    if (cacheUtil == null) {
                        cacheUtil = new RedisCacheUtil();
                    }
                }
            }
            return cacheUtil;
        }
    
        static {
            redisTemplate = SpringContextUtil.getBean("redisTemplate", RedisTemplate.class);
        }
    
        /**
         * 指定缓存失效时间
         *
         * @param allKey  键(包含前缀与Key)
         * @param seconds 缓存失效时间(单位秒),0代表永久有效
         * @return
         */
        public boolean expire(String allKey, long seconds) {
            try {
                if (seconds > 0) {
                    redisTemplate.expire(allKey, seconds, TimeUnit.SECONDS);
                }
                return true;
            } catch (Exception e) {
                log.error(e.getMessage());
                return false;
            }
        }
    
        /**
         * 获取过期时间
         *
         * @param key 键(包含前缀与Key)
         * @return
         */
        public long getExpire(String key) {
            return redisTemplate.getExpire(key);
        }
    
        /**
         * 判断key是否存在
         *
         * @param key 键
         * @return true 存在 false 不存在
         */
        @Override
        public boolean hasKey(String key) {
            try {
                return redisTemplate.hasKey(key);
            } catch (Exception e) {
                log.error(e.getMessage());
                return false;
            }
        }
    
        /**
         * 删除缓存
         *
         * @param key 可以传一个值或多个
         */
        @Override
        public void del(String... key) {
            if (key != null && key.length > 0) {
                if (key.length == 1) {
                    redisTemplate.delete(key[0]);
                } else {
                    redisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }
    
        /**
         * 普通缓存获取
         *
         * @param key   键
         * @param clazz 类型
         * @return 值
         */
        @Override
        public <T> T get(String key, Class<T> clazz) {
            return (T) redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存获取
         *
         * @param key 键
         * @return 值
         */
        @Override
        public <T> T get(String key) {
            return (T) redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存放入
         *
         * @param expireSecond
         * @param key          键
         * @param value        值
         * @return true 成功 false 失败
         */
        @Override
        public boolean set(String key, long expireSecond, Object value) {
            try {
                redisTemplate.opsForValue().set(key, value, expireSecond, TimeUnit.SECONDS);
                return true;
            } catch (Exception e) {
                log.error(e.getMessage());
                return false;
            }
        }
    
        /**
         * 持久化普通缓存放入
         *
         * @param key   键
         * @param value 值
         * @return true 成功 false 失败
         */
        @Override
        public boolean setPersist(String key, Object value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                redisTemplate.persist(key);
                return true;
            } catch (Exception e) {
                log.error(e.getMessage());
                return false;
            }
        }
    
        /**
         * 递增
         *
         * @param key   键
         * @param delta 要增加几(大于0)
         * @return
         */
        @Override
        public long incr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递增因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, delta);
        }
    
        /**
         * 递减
         *
         * @param key   键
         * @param delta 要减少几(小于0)
         * @return
         */
        @Override
        public long decr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, -delta);
        }
    
        /**
         * Hash Get
         *
         * @param key  键
         * @param field 项
         * @return 值
         */
        @Override
        public Object hget(String key, Object field) {
            return redisTemplate.opsForHash().get(key, field);
        }
    
    
        /**
         * Hash Get
         *
         * @param key   键
         * @param item  项
         * @param clazz 类型
         * @return 值
         */
        @Override
        public <T> T hget(String key, String item, Class<T> clazz) {
            return (T) redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 获取Hash对应的所有键值
         *
         * @param key 键
         * @return 对应的多个键值
         */
        @Override
        public Map<Object, Object> hmget(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         *  HSET key field value
         * 将哈希表 key 中的字段 field 的值设为 value 。
         *
         * @param key 键
         * @param field 键
         * @param value 值
         * @return true 成功 false 失败
         */
        @Override
        public boolean hmset(String key, Object field, Object value, long expireSecond) {
            try {
                redisTemplate.opsForHash().put(key, field, value);
                expire(key, expireSecond);
                return true;
            } catch (Exception e) {
                log.error(e.getMessage());
                return false;
            }
        }
    
        /**
         * HMSET key field1 value1 [field2 value2 ]
         * 同时将多个 field-value (域-值)对设置到哈希表 key 中。
         *
         * @param key 键
         * @param map 对应多个键值
         * @return true 成功 false 失败
         */
        @Override
        public boolean hmset(String key, long expireSecond, Map<Object, Object> map) {
            try {
                String fullKey = key;
                redisTemplate.opsForHash().putAll(fullKey, map);
                expire(fullKey, expireSecond);
                return true;
            } catch (Exception e) {
                log.error(e.getMessage());
                return false;
            }
        }
    
        /**
         * 向一张Hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @return true 成功 false 失败
         */
        @Override
        public boolean hset(String key, long expireSecond, String item, Object value) {
            try {
                String fullKey = key;
                redisTemplate.opsForHash().put(fullKey, item, value);
                expire(fullKey, expireSecond);
                return true;
            } catch (Exception e) {
                log.error(e.getMessage());
                return false;
            }
        }
    
        @Override
        public boolean hset(String key, String item, Object value) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            } catch (Exception e) {
                log.error(e.getMessage());
                return false;
            }
        }
    
        /**
         * 删除Hash表中的值
         *
         * @param key  键
         * @param item 项
         */
        @Override
        public void hdel(String key, Object... item) {
            redisTemplate.opsForHash().delete(key, item);
        }
    
        /**
         * 判断Hash表中是否有该项的值
         *
         * @param key  键
         * @param item 项
         * @return true 存在 false 不存在
         */
        @Override
        public boolean hHasKey(String key, String item) {
            return redisTemplate.opsForHash().hasKey(key, item);
        }
    
        /**
         * Hash递增 如果不存在,就会创建一个并把新增后的值返回
         *
         * @param key  键
         * @param item 项
         * @param by   要增加几(大于0)
         * @return
         */
        @Override
        public double hincr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    
        /**
         * Hash递减
         *
         * @param key  键
         * @param item 项
         * @param by   要减少几(小于0)
         * @return
         */
        @Override
        public double hdecr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, -by);
        }
    
        /**
         * 根据key获取Set中的所有值
         *
         * @param key 键
         * @return
         */
        @Override
        public Set<Object> sGet(String key) {
            try {
                return redisTemplate.opsForSet().members(key);
            } catch (Exception e) {
                log.error(e.getMessage());
                return null;
            }
        }
    
        /**
         * 根据key获取Set中的所有值
         *
         * @param key   键
         * @param clazz 类型
         * @return
         */
        @Override
        public <T> Set<T> sGet(String key, Class<T> clazz) {
            try {
                return (Set<T>) redisTemplate.opsForSet().members(key);
            } catch (Exception e) {
                log.error(e.getMessage());
                return null;
            }
        }
    
        /**
         * 根据value从一个Set中查询,是否存在
         *
         * @param key   键
         * @param value 值
         * @return true 存在 false 不存在
         */
        @Override
        public boolean sHasKey(String key, Object value) {
            try {
                return redisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) {
                log.error(e.getMessage());
                return false;
            }
        }
    
        /**
         * 将数据放入Set缓存
         *
         * @param key    键
         * @param values 值
         * @return 成功个数
         */
        @Override
        public long sSet(String key, long expireSecond, Object... values) {
            try {
                long count = redisTemplate.opsForSet().add(key, values);
                expire(key, expireSecond);
                return count;
            } catch (Exception e) {
                log.error(e.getMessage());
                return 0;
            }
        }
    
        @Override
        public long sSet(String key, Object... values) {
            try {
                long count = redisTemplate.opsForSet().add(key, values);
                return count;
            } catch (Exception e) {
                log.error(e.getMessage());
                return 0;
            }
        }
    
        /**
         * 获取Set缓存的长度
         *
         * @param key 键
         * @return
         */
        @Override
        public long sGetSetSize(String key) {
            try {
                return redisTemplate.opsForSet().size(key);
            } catch (Exception e) {
                log.error(e.getMessage());
                return 0;
            }
        }
    
        /**
         * 移除值为value的key
         *
         * @param key    键
         * @param values 值
         * @return 移除的个数
         */
        @Override
        public long setRemove(String key, Object... values) {
            try {
                return redisTemplate.opsForSet().remove(key, values);
            } catch (Exception e) {
                log.error(e.getMessage());
                return 0;
            }
        }
    
        /**
         * 获取List缓存的内容
         *
         * @param key   键
         * @param start 开始
         * @param end   结束 0 到 -1代表所有值
         * @return
         */
        @Override
        public List<Object> lGet(String key, long start, long end) {
            try {
                return redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) {
                log.error(e.getMessage());
                return null;
            }
        }
    
        /**
         * 获取List缓存的内容
         *
         * @param key   键
         * @param start 开始
         * @param end   结束 0 到 -1代表所有值
         * @param clazz 类型
         * @return
         */
        @Override
        public <T> List<T> lGet(String key, long start, long end, Class<T> clazz) {
            try {
                return (List<T>) redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) {
                log.error(e.getMessage());
                return null;
            }
        }
    
        /**
         * 获取List缓存的长度
         *
         * @param key 键
         * @return
         */
        @Override
        public long lGetListSize(String key) {
            try {
                return redisTemplate.opsForList().size(key);
            } catch (Exception e) {
                log.error(e.getMessage());
                return 0;
            }
        }
    
        /**
         * 通过索引获取List中的值
         *
         * @param key   键
         * @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
         * @return
         */
        @Override
        public Object lGetIndex(String key, long index) {
            try {
                return redisTemplate.opsForList().index(key, index);
            } catch (Exception e) {
                log.error(e.getMessage());
                return null;
            }
        }
    
        /**
         * 通过索引获取List中的值
         *
         * @param key   键
         * @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
         * @param clazz 类型
         * @return
         */
        @Override
        public <T> List<T> lGetIndex(String key, long index, Class<T> clazz) {
            try {
                return (List<T>) redisTemplate.opsForList().index(key, index);
            } catch (Exception e) {
                log.error(e.getMessage());
                return null;
            }
        }
    
        /**
         * 将List放入缓存
         *
         * @param key   键
         * @param value 值
         * @return
         */
        @Override
        public boolean lSet(String key, long expireSecond, Object value) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                expire(key, expireSecond);
                return true;
            } catch (Exception e) {
                log.error(e.getMessage());
                return false;
            }
        }
    
        /**
         * 将List放入缓存
         *
         * @param key   键
         * @param value 值
         * @return
         */
        @Override
        public boolean lSet(String key, long expireSecond, List<Object> value) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                expire(key, expireSecond);
                return true;
            } catch (Exception e) {
                log.error(e.getMessage());
                return false;
            }
        }
    
        /**
         * 根据索引修改List中的某条数据
         *
         * @param index 索引
         * @param value 值
         * @return
         */
        @Override
        public boolean lUpdateIndex(String key, long index, Object value) {
            try {
                redisTemplate.opsForList().set(key, index, value);
                return true;
            } catch (Exception e) {
                log.error(e.getMessage());
                return false;
            }
        }
    
        /**
         * 移除N个值为value的key
         *
         * @param key   键
         * @param count 移除多少个
         * @param value 值
         * @return 移除的个数
         */
        @Override
        public long lRemove(String key, long count, Object value) {
            try {
                return redisTemplate.opsForList().remove(key, count, value);
            } catch (Exception e) {
                log.error(e.getMessage());
                return 0;
            }
        }
    
        public DataType getType(String key) {
            return redisTemplate.type(key);
        }
    

    相关文章

      网友评论

          本文标题:springboot redis整合笔记

          本文链接:https://www.haomeiwen.com/subject/uoccgctx.html