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

标签：return String spring redis param value key public cloud

一、引入redis工具依赖

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

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

二、application.xml配置redis

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

三、定义redis服务接口

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

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");
    }
}

标签：return,String,spring,redis,param,value,key,public,cloud
From： https://blog.51cto.com/u_16082658/6249900

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

一、引入redis工具依赖

二、application.xml配置redis

三、定义redis服务接口

四、实现redis服务接口

五、调用redis服务

相关文章

赞助商

阅读排行