springcloud redis集成與測試

 

1.添加依賴

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

2.添加application

#####################redis
spring.redis.database=0
spring.redis.host=localhost
spring.redis.port=6379
# 連接池最大連接數（使用負值表示沒有限制）
spring.redis.jedis.pool.max-active=8
# 連接池最大阻塞等待時間（使用負值表示沒有限制）
spring.redis.jedis.pool.max-wait=-1
# 連接池中的最小空閒連接
spring.redis.jedis.pool.min-idle=0
# 連接池中的最大空閒連接
spring.redis.jedis.pool.max-idle=8
# 連接超時時間（毫秒）
spring.redis.timeout=10000

3.redisutils

package com.lt.congateway.utils;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @author tong.luo
 * @description JedisUtils
 * @date 2020/4/19 16:42
 */
@Component
public class JedisUtils {
    @Resource
    private RedisTemplate redisTemplate;

    /**
     * @param key
     * @param time 秒
     * @return
     */
    public Boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根據key 獲取過期時間
     *
     * @param key 鍵 不能爲null
     * @return 時間(秒) 返回0代表爲永久有效
     */
    public Long getExpire(String key) {
        Long expire = redisTemplate.getExpire(key);
        return expire;
    }

    /**
     * 判斷key是否存在
     *
     * @param key 鍵
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 刪除緩存
     *
     * @param key 可以傳一個值 或多個
     */
    @SuppressWarnings("unchecked")
    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));
            }
        }
    }

    /**
     * 刪除單個key
     *
     * @param key 鍵
     * @return true=刪除成功；false=刪除失敗
     */
    public boolean del(final String key) {

        Boolean ret = redisTemplate.delete(key);
        return ret != null && ret;
    }

    /**
     * 存入普通對象
     *
     * @param key   Redis鍵
     * @param value 值
     */
    public void set(final String key, final Object value) {
        redisTemplate.opsForValue().set(key, value, 1, TimeUnit.MINUTES);
    }

    // 存儲普通對象操作

    /**
     * 存入普通對象
     *
     * @param key     鍵
     * @param value   值
     * @param timeout 有效期，單位秒
     */
    public void set(final String key, final Object value, final long timeout) {
        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }

    /**
     * 獲取普通對象
     *
     * @param key 鍵
     * @return 對象
     */
    public Object get(final String key) {
        return redisTemplate.opsForValue().get(key);
    }
// 存儲Hash操作

    /**
     * 往Hash中存入數據
     *
     * @param key   Redis鍵
     * @param hKey  Hash鍵
     * @param value 值
     */
    public void hPut(final String key, final String hKey, final Object value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 批量存儲
     *
     * @param map
     */
    public void mset(Map map) {
        this.redisTemplate.opsForValue().multiSet(map);
    }

    /**
     * 批量獲取
     *
     * @param collection
     * @return
     */
    public List mget(Collection collection) {
        List list = this.redisTemplate.opsForValue().multiGet(collection);
        return list;
    }

    /**
     * 往Hash中存入多個數據
     *
     * @param key    Redis鍵
     * @param values Hash鍵值對
     */
    public void hPutAll(final String key, final Map<String, Object> values) {

        redisTemplate.opsForHash().putAll(key, values);
    }

    /**
     * 獲取Hash中的數據
     *
     * @param key  Redis鍵
     * @param hKey Hash鍵
     * @return Hash中的對象
     */
    public Object hGet(final String key, final String hKey) {

        return redisTemplate.opsForHash().get(key, hKey);
    }

    /**
     * 獲取多個Hash中的數據
     *
     * @param key   Redis鍵
     * @param hKeys Hash鍵集合
     * @return Hash對象集合
     */
    public List<Object> hMultiGet(final String key, final Collection<Object> hKeys) {

        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    // 存儲Set相關操作

    /**
     * 往Set中存入數據
     *
     * @param key    Redis鍵
     * @param values 值
     * @return 存入的個數
     */
    public long sSet(final String key, final Object... values) {
        Long count = redisTemplate.opsForSet().add(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 刪除Set中的數據
     *
     * @param key    Redis鍵
     * @param values 值
     * @return 移除的個數
     */
    public long sDel(final String key, final Object... values) {
        Long count = redisTemplate.opsForSet().remove(key, values);
        return count == null ? 0 : count;
    }

    // 存儲List相關操作

    /**
     * 往List中存入數據
     *
     * @param key   Redis鍵
     * @param value 數據
     * @return 存入的個數
     */
    public long lPush(final String key, final Object value) {
        Long count = redisTemplate.opsForList().rightPush(key, value);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入多個數據
     *
     * @param key    Redis鍵
     * @param values 多個數據
     * @return 存入的個數
     */
    public long lPushAll(final String key, final Collection<Object> values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入多個數據
     *
     * @param key    Redis鍵
     * @param values 多個數據
     * @return 存入的個數
     */
    public long lPushAll(final String key, final Object... values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 從List中獲取begin到end之間的元素
     *
     * @param key   Redis鍵
     * @param start 開始位置
     * @param end   結束位置（start=0，end=-1表示獲取全部元素）
     * @return List對象
     */
    public List<Object> lGet(final String key, final int start, final int end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

}

測試

package com.lt.congateway;

import com.alibaba.fastjson.JSON;
import com.lt.congateway.utils.JedisUtils;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.UUID;

@SpringBootTest
class ConGatewayApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private JedisUtils jedisUtils;

    @Test
    void test() {
//        redisTemplate.opsForValue().set("test","test");
//        Object test = redisTemplate.opsForValue().get("test");
//        System.out.println(test);
//        redisTemplate.opsForValue().set("test","test",10, TimeUnit.SECONDS);
        HashMap<String, Object> stringObjectHashMap = new HashMap<>(16);
        for (int i = 0; i < 10; i++) {
            String uuid = UUID.randomUUID().toString();
            stringObjectHashMap.put(uuid, uuid + ":" + i);
        }
        Set<String> strings = stringObjectHashMap.keySet();
        System.out.println(JSON.toJSONString(stringObjectHashMap));
        this.jedisUtils.mset(stringObjectHashMap);
        List list = this.jedisUtils.mget(strings);
        System.out.println(JSON.toJSONString(list));
    }

}

測試通過說明集成ok