spring cloud 配置 redis、定义redis工具类

Love The Way You Lie 2022-10-23 15:27 29阅读 0赞

## **一、引入redis工具依赖** ##

在build.gradle文件中的dependencies的对象中引入依赖

compile 'org.springframework.boot:spring-boot-starter-data-redis-reactive'

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzE2OTk4OTQ1_size_16_color_FFFFFF_t_70_pic_center]

## **二、application.xml配置redis** ##

spring
        redis:
            database:       #Redis数据库索引（默认为0）
            host:           #Redis服务器地址，请替换为自己的redis服务器地址
            port:           #Redis服务器连接端口
            password:       #Redis服务器连接密码，无密码时，省略password

## **三、定义redis服务接口** ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzE2OTk4OTQ1_size_16_color_FFFFFF_t_70_pic_center 1]

package com.pd.shop.redis;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    /** * redis接口类 * * @author */
    public interface IRedis { 
    
        /** * 设置缓存 * * @param key * @param value * @param validTime 秒 */
        void set(String key, String value, int validTime);
    
        /** * 设置有效期 * * @param key * @param validTime 秒 */
        void expire(String key, int validTime);
    
        /** * 剩余有效期，单位：秒 * * @param key * @return */
        Long getExpire(String key);
    
    
        /** * 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key ) * * @param key * @return */
        Boolean persist(String key);
    
        /** * 获取缓存对象 字符串 * * @param key * @return */
        String get(String key);
    
        /** * 通过key向指定的value值追加值 * * @param key * @param str * @return */
        Integer append(String key, String str);
    
        /** * 通过批量的key获取批量的value * * @param keys * @return */
        List<String> getList(List<String> keys);
    
    
        /** * 通过key获取value值的长度 * * @param key * @return */
        Long len(String key);
    
        /** * 删除 * * @param key */
        void del(String key);
    
        /** * hash * * @param key * @param field * @return */
        String hGet(String key, String field);
    
    
        /** * * @param key * @return */
        Map<String, String> hGetAll(String key);
    
    
        /** * * @param key * @param field * @param value */
        void hSet(String key, String field, String value);
    
        /** * * @param key * @param fields */
        void hDel(String key, List<String> fields);
    
        /** * @param key * @param hash */
        void hSet(String key, Map<String, String> hash);
    
        /** * 检查是否存在 * * @param key * @param field * @return */
        Boolean hasKey(String key, String field);
    
        /** * @param key * @param field * @param value * @return */
        Long hIncrByLong(String key, String field, Long value);
    
    
        /** * @param key * @param field * @param value * @return */
        Double hIncrByDouble(String key, String field, Double value);
    
        /** * @param key * @return */
        Integer hSize(String key);
    
        /** * 通过key向list头部添加字符串 * * @param key * @param value * @return */
        void lPush(String key, String value);
    
        /** * 通过key向list头部添加字符串 * * @param key * @param values * @return */
        void lPush(String key, List<String> values);
    
        /** * 通过key向list尾部添加字符串 * * @param key * @param value * @return */
        void lrPush(String key, String value);
    
        /** * 通过key向list尾部添加字符串 * * @param key * @param values * @return */
        void lrPush(String key, List<String> values);
    
    
        /** * 通过key设置list指定下标位置的value * * @param key * @param index * @param value * @return */
        void lSet(String key, Long index, String value);
    
        /** * 通过key从对应的list中删除指定的count个 和 value相同的元素 * * @param key * @param count * @param value * @return */
        void lRem(String key, long count, String value);
    
        /** * 通过key保留list中从strat下标开始到end下标结束的value值 * * @param key * @param start * @param end * @return */
        void lTrim(String key, long start, long end);
    
        /** * 通过key从list的头部删除一个value,并返回该value * * @param key * @return */
        String lPop(String key);
    
    
        /** * 通过key从list尾部删除一个value,并返回该元素 * * @param key * @return */
        String lrPop(String key);
    
    
        /** * 通过key获取list中指定下标位置的value * * @param key * @param index * @return */
        String lIndex(String key, Long index);
    
    
        /** * 通过key返回list的长度 * * @param key * @return */
        Integer lLen(String key);
    
        /** * 通过key获取list指定下标位置的value * * @param key * @param start * @param end * @return */
        List<String> lRange(String key, long start, long end);
    
        /** * 将列表 key 下标为 index 的元素的值设置为 value * * @param key * @param index * @param value * @return */
        void lSet(String key, Integer index, String value);
    
        /** * 通过key向指定的set中添加value * * @param key * @param values * @return */
        void sAdd(String key, List<String> values);
    
        /** * 通过key删除set中对应的value值 * * @param key * @param values * @return */
        void sRem(String key, List<String> values);
    
        /** * 通过key随机删除一个set中的value并返回该值 * * @param key * @return */
        String sPop(String key);
    
        /** * 通过key获取set中的差集 * * @param keys * @return */
        Set<String> sDiff(List<String> keys);
    
        /** * 通过key获取set中的差集并存入到另一个key中 * * @param keys * @param storeKey * @return */
        Long sDiffStore(List<String> keys, String storeKey);
    
        /** * 通过key获取指定set中的交集 * * @param keys * @return */
        Set<String> sInter(List<String> keys);
    
    
        /** * 通过key获取指定set中的交集 并将结果存入新的set中 * * @param keys * @param storeKey * @return */
        Long sInterStore(List<String> keys, String storeKey);
    
    
        /** * 通过key返回所有set的并集 * * @param keys * @return */
        Set<String> sUnion(List<String> keys);
    
        /** * 通过key返回所有set的并集,并存入到新的set中 * * @param keys * @param storeKey * @return */
        Long sUnionStore(List<String> keys, String storeKey);
    
    
        /** * 通过key获取set中value的个数 * * @param key * @return */
        Integer sSize(String key);
    
        /** * 通过key判断value是否是set中的元素 * * @param key * @param member * @return */
        Boolean sIsMember(String key, String member);
    
    
        /** * 通过key获取set中随机的value,不删除元素 * * @param key * @return */
        String sRandMember(String key);
    
        /** * 通过key获取set中所有的value * * @param key * @return */
        Set<String> sMembersAll(String key);
    
    }

## **四、实现redis服务接口** ##

package com.pd.shop.redis;
    
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.stereotype.Service;
    
    import java.util.*;
    import java.util.concurrent.TimeUnit;
    
    /** * redis服务 * * @author */
    @Service
    public class RedisService implements IRedis { 
    
    
        private final StringRedisTemplate redisTemplate;
    
        public RedisService(StringRedisTemplate redisTemplate) { 
            this.redisTemplate = redisTemplate;
        }
    
        @Override
        public void set(String key, String value, int validTime) { 
            redisTemplate.opsForValue().set(key, value, validTime, TimeUnit.SECONDS);
        }
    
        @Override
        public void expire(String key, int validTime) { 
            redisTemplate.expire(key, validTime, TimeUnit.SECONDS);
        }
    
        @Override
        public Long getExpire(String key) { 
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
        @Override
        public Boolean persist(String key) { 
            return redisTemplate.persist(key);
        }
    
    
        @Override
        public String get(String key) { 
            return redisTemplate.opsForValue().get(key);
        }
    
        @Override
        public Integer append(String key, String str) { 
            return redisTemplate.opsForValue().append(key, str);
        }
    
        @Override
        public List<String> getList(List<String> keys) { 
            return redisTemplate.opsForValue().multiGet(keys);
        }
    
        @Override
        public Long len(String key) { 
            return redisTemplate.opsForValue().size(key);
        }
    
    
        @Override
        public void del(String key) { 
            redisTemplate.delete(key);
        }
    
        @Override
        public String hGet(String key, String field) { 
            Object object = redisTemplate.opsForHash().get(key, field);
            if (object == null) { 
                return null;
            }
            return (String) object;
        }
    
        @Override
        public Map<String, String> hGetAll(String key) { 
            Map<Object, Object> hGetAll = redisTemplate.opsForHash().entries(key);
            return convert(hGetAll);
        }
    
    
        @Override
        public void hSet(String key, String field, String value) { 
            redisTemplate.opsForHash().put(key, field, value);
        }
    
        @Override
        public void hDel(String key, List<String> fields) { 
            redisTemplate.opsForHash().delete(key, fields.toArray());
        }
    
        @Override
        public void hSet(String key, Map<String, String> hash) { 
            redisTemplate.opsForHash().putAll(key, hash);
        }
    
        @Override
        public Boolean hasKey(String key, String field) { 
            return redisTemplate.opsForHash().hasKey(key, field);
        }
    
        @Override
        public Long hIncrByLong(String key, String field, Long value) { 
            return redisTemplate.opsForHash().increment(key, field, value);
        }
    
        @Override
        public Double hIncrByDouble(String key, String field, Double value) { 
            return redisTemplate.opsForHash().increment(key, field, value);
        }
    
        @Override
        public Integer hSize(String key) { 
            return redisTemplate.opsForHash().size(key).intValue();
        }
    
        @Override
        public void lPush(String key, String value) { 
            redisTemplate.opsForList().leftPush(key, value);
        }
    
        @Override
        public void lPush(String key, List<String> values) { 
            redisTemplate.opsForList().leftPushAll(key, values);
        }
    
        @Override
        public void lrPush(String key, String value) { 
            redisTemplate.opsForList().rightPush(key, value);
        }
    
        @Override
        public void lrPush(String key, List<String> values) { 
            redisTemplate.opsForList().rightPushAll(key, values);
        }
    
        @Override
        public void lSet(String key, Long index, String value) { 
            redisTemplate.opsForList().set(key, index, value);
        }
    
        @Override
        public void lRem(String key, long count, String value) { 
            redisTemplate.opsForList().remove(key, count, value);
        }
    
        @Override
        public void lTrim(String key, long start, long end) { 
            redisTemplate.opsForList().trim(key, start, end);
        }
    
        @Override
        public String lPop(String key) { 
            return redisTemplate.opsForList().leftPop(key);
        }
    
        @Override
        public String lrPop(String key) { 
    
            return redisTemplate.opsForList().rightPop(key);
        }
    
        @Override
        public String lIndex(String key, Long index) { 
            return redisTemplate.opsForList().index(key, index);
        }
    
        @Override
        public Integer lLen(String key) { 
            return Objects.requireNonNull(redisTemplate.opsForList().size(key)).intValue();
        }
    
        @Override
        public List<String> lRange(String key, long start, long end) { 
            return redisTemplate.opsForList().range(key, start, end);
        }
    
        @Override
        public void lSet(String key, Integer index, String value) { 
            redisTemplate.opsForList().set(key, index, value);
        }
    
        @Override
        public void sAdd(String key, List<String> values) { 
            redisTemplate.opsForSet().add(key, String.valueOf(values));
        }
    
        @Override
        public void sRem(String key, List<String> values) { 
              redisTemplate.opsForSet().remove(key,values.toArray());
        }
    
        @Override
        public String sPop(String key) { 
            return redisTemplate.opsForSet().pop(key);
        }
    
        @Override
        public Set<String> sDiff(List<String> keys) { 
            String key = keys.get(0);
            keys.remove(0);
            return redisTemplate.opsForSet().difference(key, keys);
        }
    
        @Override
        public Long sDiffStore(List<String> keys, String storeKey) { 
            String key = keys.get(0);
            keys.remove(0);
            return redisTemplate.opsForSet().differenceAndStore(key, keys, storeKey);
        }
    
        @Override
        public Set<String> sInter(List<String> keys) { 
            String key = keys.get(0);
            keys.remove(0);
            return redisTemplate.opsForSet().intersect(key, keys);
        }
    
        @Override
        public Long sInterStore(List<String> keys, String storeKey) { 
            String key = keys.get(0);
            keys.remove(0);
            return redisTemplate.opsForSet().intersectAndStore(key, keys, storeKey);
        }
    
        @Override
        public Set<String> sUnion(List<String> keys) { 
            String key = keys.get(0);
            keys.remove(0);
            return redisTemplate.opsForSet().union(key, keys);
        }
    
        @Override
        public Long sUnionStore(List<String> keys, String storeKey) { 
            String key = keys.get(0);
            keys.remove(0);
            return redisTemplate.opsForSet().unionAndStore(key, keys, storeKey);
        }
    
    
        @Override
        public Integer sSize(String key) { 
            return Objects.requireNonNull(redisTemplate.opsForSet().size(key)).intValue();
        }
    
        @Override
        public Boolean sIsMember(String key, String member) { 
            return redisTemplate.opsForSet().isMember(key, member);
        }
    
        @Override
        public String sRandMember(String key) { 
            return redisTemplate.opsForSet().randomMember(key);
        }
    
        @Override
        public Set<String> sMembersAll(String key) { 
            return redisTemplate.opsForSet().members(key);
        }
    
        private Map<String, String> convert(Map<Object, Object> objectMap) { 
            Map<String, String> stringMap = new HashMap<>();
            objectMap.keySet().forEach(it -> { 
                stringMap.put(String.valueOf(it), String.valueOf(objectMap.get(it)));
            });
            return stringMap;
        }
    
    }

## **五、调用redis服务** ##

package com.pd.shop.controller;
    
    import com.pd.shop.redis.IRedis;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    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;
    
    @Api(value = "测试类", tags = "测试类")
    @RestController
    @RequestMapping("/v1/testApi")
    public class TestApiController { 
    
        @Autowired
        private IRedis IRedis;
    
        @GetMapping("/test1")
        @ApiOperation(value = "测试接口", httpMethod = "GET")
        public void test1(){ 
            IRedis.set("bb","bb", 200000);
            String aa = IRedis.get("bb");
            IRedis.del("bb");
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzE2OTk4OTQ1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221023/2e79ea2cd7d4431b952f565a87aec11b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzE2OTk4OTQ1_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221023/ff3b942ee0074a80a1bb094e81eddb54.png