博主
258
258
258
258
专辑

第四节 使用RedisTemplate模板操作Redis

亮子 2021-06-10 08:46:35 658 0 0 0

1、添加依赖

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

2、引入模板

package com.shenmazong.demobootredis;

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.StringRedisTemplate;

@SpringBootTest
class DemoBootRedisApplicationTests {

    @Autowired
    StringRedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        redisTemplate.opsForValue().set("userName", "wusong");
    }

}

3、操作Value

    @Test
    void testForValue() throws InterruptedException {

        // 1、set(K key, V value)
        // 新增一个字符串类型的值,key是键,value是值。
        redisTemplate.opsForValue().set("stringValue","bbb");

        // 2、get(Object key)
        // 获取key键对应的值。
        String stringValue = redisTemplate.opsForValue().get("stringValue")+"";
        System.out.println("通过get(Object key)方法获取set(K key, V value)方法新增的字符串值:" + stringValue);

        //3、append(K key, String value)
        //在原有的值基础上新增字符串到末尾。
        redisTemplate.opsForValue().append("stringValue","aaa");
        String stringValueAppend = redisTemplate.opsForValue().get("stringValue")+"";
        System.out.println("通过append(K key, String value)方法修改后的字符串:"+stringValueAppend);

        // 4、get(K key, long start, long end)
        //截取key键对应值得字符串,从开始下标位置开始到结束下标的位置(包含结束下标)的字符串。
        String cutString = redisTemplate.opsForValue().get("stringValue",0,3);
        System.out.println("通过get(K key, long start, long end)方法获取截取的字符串:"+cutString);

        // 5、getAndSet(K key, V value)
        // 获取原来key键对应的值并重新赋新值。
        String oldAndNewStringValue = redisTemplate.opsForValue().getAndSet("stringValue","ccc")+"";
        System.out.print("通过getAndSet(K key, V value)方法获取原来的" + oldAndNewStringValue + ",");
        String newStringValue = redisTemplate.opsForValue().get("stringValue")+"";
        System.out.println("修改过后的值:"+newStringValue);

        // 6、setBit(K key, long offset, boolean value)
        // key键对应的值value对应的ascii码,在offset的位置(从左向右数)变为value。
        redisTemplate.opsForValue().setBit("stringValue",1,false);
        newStringValue = redisTemplate.opsForValue().get("stringValue")+"";
        System.out.println("通过setBit(K key,long offset,boolean value)方法修改过后的值:"+newStringValue);

        // 7、getBit(K key, long offset)
        // 判断指定的位置ASCII码的bit位是否为1。
        boolean bitBoolean = redisTemplate.opsForValue().getBit("stringValue",1);
        System.out.println("通过getBit(K key,long offset)方法判断指定bit位的值是:" + bitBoolean);

        // 8、size(K key)
        // 获取指定字符串的长度。
        Long stringValueLength = redisTemplate.opsForValue().size("stringValue");
        System.out.println("通过size(K key)方法获取字符串的长度:"+stringValueLength);

        // 9、increment(K key, double delta)
        // 以增量的方式将double值存储在变量中。
        double stringValueDouble = redisTemplate.opsForValue().increment("doubleValue",5);
        System.out.println("通过increment(K key, double delta)方法以增量方式存储double值:" + stringValueDouble);

        // 10、increment(K key, long delta)
        //以增量的方式将long值存储在变量中。
        double stringValueLong = redisTemplate.opsForValue().increment("longValue",6);
        System.out.println("通过increment(K key, long delta)方法以增量方式存储long值:" + stringValueLong);

        // 11、setIfAbsent(K key, V value)
        // 如果键不存在则新增,存在则不改变已经有的值。
        boolean absentBoolean = redisTemplate.opsForValue().setIfAbsent("absentValue","fff");
        System.out.println("通过setIfAbsent(K key, V value)方法判断变量值absentValue是否存在:" + absentBoolean);
        if(absentBoolean){
            String absentValue = redisTemplate.opsForValue().get("absentValue")+"";
            System.out.print(",不存在,则新增后的值是:"+absentValue);
            boolean existBoolean = redisTemplate.opsForValue().setIfAbsent("absentValue","eee");
            System.out.print(",再次调用setIfAbsent(K key, V value)判断absentValue是否存在并重新赋值:" + existBoolean);
            if(!existBoolean){
                absentValue = redisTemplate.opsForValue().get("absentValue")+"";
                System.out.print("如果存在,则重新赋值后的absentValue变量的值是:" + absentValue);
            }
        }

        // 12、set(K key, V value, long timeout, TimeUnit unit)
        // 设置变量值的过期时间。
        redisTemplate.opsForValue().set("timeOutValue","timeOut",5, TimeUnit.SECONDS);
        String timeOutValue = redisTemplate.opsForValue().get("timeOutValue")+"";
        System.out.println("通过set(K key, V value, long timeout, TimeUnit unit)方法设置过期时间,过期之前获取的数据:"+timeOutValue);
        Thread.sleep(5*1000);
        timeOutValue = redisTemplate.opsForValue().get("timeOutValue")+"";
        System.out.print(",等待10s过后,获取的值:"+timeOutValue);

        // 13、set(K key, V value, long offset)
        //  覆盖从指定位置开始的值。
        redisTemplate.opsForValue().set("absentValue","dd",1);
        String overrideString = redisTemplate.opsForValue().get("absentValue")+"";
        System.out.println("通过set(K key, V value, long offset)方法覆盖部分的值:"+overrideString);

        // 14、multiSet(Map<? extends K,? extends V> map)
        //  设置map集合到redis。
        Map valueMap = new HashMap();
        valueMap.put("valueMap1","map1");
        valueMap.put("valueMap2","map2");
        valueMap.put("valueMap3","map3");
        redisTemplate.opsForValue().multiSet(valueMap);

        // 15、multiGet(Collection<K> keys)
        //  根据集合取出对应的value值。

        //根据List集合取出对应的value值
        List paraList = new ArrayList();
        paraList.add("valueMap1");
        paraList.add("valueMap2");
        paraList.add("valueMap3");
        List<String> valueList = redisTemplate.opsForValue().multiGet(paraList);
        for (String value : valueList){
            System.out.println("通过multiGet(Collection<K> keys)方法获取map值:" + value);
        }

        // 16、multiSetIfAbsent(Map<? extends K,? extends V> map)
        //  如果对应的map集合名称不存在,则添加,如果存在则不做修改。
        Map valueMap1 = new HashMap();
        valueMap1.put("valueMap1","map1");
        valueMap1.put("valueMap2","map2");
        valueMap1.put("valueMap3","map3");
        redisTemplate.opsForValue().multiSetIfAbsent(valueMap1);

    }

4、操作List

@Test
    void testForList() {
        // https://blog.csdn.net/suo082407128/article/details/86230914

        // 1、leftPush(K key, V value)
        //  在变量左边添加元素值。
        redisTemplate.opsForList().leftPush("list","a");
        redisTemplate.opsForList().leftPush("list","b");
        redisTemplate.opsForList().leftPush("list","c");

        // 2、index(K key, long index)
        //  获取集合指定位置的值。
        String listValue = redisTemplate.opsForList().index("list",1) + "";
        System.out.println("通过index(K key, long index)方法获取指定位置的值:" + listValue);

        // 3、range(K key, long start, long end)
        //获取指定区间的值。
        List<Object> list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println("通过range(K key, long start, long end)方法获取指定范围的集合值:"+list);

        // 4、leftPush(K key, V pivot, V value)
        // 把最后一个参数值放到指定集合的第一个出现中间参数的前面,如果中间参数值存在的话。
        redisTemplate.opsForList().leftPush("list","a","n");
        list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println("通过leftPush(K key, V pivot, V value)方法把值放到指定参数值前面:" + list);

        // 5、leftPushAll(K key, V... values)
        //  向左边批量添加参数元素。
        redisTemplate.opsForList().leftPushAll("list","w","x","y");
        list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println("通过leftPushAll(K key, V... values)方法批量添加元素:" + list);

        // 6、leftPushAll(K key, Collection<V> values)
        //  以集合的方式向左边批量添加元素。
        List newList = new ArrayList();
        newList.add("o");
        newList.add("p");
        newList.add("q");
        redisTemplate.opsForList().leftPushAll("list",newList);
        list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println("通过leftPushAll(K key, Collection<V> values)方法以集合的方式批量添加元素:" + list);

        // 7、leftPushIfPresent(K key, V value)
        //  如果存在集合则添加元素。
        redisTemplate.opsForList().leftPushIfPresent("presentList","o");
        list =  redisTemplate.opsForList().range("presentList",0,-1);
        System.out.println("通过leftPushIfPresent(K key, V value)方法向已存在的集合添加元素:" + list);

        // 8、rightPush(K key, V value)
        //  向集合最右边添加元素。
        redisTemplate.opsForList().rightPush("list","w");
        list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println("通过rightPush(K key, V value)方法向最右边添加元素:" + list);

        // 9、rightPush(K key, V pivot, V value)
        //  向集合中第一次出现第二个参数变量元素的右边添加第三个参数变量的元素值。
        redisTemplate.opsForList().rightPush("list","w","r");
        list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println("通过rightPush(K key, V pivot, V value)方法向最右边添加元素:" + list);

        // 10、rightPushAll(K key, V... values)
        //  向右边批量添加元素。
        redisTemplate.opsForList().rightPushAll("list","j","k");
        list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println("通过rightPushAll(K key, V... values)方法向最右边批量添加元素:" + list);

        // 11、rightPushAll(K key, Collection<V> values)
        //  以集合方式向右边添加元素。
        newList.clear();
        newList.add("g");
        newList.add("h");
        redisTemplate.opsForList().rightPushAll("list",newList);
        list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println("通过rightPushAll(K key, Collection<V> values)方法向最右边以集合方式批量添加元素:" + list);

        // 12、rightPushIfPresent(K key, V value)
        //  向已存在的集合中添加元素。
        redisTemplate.opsForList().rightPushIfPresent("presentList","d");
        list =  redisTemplate.opsForList().range("presentList",0,-1);
        System.out.println("通过rightPushIfPresent(K key, V value)方法已存在的集合向最右边添加元素:" + list);

        // 13、size(K key)
        //获取集合长度。
        long listLength = redisTemplate.opsForList().size("list");
        System.out.println("通过size(K key)方法获取集合list的长度为:" + listLength);

        // 14、leftPop(K key)
        // 移除集合中的左边第一个元素。
        Object popValue = redisTemplate.opsForList().leftPop("list");
        System.out.print("通过leftPop(K key)方法移除的元素是:" + popValue);
        list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println(",剩余的元素是:" + list);

        // 15、leftPop(K key, long timeout, TimeUnit unit)
        //  移除集合中左边的元素在等待的时间里,如果超过等待的时间仍没有元素则退出。
        popValue = redisTemplate.opsForList().leftPop("presentList",1, TimeUnit.SECONDS);
        System.out.print("通过leftPop(K key, long timeout, TimeUnit unit)方法移除的元素是:" + popValue);
        list =  redisTemplate.opsForList().range("presentList",0,-1);
        System.out.println(",剩余的元素是:" + list);

        // 16、rightPop(K key)
        // 移除集合中右边的元素。
        popValue = redisTemplate.opsForList().rightPop("list");
        System.out.print("通过rightPop(K key)方法移除的元素是:" + popValue);
        list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println(",剩余的元素是:" + list);

        // rightPop(K key, long timeout, TimeUnit unit)
        // 移除集合中右边的元素在等待的时间里,如果超过等待的时间仍没有元素则退出。
        popValue = redisTemplate.opsForList().rightPop("presentList",1, TimeUnit.SECONDS);
        System.out.print("通过rightPop(K key, long timeout, TimeUnit unit)方法移除的元素是:" + popValue);
        list =  redisTemplate.opsForList().range("presentList",0,-1);
        System.out.println(",剩余的元素是:" + list);

        // 18、rightPopAndLeftPush(K sourceKey, K destinationKey)
        //  移除集合中右边的元素,同时在左边加入一个元素。
        popValue = redisTemplate.opsForList().rightPopAndLeftPush("list","12");
        System.out.print("通过rightPopAndLeftPush(K sourceKey, K destinationKey)方法移除的元素是:" + popValue);
        list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println(",剩余的元素是:" + list);

        // 19、rightPopAndLeftPush(K sourceKey, K destinationKey, long timeout, TimeUnit unit)
        //  移除集合中右边的元素在等待的时间里,同时在左边添加元素,如果超过等待的时间仍没有元素则退出。
        popValue = redisTemplate.opsForList().rightPopAndLeftPush("presentList","13",1,TimeUnit.SECONDS);
        System.out.println("通过rightPopAndLeftPush(K sourceKey, K destinationKey, long timeout, TimeUnit unit)方法移除的元素是:" + popValue);
        list =  redisTemplate.opsForList().range("presentList",0,-1);
        System.out.print(",剩余的元素是:" + list);

        // 20、set(K key, long index, V value)
        //  在集合的指定位置插入元素,如果指定位置已有元素,则覆盖,没有则新增,超过集合下标+n则会报错。
        redisTemplate.opsForList().set("presentList",3,"15");
        list =  redisTemplate.opsForList().range("presentList",0,-1);
        System.out.print("通过set(K key, long index, V value)方法在指定位置添加元素后:" + list);

        // 21、remove(K key, long count, Object value)
        //  从存储在键中的列表中删除等于值的元素的第一个计数事件。
        //  count> 0:删除等于从左到右移动的值的第一个元素;
        //  count< 0:删除等于从右到左移动的值的第一个元素;
        //  count = 0:删除等于value的所有元素。
        long removeCount = redisTemplate.opsForList().remove("list",0,"w");
        list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println("通过remove(K key, long count, Object value)方法移除元素数量:" + removeCount);
        System.out.println(",剩余的元素:" + list);

        // 22、trim(K key, long start, long end)
        //  截取集合元素长度,保留长度内的数据。
        redisTemplate.opsForList().trim("list",0,5);
        list =  redisTemplate.opsForList().range("list",0,-1);
        System.out.println("通过trim(K key, long start, long end)方法截取后剩余元素:" + list);
    }

5、操作Hash

   @Test
    void testForHash() {
        // https://blog.csdn.net/suo082407128/article/details/86231433

        // 1、put(H key, HK hashKey, HV value)
        //   新增hashMap值。
        redisTemplate.opsForHash().put("hashValue","map1","map1-1");
        redisTemplate.opsForHash().put("hashValue","map2","map2-2");

        // 2、values(H key)
        //  获取指定变量中的hashMap值。
        List<Object> hashList = redisTemplate.opsForHash().values("hashValue");
        System.out.println("通过values(H key)方法获取变量中的hashMap值:" + hashList);

        // 3、entries(H key)
        //  获取变量中的键值对。
        Map<Object,Object> map = redisTemplate.opsForHash().entries("hashValue");
        System.out.println("通过entries(H key)方法获取变量中的键值对:" + map);

        // 4、get(H key, Object hashKey)
        //  获取变量中的指定map键是否有值,如果存在该map键则获取值,没有则返回null。
        Object mapValue = redisTemplate.opsForHash().get("hashValue","map1");
        System.out.println("通过get(H key, Object hashKey)方法获取map键的值:" + mapValue);

        // 5、hasKey(H key, Object hashKey)
        //  判断变量中是否有指定的map键。
        boolean hashKeyBoolean = redisTemplate.opsForHash().hasKey("hashValue","map3");
        System.out.println("通过hasKey(H key, Object hashKey)方法判断变量中是否存在map键:" + hashKeyBoolean);

        // 6、keys(H key)
        // 获取变量中的键。
        Set<Object> keySet = redisTemplate.opsForHash().keys("hashValue");
        System.out.println("通过keys(H key)方法获取变量中的键:" + keySet);

        // 7、size(H key)
        // 获取变量的长度。
        long hashLength = redisTemplate.opsForHash().size("hashValue");
        System.out.println("通过size(H key)方法获取变量的长度:" + hashLength);

        // 8、increment(H key, HK hashKey, double delta)
        // 使变量中的键以double值的大小进行自增长。
        double hashIncDouble = redisTemplate.opsForHash().increment("hashInc","map1",3);
        System.out.println("通过increment(H key, HK hashKey, double delta)方法使变量中的键以值的大小进行自增长:" + hashIncDouble);

        // 9、increment(H key, HK hashKey, long delta)
        // 使变量中的键以long值的大小进行自增长。
        long hashIncLong = redisTemplate.opsForHash().increment("hashInc","map2",6);
        System.out.println("通过increment(H key, HK hashKey, long delta)方法使变量中的键以值的大小进行自增长:" + hashIncLong);

        // 10、multiGet(H key, Collection<HK> hashKeys)
        // 以集合的方式获取变量中的值。
        List<Object> list = new ArrayList<Object>();
        list.add("map1");
        list.add("map2");
        List mapValueList = redisTemplate.opsForHash().multiGet("hashValue",list);
        System.out.println("通过multiGet(H key, Collection<HK> hashKeys)方法以集合的方式获取变量中的值:"+mapValueList);

        // 11、putAll(H key, Map<? extends HK,? extends HV> m)
        // 以map集合的形式添加键值对。
        Map newMap = new HashMap();
        newMap.put("map3","map3-3");
        newMap.put("map5","map5-5");
        redisTemplate.opsForHash().putAll("hashValue",newMap);
        map = redisTemplate.opsForHash().entries("hashValue");
        System.out.println("通过putAll(H key, Map<? extends HK,? extends HV> m)方法以map集合的形式添加键值对:" + map);

        // 12、putIfAbsent(H key, HK hashKey, HV value)
        // 如果变量值存在,在变量中可以添加不存在的的键值对,如果变量不存在,则新增一个变量,同时将键值对添加到该变量。
        redisTemplate.opsForHash().putIfAbsent("hashValue","map6","map6-6");
        map = redisTemplate.opsForHash().entries("hashValue");
        System.out.println("通过putIfAbsent(H key, HK hashKey, HV value)方法添加不存在于变量中的键值对:" + map);

        // 13、scan(H key, ScanOptions options)
        // 匹配获取键值对,ScanOptions.NONE为获取全部键对,ScanOptions.scanOptions().match("map1").build()
        // 匹配获取键位map1的键值对,不能模糊匹配。
        Cursor<Map.Entry<Object,Object>> cursor = redisTemplate.opsForHash().scan("hashValue",ScanOptions.scanOptions().match("map1").build());
        //Cursor<Map.Entry<Object,Object>> cursor = redisTemplate.opsForHash().scan("hashValue",ScanOptions.NONE);
        while (cursor.hasNext()){
            Map.Entry<Object,Object> entry = cursor.next();
            System.out.println("通过scan(H key, ScanOptions options)方法获取匹配键值对:" + entry.getKey() + "---->" + entry.getValue());
        }

        // 14、delete(H key, Object... hashKeys)
        //   删除变量中的键值对,可以传入多个参数,删除多个键值对。
        redisTemplate.opsForHash().delete("hashValue","map1","map2");
        map = redisTemplate.opsForHash().entries("hashValue");
        System.out.println("通过delete(H key, Object... hashKeys)方法删除变量中的键值对后剩余的:" + map);

    }

6、操作Set

   @Test
    void testForSet() {
        // https://blog.csdn.net/suo082407128/article/details/86231681
        
        //--1 向变量中批量添加值。
        redisTemplate.opsForSet().add("setValue","A","B","C","B","D","E","F");

        //--2 获取集合中元素的个数。
        Long size = redisTemplate.opsForSet().size("setValue");
        System.out.println("通过size(K key)方法获取变量中元素值的长度:" + size);


        //--3 获取变量中的值。
        Set setValue = redisTemplate.opsForSet().members("setValue");
        System.out.println("通过members(K key)方法获取变量中的元素值:" + setValue);

        //--4 随机获取变量中的元素。
        Object randomMember = redisTemplate.opsForSet().randomMember("setValue");
        System.out.println("通过randomMember(K key)方法随机获取变量中的元素:" + randomMember);

        //--5 随机获取变量中指定个数的元素。
        List randomMembers = redisTemplate.opsForSet().randomMembers("setValue",2);
        System.out.println("通过randomMembers(K key, long count)方法随机获取变量中指定个数的元素:" + randomMembers);

        //--6 检查给定的元素是否在变量中。
        boolean isMember = redisTemplate.opsForSet().isMember("setValue","A");
        System.out.println("通过isMember(K key, Object o)方法检查给定的元素是否在变量中:" + isMember);

        //--7 转移变量的元素值到目的变量。
        boolean isMove = redisTemplate.opsForSet().move("setValue","A","destSetValue");
        if(isMove){
            Set set = redisTemplate.opsForSet().members("setValue");
            System.out.print("通过move(K key, V value, K destKey)方法转移变量的元素值到目的变量后的剩余元素:" + set);
            set = redisTemplate.opsForSet().members("destSetValue");
            System.out.println(",目的变量中的元素值:" + set);
        }

        //--8 弹出变量中的元素。
        Object popValue = redisTemplate.opsForSet().pop("setValue");
        System.out.print("通过pop(K key)方法弹出变量中的元素:" + popValue);
        Set set = redisTemplate.opsForSet().members("setValue");
        System.out.println(",剩余元素:" + set);

        //--9 批量移除变量中的元素。
        long removeCount = redisTemplate.opsForSet().remove("setValue","E","F","G");
        System.out.print("通过remove(K key, Object... values)方法移除变量中的元素个数:" + removeCount);
        set = redisTemplate.opsForSet().members("setValue");
        System.out.println(",剩余元素:" + set);

        //--10 匹配获取键值对,ScanOptions.NONE为获取全部键值对;
        // ScanOptions.scanOptions().match("C").build()匹配获取键位map1的键值对,不能模糊匹配。
        //Cursor<Object> cursor = redisTemplate.opsForSet().scan("setValue", ScanOptions.NONE);
        Cursor<Object> cursor = redisTemplate.opsForSet().scan("setValue", ScanOptions.scanOptions().match("C").build());
        while (cursor.hasNext()){
            Object object = cursor.next();
            System.out.println("通过scan(K key, ScanOptions options)方法获取匹配的值:" + object);
        }

        //--11 通过集合求差值。
        List list = new ArrayList();
        list.add("destSetValue");
        Set differenceSet = redisTemplate.opsForSet().difference("setValue",list);
        System.out.println("通过difference(K key, Collection<K> otherKeys)方法获取变量中与给定集合中变量不一样的值:" + differenceSet);

        //--12 通过给定的key求2个set变量的差值。
        differenceSet = redisTemplate.opsForSet().difference("setValue","destSetValue");
        System.out.println("通过difference(K key, Collection<K> otherKeys)方法获取变量中与给定变量不一样的值:" + differenceSet);

        //--13 将求出来的差值元素保存。
        redisTemplate.opsForSet().differenceAndStore("setValue","destSetValue","storeSetValue");
        set = redisTemplate.opsForSet().members("storeSetValue");
        System.out.println("通过differenceAndStore(K key, K otherKey, K destKey)方法将求出来的差值元素保存:" + set);

        //--14 将求出来的差值元素保存。
        redisTemplate.opsForSet().differenceAndStore("setValue",list,"storeSetValue");
        set = redisTemplate.opsForSet().members("storeSetValue");
        System.out.println("通过differenceAndStore(K key, Collection<K> otherKeys, K destKey)方法将求出来的差值元素保存:" + set);

        //--15 获取去重的随机元素。
        set = redisTemplate.opsForSet().distinctRandomMembers("setValue",2);
        System.out.println("通过distinctRandomMembers(K key, long count)方法获取去重的随机元素:" + set);

        //--16 获取2个变量中的交集。
        set = redisTemplate.opsForSet().intersect("setValue","destSetValue");
        System.out.println("通过intersect(K key, K otherKey)方法获取交集元素:" + set);

        //--17 获取多个变量之间的交集。
        set = redisTemplate.opsForSet().intersect("setValue",list);
        System.out.println("通过intersect(K key, Collection<K> otherKeys)方法获取交集元素:" + set);

        //--18 获取2个变量交集后保存到最后一个参数上。
        redisTemplate.opsForSet().intersectAndStore("setValue","destSetValue","intersectValue");
        set = redisTemplate.opsForSet().members("intersectValue");
        System.out.println("通过intersectAndStore(K key, K otherKey, K destKey)方法将求出来的交集元素保存:" + set);

        //--19 获取多个变量的交集并保存到最后一个参数上。
        redisTemplate.opsForSet().intersectAndStore("setValue",list,"intersectListValue");
        set = redisTemplate.opsForSet().members("intersectListValue");
        System.out.println("通过intersectAndStore(K key, Collection<K> otherKeys, K destKey)方法将求出来的交集元素保存:" + set);

        //--20 获取2个变量的合集。
        set = redisTemplate.opsForSet().union("setValue","destSetValue");
        System.out.println("通过union(K key, K otherKey)方法获取2个变量的合集元素:" + set);

        //--21 获取多个变量的合集。
        set = redisTemplate.opsForSet().union("setValue",list);
        System.out.println("通过union(K key, Collection<K> otherKeys)方法获取多个变量的合集元素:" + set);

        //--22 获取2个变量合集后保存到最后一个参数上。
        redisTemplate.opsForSet().unionAndStore("setValue","destSetValue","unionValue");
        set = redisTemplate.opsForSet().members("unionValue");
        System.out.println("通过unionAndStore(K key, K otherKey, K destKey)方法将求出来的交集元素保存:" + set);

        //--23 获取多个变量的合集并保存到最后一个参数上。
        redisTemplate.opsForSet().unionAndStore("setValue",list,"unionListValue");
        set = redisTemplate.opsForSet().members("unionListValue");
        System.out.println("通过unionAndStore(K key, Collection<K> otherKeys, K destKey)方法将求出来的交集元素保存:" + set);

    }

7、操作Geo

@SpringBootTest
public class RedisGeoTest {

    @Autowired
    RedisTemplate redisTemplate;

    @Test
    void testAddGeo() {
        //--1 把位置信息存入hash
        UserNews userNews1 = new UserNews();
        userNews1.setId(1L);
        // 116.307594,40.048617
        userNews1.setLongitude(116.307594);
        userNews1.setLatitude(40.048617);

        RedisGeoCommands.GeoLocation<Long> longGeoLocation1 = new RedisGeoCommands.GeoLocation<>(userNews1.getId(), new Point(userNews1.getLongitude(), userNews1.getLatitude()));

        redisTemplate.opsForGeo().add("geo_user", longGeoLocation1);

        //
        UserNews userNews2 = new UserNews();
        userNews2.setId(2L);
        // 116.306193,40.045814
        userNews2.setLongitude(116.306193);
        userNews2.setLatitude(40.045814);

        RedisGeoCommands.GeoLocation<Long> longGeoLocation2 = new RedisGeoCommands.GeoLocation<>(
                userNews2.getId(), new Point(userNews2.getLongitude(), userNews2.getLatitude()));

        redisTemplate.opsForGeo().add("geo_user", longGeoLocation2);

        //
        UserNews userNews3 = new UserNews();
        userNews3.setId(3L);
        // 116.30551,40.047899
        userNews3.setLongitude(116.30551);
        userNews3.setLatitude(40.047899);

        RedisGeoCommands.GeoLocation<Long> longGeoLocation3 = new RedisGeoCommands.GeoLocation<>(
                userNews3.getId(), new Point(userNews3.getLongitude(), userNews3.getLatitude()));

        redisTemplate.opsForGeo().add("geo_user", longGeoLocation3);

        Long geo_size = redisTemplate.opsForZSet().size("geo_user");
        System.out.println("geo_size="+geo_size);

    }

    @Test
    void testGeoPosition() {
        //--2 获取某个用户的地理位置信息

        List<Point> userList = redisTemplate.opsForGeo().position("geo_user", 2L, 3L);
        userList.forEach(user->{
            System.out.println(user);
        });
    }

    @Test
    void testGeoDistance() {
        //--3 获取某两个用户之间的距离

        Distance geo_distance = redisTemplate.opsForGeo().distance("geo_user", 2L, 3L);
        System.out.println(geo_distance);

        Distance geo_distance2 = redisTemplate.opsForGeo().distance("geo_user", 2L, 3L, Metrics.KILOMETERS);
        System.out.println(geo_distance2);
    }

    @Test
    void testGeoCircle() {
        //--4 根据一个点,获取方圆一定范围内的所有用户信息

        Point center = new Point(116.306965,40.047554);
        Distance distance = new Distance(2, Metrics.KILOMETERS);

        Circle circle = new Circle(center, distance);

        GeoResults<RedisGeoCommands.GeoLocation<Long>> users = redisTemplate.opsForGeo().radius("geo_user", circle);
        List<GeoResult<RedisGeoCommands.GeoLocation<Long>>> contents = users.getContent();
        contents.forEach(content->{
            System.out.println(content);
            RedisGeoCommands.@NonNull GeoLocation<Long> user = content.getContent();
            System.out.println("userid="+user.getName());
        });
    }

    @Test
    void testGeoCircle2() {
        Point center = new Point(116.306965,40.047554);
        Distance distance = new Distance(2, Metrics.KILOMETERS);

        Circle circle = new Circle(center, distance);

        // 包含距离、包含坐标、升序排列、只返回5个
        RedisGeoCommands.GeoRadiusCommandArgs args = RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs()
                .includeDistance()
                .includeCoordinates()
                .sortAscending()
                .limit(5);

        GeoResults<RedisGeoCommands.GeoLocation<Long>> users = redisTemplate.opsForGeo().radius("geo_user", circle, args);
        List<GeoResult<RedisGeoCommands.GeoLocation<Long>>> contents = users.getContent();
        contents.forEach(content->{
            System.out.println(content);

            RedisGeoCommands.@NonNull GeoLocation<Long> user = content.getContent();
            System.out.println(user);
        });
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
class UserNews {
    private Long id;                // 用户ID
    private Double longitude;       // 经度
    private Double latitude;        // 纬度

}