天天看點
傳回

springboot使用redis（StringRedisTemplate的用法）

springboot使用StringRedisTemplate對redis資料庫進行操作

添加依賴 

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

opsForValue(操作字元串) 

/**
 * @author Gjing
 **/
@Component
public class RedisString {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 新增一個字元串類型的值,key是鍵，value是值。
     *
     * set(K key, V value)
     */
    public void set() {
        // 存入永久資料
        stringRedisTemplate.opsForValue().set("test2", "1");
        // 也可以向redis裡存入資料和設定緩存時間
        stringRedisTemplate.opsForValue().set("test1", "hello redis", 1000, TimeUnit.SECONDS);
    }

    /**
     * 批量插入，key值存在會覆寫原值
     *
     * multiSet(Map<? extends K,? extends V> map)
     */
    public void multiSet() {
        Map<String,String> map = new HashMap<>(16);
        map.put("testMultiSet1", "value0");
        map.put("testMultiSet2", "value2");
        stringRedisTemplate.opsForValue().multiSet(map);
    }

    /**
     *  批量插入，如果裡面的所有key都不存在，則全部插入，傳回true，如果其中一個在redis中已存在，全不插入，傳回false
     *
     *  multiSetIfAbsent(Map<? extends K,? extends V> map)
     */
    public void multiSetIfAbsent() {
        Map<String,String> map = new HashMap<>(16);
        map.put("testMultiSet4", "value1");
        map.put("testMultiSet3", "value3");
        Boolean absent = stringRedisTemplate.opsForValue().multiSetIfAbsent(map);
        System.out.println(absent);
    }

    /**
     * 如果不存在則插入，傳回true為插入成功,false失敗
     *
     * setIfAbsent(K key, V value)
     */
    public void setIfAbsent() {
        Boolean absent = stringRedisTemplate.opsForValue().setIfAbsent("test", "hello redis");
        System.out.println(absent);
    }
    /**
     * 擷取值,key不存在傳回null
     *
     * get(Object key)
     */
    public void get() {
        System.out.println(stringRedisTemplate.opsForValue().get("testMultiSet1"));
    }

    /**
     * 批量擷取，key不存在傳回null
     *
     * multiGet(Collection<K> keys)
     */
    public void multiGet() {
        List<String> list = stringRedisTemplate.opsForValue().multiGet(Arrays.asList("test", "test2"));
        assert list != null;
        System.out.println(list.toString());
    }

    /**
     * 擷取指定字元串的長度。
     *
     * size(K key)
     */
    public void getLength() {
        Long size = stringRedisTemplate.opsForValue().size("test");
        System.out.println(size);
    }

    /**
     * 在原有的值基礎上新增字元串到末尾。
     *
     * append(K key, String value)
     */
    public void append() {
        Integer append = stringRedisTemplate.opsForValue().append("test3", "database");
        System.out.println(append);
    }

    /**
     * 擷取原來key鍵對應的值并重新賦新值
     *
     * getAndSet(K key, V value)
     */
    public void getAndSet() {
        String set = stringRedisTemplate.opsForValue().getAndSet("test", "set test");
        System.out.println(set);
    }

    /**
     * 擷取指定key的值進行減1，如果value不是integer類型，會抛異常，如果key不存在會建立一個，預設value為0
     *
     * decrement(k key)
     */
    public void decrement() {
        stringRedisTemplate.opsForValue().decrement("test2");
        stringRedisTemplate.opsForValue().decrement("test1");
    }

    /**
     * 擷取指定key的值進行加1，如果value不是integer類型，會抛異常，如果key不存在會建立一個，預設value為0
     * 
     * increment(k key)
     */
    public void increment() {
        stringRedisTemplate.opsForValue().increment("test2");
        stringRedisTemplate.opsForValue().increment("test1");
    }

    /**
     * 删除指定key,成功傳回true，否則false
     * 
     * delete(k key)
     */
    public void delete() {
        Boolean delete = stringRedisTemplate.opsForValue().getOperations().delete("test1");
        System.out.println(delete);
    }

    /**
     * 删除多個key，傳回删除key的個數
     * 
     * delete(k ...keys)
     */
    public void deleteMulti() {
        Long delete = stringRedisTemplate.opsForValue().getOperations().delete(Arrays.asList("test1", "test2"));
        System.out.println(delete);
    }
}

opsForList(操作集合) 

/**
 * @author Gjing
 **/
@Component
public class RedisList {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 在變量左邊添加元素值。如果key不存在會建立，添加成功傳回添加後的總個數
     * 
     * leftPush(K key, V value)
     */
    public void leftPush() {
        Long aLong = stringRedisTemplate.opsForList().leftPush("list", "a");
        System.out.println(aLong);
    }

    /**
     * 向左邊批量添加參數元素，如果key不存在會建立，添加成功傳回添加後的總個數
     * 
     * leftPushAll(K key, V... values)
     */
    public void leftPushAll() {
        Long pushAll = stringRedisTemplate.opsForList().leftPushAll("list", "e", "f", "g");
        System.out.println(pushAll);
    }

    /**
     * 向集合最右邊添加元素。如果key不存在會建立，添加成功傳回添加後的總個數
     * 
     * rightPush(K key, V value)
     */
    public void rightPush() {
        Long aLong = stringRedisTemplate.opsForList().rightPush("list2", "a");
        System.out.println(aLong);
    }


    /**
     * 如果存在集合則添加元素。
     * 
     * leftPushIfPresent(K key, V value)
     */
    public void leftPushIfPresent() {
        Long aLong = stringRedisTemplate.opsForList().leftPushIfPresent("list", "h");
        System.out.println(aLong);
    }

    /**
     * 向右邊批量添加元素。傳回目前集合元素總個數
     * 
     * rightPushAll(K key, V... values)
     */
    public void rightPushAll() {
        Long aLong = stringRedisTemplate.opsForList().rightPushAll("list2", "b", "c", "d");
        System.out.println(aLong);
    }

    /**
     * 向已存在的集合中添加元素。傳回集合總元素個數
     * 
     * rightPushIfPresent(K key, V value)
     */
    public void rightPushIfPresent() {
        Long aLong = stringRedisTemplate.opsForList().rightPushIfPresent("list", "e");
        System.out.println(aLong);
    }

    /**
     * 擷取集合長度
     * 
     * size(K key)
     */
    public void size() {
        Long size = stringRedisTemplate.opsForList().size("list2");
        System.out.println(size);
    }

    /**
     * 移除集合中的左邊第一個元素。傳回删除的元素，如果元素為空，該集合會自動删除
     * 
     * leftPop(K key)
     */
    public void leftPop() {
        String pop = stringRedisTemplate.opsForList().leftPop("list2");
        System.out.println(pop);
    }

    /**
     * 移除集合中左邊的元素在等待的時間裡，如果超過等待的時間仍沒有元素則退出。
     * 
     * leftPop(K key, long timeout, TimeUnit unit)
     */
    public void leftPopWait() {
        String pop = stringRedisTemplate.opsForList().leftPop("list2", 10, TimeUnit.SECONDS);
        System.out.println(pop);
    }

    /**
     * 移除集合中右邊的元素。傳回删除的元素，如果元素為空，該集合會自動删除
     * 
     * rightPop(K key)
     */
    public void rightPop() {
        String pop = stringRedisTemplate.opsForList().rightPop("list2");
        System.out.println(pop);
    }

    /**
     * 移除集合中右邊的元素在等待的時間裡，如果超過等待的時間仍沒有元素則退出。
     * 
     * rightPop(K key, long timeout, TimeUnit unit)
     */
    public void rightPopWait() {
        String pop = stringRedisTemplate.opsForList().rightPop("list2", 10, TimeUnit.SECONDS);
        System.out.println(pop);
    }

    /**
     * 移除第一個集合右邊的一個元素，插入第二個集合左邊插入這個元素
     * 
     * rightPopAndLeftPush(K sourceKey, K destinationKey)
     */
    public void rightPopAndLeftPush() {
        String s = stringRedisTemplate.opsForList().rightPopAndLeftPush("list2", "list3");
        System.out.println(s);
    }

    /**
     * 在集合的指定位置插入元素,如果指定位置已有元素，則覆寫，沒有則新增，超過集合下标+n則會報錯。
     * 
     * set(K key, long index, V value)
     */
    public void set() {
        stringRedisTemplate.opsForList().set("list2", 2, "w");
    }

    /**
     * 從存儲在鍵中的清單中删除等于值的元素的第一個計數事件。count> 0：删除等于從左到右移動的值的第一個元素；
     * count< 0：删除等于從右到左移動的值的第一個元素；count = 0：删除等于value的所有元素
     * 
     * remove(K key, long count, Object value)
     */
    public void remove() {
        Long remove = stringRedisTemplate.opsForList().remove("list2", 2, "w");
        System.out.println(remove);
    }

    /**
     * 截取集合元素長度，保留長度内的資料。
     * 
     * trim(K key, long start, long end)
     */
    public void trim() {
        stringRedisTemplate.opsForList().trim("list2", 0, 3);
    }

    /**
     * 擷取集合指定位置的值。
     * 
     * index(K key, long index)
     */
    public void index() {
        Object listValue = stringRedisTemplate.opsForList().index("list2", 3);
        System.out.println(listValue);
    }

    /**
     * 擷取指定區間的值。
     * 
     * range(K key, long start, long end)
     */
    public void range() {
        List<String> list = stringRedisTemplate.opsForList().range("list", 0, -1);
        System.out.println(list);
    }

    /**
     * 删除指定集合,傳回true删除成功
     * 
     * delete(K key)
     */
    public void delete() {
        Boolean delete = stringRedisTemplate.opsForList().getOperations().delete("list2");
        System.out.println(delete);
    }
}

opsForHash(操作hashMap) 

/**
 * @author Gjing
 **/
@Component
public class RedisHash {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 新增hashMap值
     * 
     * put(H key, HK hashKey, HV value)
     */
    public void put() {
        stringRedisTemplate.opsForHash().put("hash","hash-key","hash-value");
        stringRedisTemplate.opsForHash().put("hash","hash-key2","hash-value2");
    }

    /**
     * 以map集合的形式添加鍵值對
     * 
     * putAll(H key, Map<? extends HK,? extends HV> m)
     */
    public void putAll() {
        Map<String, String> map = new HashMap<>(16);
        map.put("hash-key3", "value3");
        map.put("hash-key4", "value4");
        stringRedisTemplate.opsForHash().putAll("hash", map);
    }

    /**
     * 如果變量值存在，在變量中可以添加不存在的的鍵值對，如果變量不存在，則新增一個變量，同時将鍵值對添加到該變量。添加成功傳回true否則傳回false
     * 
     * putIfAbsent(H key, HK hashKey, HV value)
     */
    public void putIfAbsent() {
        Boolean absent = stringRedisTemplate.opsForHash().putIfAbsent("hash", "hash-key", "value1");
        Boolean absent2 = stringRedisTemplate.opsForHash().putIfAbsent("hash", "hash-key5", "value5");
        System.out.println(absent);
        System.out.println(absent2);
    }

    /**
     * 擷取指定變量中的hashMap值。
     * 
     * values(H Key)
     */
    public void values() {
        List<Object> values = stringRedisTemplate.opsForHash().values("hash2");
        System.out.println(values.toString());
    }

    /**
     * 擷取變量中的鍵值對。
     * 
     * entries(H key)
     */
    public void entries() {
        Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("hash");
        System.out.println(entries.toString());
    }

    /**
     * 擷取變量中的指定map鍵是否有值,如果存在該map鍵則擷取值，沒有則傳回null。
     * 
     * get(H key, Object hashKey)
     */
    public void get() {
        Object value = stringRedisTemplate.opsForHash().get("hash", "hash-key");
        System.out.println(value);
    }

    /**
     * 擷取變量中的鍵。
     * 
     * keys(H key)
     */
    public void keys() {
        Set<Object> keys = stringRedisTemplate.opsForHash().keys("hash");
        System.out.println(keys.toString());
    }

    /**
     *  擷取變量的長度
     *  
     *  size(H key)
     */
    public void size() {
        Long size = stringRedisTemplate.opsForHash().size("hash");
        System.out.println(size);
    }

    /**
     * 使變量中的鍵以long值的大小進行自增長。值必須為Integer類型,否則異常
     * 
     * increment(H key, HK hashKey, long data)
     */
    public void increment() {
        Long increment = stringRedisTemplate.opsForHash().increment("hash", "hash-key2", 1);
        System.out.println(increment);
    }

    /**
     * 以集合的方式擷取變量中的值。
     * 
     * multiGet(H key, Collection<HK> hashKeys)
     */
    public void multiGet() {
        List<Object> values = stringRedisTemplate.opsForHash().multiGet("hash", Arrays.asList("hash-key", "hash-key2"));
        System.out.println(values.toString());
    }

    /**
     * 比對擷取鍵值對，ScanOptions.NONE為擷取全部鍵對，ScanOptions.scanOptions().match("hash-key2").build()比對擷取鍵位map1的鍵值對,不能模糊比對。
     * 
     * scan(H key, ScanOptions options)
     */
    public void scan() {
        Cursor<Map.Entry<Object, Object>> scan = stringRedisTemplate.opsForHash().scan("hash", ScanOptions.NONE);
        while (scan.hasNext()) {
            Map.Entry<Object, Object> next = scan.next();
            System.out.println(next.getKey() + "---->" + next.getValue());
        }
    }

    /**
     * 删除變量中的鍵值對，可以傳入多個參數，删除多個鍵值對。傳回删除成功數量
     * 
     * delete(H key, Object... hashKeys)
     */
    public void delete() {
        Long delete = stringRedisTemplate.opsForHash().delete("hash", "hash-key", "hash-key1");
        System.out.println(delete);
    }

}

opsForSet(操作set集合) 

/**
 * @author Gjing
 *
 * 以下可能有部分方法含有參數傳Collection的,本案例沒有描述,你們可以根據實際參數類型傳參
 **/
@Component
public class RedisSet {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 向變量中批量添加值。傳回添加的數量
     *
     * add(K key, V... values)
     */
    public void add() {
        Long add = stringRedisTemplate.opsForSet().add("set", "a", "b", "c");
        System.out.println(add);
    }

    /**
     * 擷取變量的值
     *
     * members(K key)
     */
    public void members() {
        Set<String> set = stringRedisTemplate.opsForSet().members("set");
        System.out.println(set);
    }

    /**
     * 擷取變量中值得長度
     *
     * size(k key)
     */
    public void size() {
        Long size = stringRedisTemplate.opsForSet().size("set");
        System.out.println(size);
    }

    /**
     * 随機擷取變量中的某個元素
     *
     * randomMember(k key)
     */
    public void randomMember() {
        String member = stringRedisTemplate.opsForSet().randomMember("set");
        System.out.println(member);
    }

    /**
     * 随機擷取變量中指定個數的元素
     *
     * randomMembers(k key, long count)
     */
    public void randomMembers() {
        List<String> members = stringRedisTemplate.opsForSet().randomMembers("set", 2);
        System.out.println(members);
    }

    /**
     * 檢查給定的元素是否在變量中,true為存在
     *
     * isMember(k key, object value)
     */
    public void isMember() {
        Boolean member = stringRedisTemplate.opsForSet().isMember("set", "b");
        System.out.println(member);
    }

    /**
     * 轉義變量的元素值到另一個變量中
     *
     * move(k key, v value, k targetKey)
     */
    public void move() {
        Boolean move = stringRedisTemplate.opsForSet().move("set", "b", "set2");
        System.out.println(move);
    }

    /**
     * 彈出變量中的元素。當元素全部彈完,變量也會删除
     *
     * pop(k key)
     */
    public void pop() {
        String pop = stringRedisTemplate.opsForSet().pop("set");
        System.out.println(pop);
    }

    /**
     * 批量删除變量中的元素,傳回删除的數量
     *
     * remove(k key, v ...values)
     */
    public void remove() {
        Long remove = stringRedisTemplate.opsForSet().remove("set2", "b");
        System.out.println(remove);
    }

    /**
     * 比對擷取鍵值對，ScanOptions.NONE為擷取全部鍵值對；ScanOptions.scanOptions().match("C").build()比對擷取鍵位map1的鍵值對,不能模糊比對。
     *
     * scan(K key, ScanOptions options)
     */
    public void scan() {
        Cursor<String> set = stringRedisTemplate.opsForSet().scan("set", ScanOptions.NONE);
        while (set.hasNext()) {
            String next = set.next();
            System.out.println(next);
        }
    }

    /**
     * 通過集合求內插補點。
     *
     * difference(k key, k otherKey)
     */
    public void difference() {
        Set<String> difference = stringRedisTemplate.opsForSet().difference("set", "set2");
        System.out.println(difference);
    }

    /**
     * 将求出來的內插補點元素儲存
     *
     * differenceAndStore(K key, K otherKey, K targetKey)
     */
    public void differenceAndStore() {
        Long aLong = stringRedisTemplate.opsForSet().differenceAndStore("set", "set2", "set3");
        System.out.println(aLong);
    }

    /**
     * 擷取去重的随機元素
     *
     * distinctRandomMembers(K key, long count)
     */
    public void distinctRandomMembers() {
        Set<String> set = stringRedisTemplate.opsForSet().distinctRandomMembers("set", 2);
        System.out.println(set);
    }

    /**
     * 擷取兩個變量中的交集
     *
     * intersect(K key, K otherKey)
     */
    public void intersect() {
        Set<String> intersect = stringRedisTemplate.opsForSet().intersect("set", "set2");
        System.out.println(intersect);
    }

    /**
     * 擷取2個變量交集後儲存到最後一個變量上。
     *
     * intersectAndStore(K key, K otherKey, K targetKey)
     */
    public void intersectAndStore() {
        Long aLong = stringRedisTemplate.opsForSet().intersectAndStore("set", "set2", "set3");
        System.out.println(aLong);
    }

    /**
     * 擷取兩個變量的合集
     *
     * union(K key, K otherKey)
     */
    public void union() {
        Set<String> union = stringRedisTemplate.opsForSet().union("set", "set2");
        System.out.println(union);
    }

    /**
     * 擷取兩個變量合集後儲存到另一個變量中
     *
     * unionAndStore(K key, K otherKey, K targetKey)
     */
    public void unionAndStore() {
        Long aLong = stringRedisTemplate.opsForSet().unionAndStore("set", "set2", "set3");
        System.out.println(aLong);
    }
}

opsForZset 

/**
 * @author Gjing
 *
 **/
@Component
public class RedisZSet {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 添加元素到變量中同時指定元素的分值。
     *
     * add(K key, V value, double score)
     */
    public void add() {
        Boolean add = stringRedisTemplate.opsForZSet().add("zset", "a", 1);
        System.out.println(add);
    }

    /**
     * 通過TypedTuple方式新增資料。
     *
     * add(K key, Set<ZSetOperations.TypedTuple<V>> tuples)
     */
    public void addByTypedTuple() {
        ZSetOperations.TypedTuple<String> typedTuple1 = new DefaultTypedTuple<>("E", 2.0);
        ZSetOperations.TypedTuple<String> typedTuple2 = new DefaultTypedTuple<>("F", 3.0);
        ZSetOperations.TypedTuple<String> typedTuple3 = new DefaultTypedTuple<>("G", 5.0);
        Set<ZSetOperations.TypedTuple<String>> typedTupleSet = new HashSet<>();
        typedTupleSet.add(typedTuple1);
        typedTupleSet.add(typedTuple2);
        typedTupleSet.add(typedTuple3);
        Long zset = stringRedisTemplate.opsForZSet().add("zset", typedTupleSet);
        System.out.println(zset);
    }

    /**
     * 擷取指定區間的元素
     *
     * range(k key, long start, long end)
     */
    public void range() {
        Set<String> zset = stringRedisTemplate.opsForZSet().range("zset", 0, -1);
        System.out.println(zset);
    }

    /**
     * 用于擷取滿足非score的排序取值。這個排序隻有在有相同分數的情況下才能使用，如果有不同的分數則傳回值不确定。
     *
     * rangeByLex(K key, RedisZSetCommands.Range range)
     */
    public void rangeByLex() {
        Set<String> rangeByLex = stringRedisTemplate.opsForZSet().rangeByLex("zset", RedisZSetCommands.Range.range().lt("E"));
        System.out.println(rangeByLex);
    }

    /**
     * 用于擷取滿足非score的設定下标開始的長度排序取值。
     *
     * rangeByLex(k key, range range, limit limit)
     */
    public void rangeByLexAndLimit() {
        Set<String> zset = stringRedisTemplate.opsForZSet().rangeByLex("zset", RedisZSetCommands.Range.range().lt("E"),
                RedisZSetCommands.Limit.limit().offset(1).count(2));
        System.out.println(zset);
    }

    /**
     * 根據設定的score擷取區間值。
     *
     * rangeByScore(K key, double min, double max)
     */
    public void rangeByScore() {
        Set<String> zset = stringRedisTemplate.opsForZSet().rangeByScore("zset", 1, 3);
        System.out.println(zset);
    }

    /**
     * 擷取RedisZSetCommands.Tuples的區間值。
     *
     * rangeWithScores(K key, long start, long end)
     */
    public void rangeWithScores() {
        Set<ZSetOperations.TypedTuple<String>> zset = stringRedisTemplate.opsForZSet().rangeWithScores("zset", 1, 3);
        assert zset != null;
        for (ZSetOperations.TypedTuple<String> next : zset) {
            String value = next.getValue();
            Double score = next.getScore();
            System.out.println(value + "-->" + score);
        }
    }

    /**
     * 擷取區間值的個數。
     *
     * count(k key, double min, double max)
     */
    public void count() {
        Long zset = stringRedisTemplate.opsForZSet().count("zset", 1, 3);
        System.out.println(zset);
    }

    /**
     * 擷取變量中指定元素的索引,下标開始為0
     *
     * rank(k key, object o)
     */
    public void rank() {
        Long rank = stringRedisTemplate.opsForZSet().rank("zset", "a");
        System.out.println(rank);
    }

    /**
     * 比對擷取鍵值對，ScanOptions.NONE為擷取全部鍵值對；ScanOptions.scanOptions().match("C").build()比對擷取鍵位map1的鍵值對,不能模糊比對。
     *
     * scan(K key, ScanOptions options)
     */
    public void scan() {
        Cursor<ZSetOperations.TypedTuple<String>> zset = stringRedisTemplate.opsForZSet().scan("zset", ScanOptions.NONE);
        while (zset.hasNext()) {
            ZSetOperations.TypedTuple<String> next = zset.next();
            System.out.println(next.getValue() + "-->" + next.getScore());
        }
    }

    /**
     * 擷取指定元素的分值
     *
     * score(k key, object o)
     */
    public void score() {
        Double score = stringRedisTemplate.opsForZSet().score("zset", "a");
        System.out.println(score);
    }

    /**
     * 擷取變量中元素的個數
     *
     * zCard(k key)
     */
    public void zCard() {
        Long zset = stringRedisTemplate.opsForZSet().zCard("zset");
        System.out.println(zset);
    }

    /**
     * 修改變量中元素的分值
     *
     * incrementScore(K key, V value, double delta)
     */
    public void incrementScore() {
        Double score = stringRedisTemplate.opsForZSet().incrementScore("zset", "a", 2);
        System.out.println(score);
    }

    /**
     * 索引倒序排列指定區間的元素
     *
     * reverseRange(K key, long start, long end)
     */
    public void reverseRange() {
        Set<String> zset = stringRedisTemplate.opsForZSet().reverseRange("zset", 1, 3);
        System.out.println(zset);
    }

    /**
     * 倒序排列指定分值區間的元素
     *
     * reverseRangeByScore(K key, double min, double max)
     */
    public void reverseRangeByScore() {
        Set<String> zset = stringRedisTemplate.opsForZSet().reverseRangeByScore("zset", 1, 3);
        System.out.println(zset);
    }

    /**
     * 倒序排序擷取RedisZSetCommands.Tuples的分值區間值
     *
     * reverseRangeByScore(K key, double min, double max, long offset, long count)
     */
    public void reverseRangeByScoreLength() {
        Set<String> zset = stringRedisTemplate.opsForZSet().reverseRangeByScore("zset", 1, 3, 1, 2);
        System.out.println(zset);
    }

    /**
     * 倒序排序擷取RedisZSetCommands.Tuples的分值區間值。
     *
     * reverseRangeByScoreWithScores(K key, double min, double max)
     */
    public void reverseRangeByScoreWithScores() {
        Set<ZSetOperations.TypedTuple<String>> zset = stringRedisTemplate.opsForZSet().reverseRangeByScoreWithScores("zset", 1, 5);
        assert zset != null;
        zset.iterator().forEachRemaining(e-> System.out.println(e.getValue() + "--->" + e.getScore()));
    }

    /**
     * 擷取倒序排列的索引值
     *
     * reverseRank(k key, object o)
     */
    public void reverseRank() {
        Long aLong = stringRedisTemplate.opsForZSet().reverseRank("zset", "a");
        System.out.println(aLong);
    }

    /**
     * 擷取2個變量的交集存放到第3個變量裡面。
     *
     * intersectAndStore(K key, K otherKey, K destKey)
     */
    public void intersectAndStore() {
        Long aLong = stringRedisTemplate.opsForZSet().intersectAndStore("zset", "zset2", "zset3");
        System.out.println(aLong);
    }

    /**
     * 擷取2個變量的合集存放到第3個變量裡面。 傳回操作的數量
     *
     * unionAndStore(K key, K otherKey, K destKey)
     */
    public void unionAndStore() {
        Long aLong = stringRedisTemplate.opsForZSet().unionAndStore("zset", "zset2", "zset3");
        System.out.println(aLong);
    }


    /**
     * 批量移除元素根據元素值。傳回删除的元素數量
     *
     * remove(K key, Object... values)
     */
    public void remove() {
        Long remove = stringRedisTemplate.opsForZSet().remove("zset", "a", "b");
        System.out.println(remove);
    }

    /**
     * 根據分值移除區間元素。傳回删除的數量
     *
     * removeRangeByScore(k key, double min, double max)
     */
    public void removeRangeByScore() {
        Long zset = stringRedisTemplate.opsForZSet().removeRangeByScore("zset", 1, 3);
        System.out.println(zset);
    }

    /**
     * 根據索引值移除區間元素。傳回移除的元素集合
     *
     * removeRange(K key, long start, long end)
     */
    public void removeRange() {
        Set<String> zset = stringRedisTemplate.opsForZSet().reverseRange("zset", 0, 4);
        System.out.println(zset);
    }
}

五大常用資料類型使用場景

  • String

緩存：将資料以字元串方式存儲

計數器功能：比如視訊播放次數，點贊次數。

共享session：資料共享的功能，redis作為單獨的應用軟體用來存儲一些共享資料供多個執行個體通路。

字元串的使用空間非常大，可以結合字元串提供的指令充分發揮自己的想象力

  • hash

字典。鍵值對集合，即程式設計語言中的Map類型。适合存儲對象，并且可以像資料庫中update一個屬性一樣隻修改某一項屬性值。适用于：存

儲、讀取、修改使用者屬性。也可以用Hash做表資料緩存

  • list
連結清單(雙向連結清單)，增删快，提供了操作某一段元素的API。适用于：最新消息排行等功能；消息隊列。
  • set
集合。哈希表實作，元素不重複，為集合提供了求交集、并集、差集等操作。适用于：共同好友；利用唯一性，統計通路網站的所有獨立ip；> 好友推薦時，根據tag求交集，大于某個門檻值就可以推薦。
  • sorted set
有序集合。将Set中的元素增加一個權重參數score，元素按score有序排列。資料插入集合時，已經進行天然排序。适用于：排行榜；帶權重的消息隊列。

StringRedisTemplate與RedisTemplate的差別?

兩者的關系是StringRedisTemplate繼承RedisTemplate。

兩者的資料是不共通的；也就是說StringRedisTemplate隻能管理StringRedisTemplate裡面的資料

RedisTemplate隻能管RedisTemplate中的資料。

SDR預設采用的序列化政策有兩種，一種是String的序列化政策，一種是JDK的序列化政策。

StringRedisTemplate預設采用的是String的序列化政策，儲存的key和value都是采用此政策序列化儲存的。

RedisTemplate預設采用的是JDK的序列化政策，儲存的key和value都是采用此政策序列化儲存的。

友情提示：目前資料類型已經達到八種，本文隻講解了五種常用類型，其餘的自行學習

源代碼位址：redis-demo

java springboot Redis StringRedisTemplate
上一篇: C++類與對象（二）構造函數析構函數拷貝構造函數指派運算符重載const成員取位址及const取位址操作符重載
下一篇: 如何用sql語言隻獲得資料庫目前日期，且格式為"yyyy-mm-dd"？

繼續閱讀