此命令是用来对list,set或sorted中元素排序，具体参考可以去参考我之前写的Redis命令详解

//基本测试数据导入
//lpush listNumber 8.4 13 14 10.5 4 19.6 10 14 5.2 10 3 2.5 7 4.7 10 11.2 8 2.2 15.7 20.9
//lpush listString remini Momen Pledg Memo Tende Biode Revie silen Romanti AusL Simpl Promis Romanti Bautifu smil Initiall sunse lemo firs Chaffere

/\*参数介绍  
    查询条件：  
        SortQuery  
        使用SortQueryBuilder对象builder()方法创建 SortQuery  
        参数：  
            by()    和Redis命令中by一样，通过引用外部key来排序  
            get()   获取外部key的值  
            noSort() 不使用by()，就是不通过引用外部key来排序；注by()和noSort()只能存在一个  
            limit()  分页和mysql写法一样  
            order()   默认asc从小到大  desc从大到小  
                    SortParameters.Order.DESC  
                    SortParameters.Order.ASC  
            alphabetical(true)  当排序的集合中存在字符串则需要使用此属性  
            build()  构建出对象  
 \*/  
//基本的Sort使用  
//List<V> sort(SortQuery<K> query);  
@Test  
void redisTemplateSortA() {  
    //对应Redis命令：sort listString limit 0 3 desc alpha  
    //具体为啥查询出来和在Redis查询出来的不一样，也没有细了解  
    SortQuery<String> sortQuery = SortQueryBuilder.sort("listString")  
            .noSort()  
            .limit(0, 3)  
            .order(SortParameters.Order.DESC)  
            .alphabetical(true)  
            .build();  
    List<String> sort = stringRedisTemplate.sort(sortQuery);  
    sort.forEach(System.out::println);  
}

//通过外部key来排序  
@Test  
void redisTemplateSortB() {  
    //测试数据  
    //lpush mylist 20 15 18  
    //set n\_20 b  
    //set n\_15 a  
    //set n\_18 c  
    SortQuery<String> sortQuery = SortQueryBuilder.sort("mylist")  
            .by("n\_\*")  
            .order(SortParameters.Order.DESC)  
            .alphabetical(true)  
            .build();  
    List<String> sort = stringRedisTemplate.sort(sortQuery);  
    sort.forEach(System.out::println);  
}

Sort方法的简单使用

2：ValueOperations之String类型操作

基本方法：
方法：void set(K key, V value);
方法：void set(K key, V value, long offset);
# 对应命令：setrange key offset value
方法：void set(K key, V value, Duration timeout)
方法：void set(K key, V value, long timeout, TimeUnit unit);
# 对应命令：psetex key milliseconds value
# 设置K-V键值的String类型
# offset:偏移量 timeout:失效时间 unit:失效时间类型
# 时间取值参考“redisTemplate之Key操作”
方法：Boolean setIfAbsent(K key, V value);
方法：Boolean setIfAbsent(K key, V value, Duration timeout)
方法：Boolean setIfAbsent(K key, V value, long timeout, TimeUnit unit);
# 设置键值，若当前键存在则不在更新覆盖
方法：Boolean setIfPresent(K key, V value);
方法：Boolean setIfPresent(K key, V value, Duration timeout)
方法：Boolean setIfPresent(K key, V value, long timeout, TimeUnit unit);
# 设置键值，若当前键存在则更新覆盖，key原本不存在则返回false
方法：V get(Object key);
方法：String get(K key, long start, long end);
# 对应命令：getrange key start end
# 获取指定的键，start和end是获取值里的指定部分
方法：Integer append(K key, String value);
# 对指定的key后面追加指定的值
方法：Long increment(K key);
方法：Long increment(K key, long delta);
方法：Double increment(K key, double delta);
# 将key中储存的数字值增加1，或增加指定值
方法：Long decrement(K key);
方法：Long decrement(K key, long delta);
# 将key中储存的数字值减1，或减指定值
方法：V getAndSet(K key, V value);
# 设置更新key值，设置前先把原有的值返回出来，并设置新的值
方法：Long size(K key);
# 对应命令：strlen key
# 获取指定key所储存的字符串值的长度
方法：void multiSet(Map map);
# 批量设置键值
方法：List multiGet(Collection keys);
# 批量根据键获取值
方法：RedisOperations getOperations();
# 其它公共方法，就和RedisTemplate下的公共方法差不多
注：下面的位图方法操作放在后面介绍
方法：Boolean setBit(K key, long offset, boolean value);
方法：Boolean getBit(K key, long offset);
方法：List bitField(K key, BitFieldSubCommands subCommands);

ValueOperations基本方法

//注入键值都为String对象的RedisTemplate对象
@Autowired
private StringRedisTemplate stringRedisTemplate;

@Test  
void redisTemplateBase() {  
    //获取基本的 ValueOperations 操作对象（操作Redis的String类型）  
    ValueOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();  
    //设置一个普通的键值  命令：set message "Hello World"  
    opsForValue.set("message", "Hello World");  
    //设置一个普通的键值，存在偏移的设置  
    opsForValue.set("messages", "Redis", 6);  
    //设置一个普通键值，并设置过期时间60秒  
    opsForValue.set("name", "zhangsan", Duration.ofSeconds(6000));  
    //获取key为“name”的值  
    opsForValue.get("name");  
    //获取key为“message”的值，并指定偏移，打印为 "llo Wor"  
    opsForValue.get("message", 2, 8);  
    //在key为“message”的值后面追加 " Good" 最终的message为"Hello World Good"  
    opsForValue.append("message", " Good");  
    opsForValue.set("age", "22");  
    opsForValue.set("salary", "1000.3");  
    //将key中储存的数字值增加 1 或者后面的增加指定值  
    Long age1 = opsForValue.increment("age");  
    Long age2 = opsForValue.increment("age", 2L);  
    Double salary = opsForValue.increment("salary", 3.4D);  
    //将key中储存的数字值减 1 或减去指定值  
    Long age3 = opsForValue.decrement("age");  
    Long age4 = opsForValue.decrement("age", 2L);  
    //先获取age值，并把age值更改为23  
    String age = opsForValue.getAndSet("age", "23");  
    //获取指定key所储存的字符串值的长度 此时获取为16  
    Long message = opsForValue.size("message");  
    //setIfAbsent只能新增操作，setIfPresent只能更新操作  
    Boolean aBoolean1 = opsForValue.setIfAbsent("address", "anhui");  
    Boolean aBoolean2 = opsForValue.setIfPresent("address", "anhui");  
    Map<String,String> maps = new HashMap<>();  
    maps.put("keyA","valueA");maps.put("keyB","valueB");maps.put("keyC","valueC");  
    //批量设置String的键值  
    opsForValue.multiSet(maps);  
    //批量获取值  
    List<String> strings = opsForValue.multiGet(Arrays.asList("keyA", "keyB", "keyC"));  
    //其它公共方法操作，就和RedisTemplate下的公共方法差不多  
    RedisOperations<String, String> operations = opsForValue.getOperations();  
}

3：HashOperations之Hash类型操作

基本方法：
方法：void put(H key, HK hashKey, HV value);
# 往Hash表中插入K-V
方法：void putAll(H key, Map m);
# 往Hash表中批量插入K-V
方法：HV get(H key, Object hashKey);
# 获取Hash表中指定key
方法：List multiGet(H key, Collection hashKeys);
# 批量获取Hash表中的key值
方法：Long lengthOfValue(H key, HK hashKey);
# 获取Hash表中其中一个key里的值的字符长度
方法：Boolean putIfAbsent(H key, HK hashKey, HV value);
# 往Hash表中插入K-V（前提当前hash表中的key不存在，存在返回false，不做操作）
方法：Boolean hasKey(H key, Object hashKey);
# 判断Hash表中是否包含此key
方法：Long size(H key);
# 获取Hash表中的key数量
方法：Set keys(H key);
方法：List values(H key);
# 获取Hash表中全部key和全部value
方法：Long increment(H key, HK hashKey, long delta);
方法：Double increment(H key, HK hashKey, double delta);
# 对Hash表中指定key的值（整数、浮点数）的累加和相减（负数代表减）
方法：Cursor> scan(H key, ScanOptions options);
# 迭代Hash表数据
方法：Long delete(H key, Object… hashKeys);
# 删除指定Hash表中的key

HashOperations基本方法

//注入键值都为String对象的RedisTemplate对象
@Autowired
private StringRedisTemplate stringRedisTemplate;

@Test  
void redisTemplateBase() {  
    //获取基本的 HashOperations 操作对象（操作Redis的Hash类型）  
    HashOperations<String, Object, Object> opsForHash = stringRedisTemplate.opsForHash();

    //往Student的Hash表中插入一个name为“zhangsan”  
    opsForHash.put("Student", "name", "zhangsan");  
    //批量往Student的Hash表中插入age、salary  
    Map<String, String> map = new HashMap<>();  
    map.put("age", "22");  
    map.put("salary", "3000.88");  
    opsForHash.putAll("Student", map);  
    //获取Student的Hash中key为name的值  
    Object name = opsForHash.get("Student", "name");  
    //往Student的Hash表中插入name为list的值，注：若name的key存在则无法插入，也无法更新，用于插入不存在的key  
    Boolean aBoolean = opsForHash.putIfAbsent("Student", "name", "lisi");  
    //获取当前Student的HAsh表中的key数量  
    Long stuSize = opsForHash.size("Student");  
    //获取Student的Hash表中的全部key和value  
    Set<Object> stuKeys = opsForHash.keys("Student");  
    List<Object> stuValue = opsForHash.values("Student");  
    //获取Student的Hash中key为name的字符长度  
    Long aLong = opsForHash.lengthOfValue("Student", "name");  
    //获取Student的Hash中是否存在key为name的数据  
    Boolean aBoolean1 = opsForHash.hasKey("Student", "name");  
    //为Hash中某个key(整数、小数)累加指定的值；为负数就相减  
    Long increment = opsForHash.increment("Student", "age", -30L);  
    Double increment1 = opsForHash.increment("Student", "salary", -5000D);  
    //批量获取Hash表中指定多个key的值  
    List<Object> objects = opsForHash.multiGet("Student", Arrays.asList("name", "age"));  
    //获取基本操作key对象  
    RedisOperations<String, ?> operations = opsForHash.getOperations();  
    //删除Hash表中指定key  
    Long delName = opsForHash.delete("Student", "name");

    //迭代，具体参考hcsan  
    //测试数据：hmset testHash k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7  
    ScanOptions build = ScanOptions.scanOptions()  
            .count(1)  
            .match("k\*") //过滤符合指定的key   \*代表以 k 开头的键  
            .build();  
    //ScanOptions.NONE迭代全部  
    Cursor<Map.Entry<Object, Object>> kv = opsForHash.scan("testHash", ScanOptions.NONE);  
    System.out.println(kv.getCursorId());//获取光标ID  
    System.out.println(kv.getPosition());//获取当前迭代的位置  
    System.out.println(kv.isClosed());   //是否已关闭  
    while (kv.hasNext()) {  
        Map.Entry<Object, Object> next = kv.next();  
        System.out.println(next.getKey() + ":" + next.getValue());  
    }  
}

4：ListOperations之List类型操作

基本方法：
方法：Long leftPush(K key, V value);
# 往集合头部添加元素
方法：Long leftPushAll(K key, V… values);
# 往集合头部批量添加元素
方法：Long leftPushAll(K key, Collection values);
# 往集合头部批量添加元素，接收集合对象
方法：Long leftPush(K key, V pivot, V value);
# 在集合指定元素pivot前插入value元素左往右
方法：Long leftPushIfPresent(K key, V value);
# 在指定集合内部添加元素（保证当前元素存在）
方法：V leftPop(K key);
# 从集合头部弹出一个元素
方法：V leftPop(K key, long timeout, TimeUnit unit);
方法：V leftPop(K key, Duration timeout)
# 从集合头部弹出一个元素（阻塞）

 ## 注：还有尾插元素，以上面方法为主，把left换为right及是尾插法

方法：V rightPopAndLeftPush(K sourceKey, K destinationKey);
方法：V rightPopAndLeftPush(K sourceKey, K destinationKey, Duration timeout)
方法：V rightPopAndLeftPush(K sourceKey, K destinationKey, long timeout, TimeUnit unit)
# 从sourceKey集合尾部弹出一个元素插入到destinationKey集合头部（后面参数为阻塞参数）

方法：List range(K key, long start, long end);
# 获取集合中指定范围的元素
方法：V index(K key, long index);
# 获取集合中指定下标元素的值
方法：Long indexOf(K key, V value);
# 通过元素值查找当期位置坐标（从左往右）
方法：Long lastIndexOf(K key, V value);
# 通过元素值查找当期位置坐标（从右往左）
方法：Long size(K key);
# 获取集合的全部元素大小
方法：void set(K key, long index, V value);
# 更新指定下标的元素值
方法：void trim(K key, long start, long end);
# 对集合中指定范围的元素截取（并会保存截取后的元素）
方法：Long remove(K key, long count, Object value);
# 从集合key中删除前count个值等于value的元素 ,返回删除的元素个数

ListOperations基本方法

//注入键值都为String对象的RedisTemplate对象  
@Autowired  
private StringRedisTemplate stringRedisTemplate;

@Test  
void redisTemplateBase() {  
    //获取基本的 HashOperations 操作对象（操作Redis的Hash类型）  
    ListOperations<String, String> opsForList = stringRedisTemplate.opsForList();

    //在names集合头部插入zhangsan；返回插入成功后集合里的元素总数  
    Long aLong = opsForList.leftPush("names", "zhangsan");  
    //在names集合头部批量插入lisi、mazi；返回插入成功后集合里的元素总数  
    Long aLong1 = opsForList.leftPushAll("names", "lisi", "mazi");  
    //在names集合头部批量插入一个集合对象wangwu、wangwu；返回插入成功后集合里的元素总数  
    Long aLong2 = opsForList.leftPushAll("names", Arrays.asList("wangwu", "xiehao"));  
    //在names集合中的lisi元素前面插入 WeiHua 元素  
    Long aLong3 = opsForList.leftPush("names", "lisi", "WeiHua");  
    //在names集合上添加“mazi”元素，返回元素个数，0代表未添加（若集合names不存在则无法插入）  
    Long aLong4 = opsForList.leftPushIfPresent("names", "mazi");  
    //移除names集合中的头部第一个元素  
    String s = opsForList.leftPop("names");  
    //移除names集合中的头部第一个元素,延迟阻塞 参考命令blpop key \[key ...\] timeout  
    String s1 = opsForList.leftPop("names", 1000L, TimeUnit.SECONDS);  
    //移除names集合中的头部第一个元素,延迟阻塞 参考命令blpop key \[key ...\] timeout  
    String s2 = opsForList.leftPop("names", Duration.ofSeconds(30));

      //### 还有尾插元素，以上面方法为主，把left换为right及是尾插法

    //案例示例命令：   LPUSH testNames xulingyue  wangyanke xiaogege  
    //从testNames集合尾部弹出一个元素插入到names集合头部，返回添加的元素;;后两个为阻塞版  
    String s3 = opsForList.rightPopAndLeftPush("testNames", "names");  
    String s4 = opsForList.rightPopAndLeftPush("testNames", "names", Duration.ofSeconds(60L));  
    String s5 = opsForList.rightPopAndLeftPush("testNames", "names", 60L,TimeUnit.SECONDS);

    //查询集合里全部元素  
    List<String> names = opsForList.range("names", 0L, -1L);  
    //获取names集合里坐标为3的元素   0开始  
    String names1 = opsForList.index("names", 3L);  
    //获取names集合里指定元素的坐标位置，头部查询  
    Long aLong5 = opsForList.indexOf("names", "mazi");  
    //获取names集合里指定元素的坐标位置，尾部查询  
    Long aLong6 = opsForList.lastIndexOf("names", "mazi");  
    //获取集合names内的元素数量  
    Long sizes = opsForList.size("names");  
    //修改集合names下坐标为3的元素为”aha“  
    opsForList.set("names", 3L, "aha");  
    //截取集合指定范围的元素  
    opsForList.trim("names",2L,4L);  
    //从集合key中删除前count个值等于element的元素 ,返回删除的元素个数  
    Long remove = opsForList.remove("names", 2L, "aha");  
}

5：SetOperations之Set类型操作

基本方法：
方法：Long add(K key, V… values);
# 往集合中添加一个或多个元素

差异方法

方法：Set difference(K key, K otherKey);
方法：Set difference(Collection keys);
方法：Set difference(K key, Collection otherKeys);
方法：Long differenceAndStore(K key, K otherKey, K destKey);
方法：Long differenceAndStore(Collection keys, K destKey);
方法：Long differenceAndStore(K key, Collection otherKeys, K destKey);
# 返回第一个集合与其它集合之间的差异；说白就是第一个集合的某个元素在其它集合都不存在则这个元素会被返回，
方法：Set intersect(K key, K otherKey);
方法：Set intersect(Collection keys);
方法：Set intersect(K key, Collection otherKeys);
方法：Long intersectAndStore(K key, K otherKey, K destKey);
方法：Long intersectAndStore(Collection keys, K destKey);
方法：Long intersectAndStore(K key, Collection otherKeys, K destKey);
# 返回第一个集合与其它集合之间的交集；说白就是第一个集合的某个元素在其它集合都存在则这个元素会被返回，(交集)
方法：Set union(K key, K otherKey);
方法：Set union(Collection keys);
方法：Set union(K key, Collection otherKeys);
方法：Long unionAndStore(K key, K otherKey, K destKey);
方法：Long unionAndStore(Collection keys, K destKey);
方法：Long unionAndStore(K key, Collection otherKeys, K destKey);
# 用于返回所有给定集合的并集
方法：Long size(K key);
# 返回集合中的元素数量
方法：Set members(K key);
# 返回集合中全部元素
方法：Boolean isMember(K key, Object o);
# 返回集合中是否存在此元素
方法：V randomMember(K key);
# 随机返回集合中一个元素
方法：List randomMembers(K key, long count);
# 随机返回集合中多个元素（可能重复）
方法：Set distinctRandomMembers(K key, long count);
# 随机返回集合中多个元素（不重复）
方法：Boolean move(K key, V value, K destKey);
# 将一个集合中的某个元素弹出放到另一个集合中
方法：Cursor scan(K key, ScanOptions options);
# 遍历集合
方法：RedisOperations getOperations();
# 返回基本操作对象
方法：Long remove(K key, Object… values);
# 从集合中弹出指定的多个元素
方法：V pop(K key);
# 随机从集合中弹出一个元素删除
方法：List pop(K key, long count);
# 随机从集合中弹出多个元素删除

SetOperations基本方法

//注入键值都为String对象的RedisTemplate对象
@Autowired
private StringRedisTemplate stringRedisTemplate;

@Test  
void redisTemplateBase() {  
    //获取基本的 SetOperations 操作对象（操作Redis的Set类型）  
    SetOperations<String, String> opsForSet = stringRedisTemplate.opsForSet();

    //往ChinaA的Set集合中添加 北京、上海、安徽、河南、广东、江苏；并返回添加成功的个数（已存在的不会被添加）；ChinaB一样  
    Long add1 = opsForSet.add("ChinaA", "Beijing", "Shanghai", "Anhui", "Henan", "Guangdong", "Jiangsu");  
    Long add2 = opsForSet.add("ChinaB", "Shanxi", "Shanghai", "Fujian", "Anhui", "Zhejiang");  
    //===================================================================  
    //差异比较  
    //=====返回第一个集合与其它集合之间的差异；说白就是第一个集合的某个元素在其它集合都不存在则这个元素会被返回，  
    // key1 = {a,b,c,d}  
    // key2 = {c}  
    // key3 = {a,c,e}  
    // SDIFF key1 key2 key3  = {b,d}  
    //第一个集合和其它集合比较差异，并返回有差异的元素  
    Set<String> difference1 = opsForSet.difference("ChinaA", "ChinaB");  
    Set<String> difference2 = opsForSet.difference("ChinaA", Arrays.asList("ChinaB"));  
    Set<String> difference3 = opsForSet.difference(Arrays.asList("ChinaA", "ChinaB"));  
    //第一个集合和其它集合比较差异，并把差异的元素存放到指定的集合中（注：存放差异的集合会把原来的数据覆盖）  
    Long aLong1 = opsForSet.differenceAndStore("ChinaA", "ChinaB", "diffStoreA");  
    Long aLong2 = opsForSet.differenceAndStore("ChinaA", Arrays.asList("ChinaB"), "diffStoreB");  
    Long aLong3 = opsForSet.differenceAndStore(Arrays.asList("ChinaA", "ChinaB"), "diffStoreC");  
    //=====返回第一个集合与其它集合之间的交集；说白就是第一个集合的某个元素在其它集合都存在则这个元素会被返回，  
    // key1 = {a,b,c,d}  
    // key2 = {c}  
    // key3 = {a,c,e}  
    // SINTER key1 key2 key3 = {c}  
    // 使用上和上面6个方法一样，只不过这个是获取它的 交集  
    Set<String> intersect1 = opsForSet.intersect("ChinaA", "ChinaB");  
    Set<String> intersect2 = opsForSet.intersect("ChinaA", Arrays.asList("ChinaB"));  
    Set<String> intersect3 = opsForSet.intersect(Arrays.asList("ChinaA", "ChinaB"));  
    Long iLong1 = opsForSet.intersectAndStore("ChinaA", "ChinaB", "interStoreA");  
    Long iLong2 = opsForSet.intersectAndStore("ChinaA", Arrays.asList("ChinaB"), "interStoreB");  
    Long iLong3 = opsForSet.intersectAndStore(Arrays.asList("ChinaA", "ChinaB"), "interStoreC");  
    //=====用于返回所有给定集合的并集  
    // key1 = {a,b,c,d}  
    // key2 = {c}  
    // key3 = {a,c,e}  
    // sunion key1 key2 key3 = {a,b,c,d,e}  
    // 使用上和上面12个方法一样，只不过这个是获取它的 并集  
    Set<String> union1 = opsForSet.union("ChinaA", "ChinaB");  
    Set<String> union2 = opsForSet.union("ChinaA", Arrays.asList("ChinaB"));  
    Set<String> union3 = opsForSet.union(Arrays.asList("ChinaA", "ChinaB"));  
    Long uLong1 = opsForSet.unionAndStore("ChinaA", "ChinaB", "unionStoreA");  
    Long uLong2 = opsForSet.unionAndStore("ChinaA", Arrays.asList("ChinaB"), "unionStoreB");  
    Long uLong3 = opsForSet.unionAndStore(Arrays.asList("ChinaA", "ChinaB"), "unionStoreC");  
    //===================================================================  
    //返回集合中全部元素个数  
    Long size = opsForSet.size("ChinaA");  
    //返回集合中全部元素的set集合  
    Set<String> chinaA = opsForSet.members("ChinaA");  
    //判断集合中是否存在“Shanghai”这个元素  
    Boolean member = opsForSet.isMember("ChinaA", "Shanghai");  
    //随机返回集合中一个或多个元素(注意返回多个元素可能会存在重复的)  
    String s = opsForSet.randomMember("ChinaA");  
    List<String> strings = opsForSet.randomMembers("ChinaA", 3);  
    //随机返回集合中一个或多个元素(注意返回多个元素不会存在重复的)  
    Set<String> chinaA2 = opsForSet.distinctRandomMembers("ChinaA", 3L);  
    //将ChinaA集合里的Beijing弹出放到ChinaB集合中（若A集合弹出元素在B集合存在，那么A集合元素也将被清理）  
    Boolean move = opsForSet.move("ChinaA", "Shanghai", "ChinaB");  
    //带条件的获取指定元素  
    ScanOptions scanOptions = ScanOptions.scanOptions().match("\*e\*").count(2L).build();  
    Cursor<String> chinaA1 = opsForSet.scan("ChinaA", ScanOptions.NONE);  
    while (chinaA1.hasNext()){ System.out.println(chinaA1.next()); }  
    //获取RedisTemplate基本操作方法对象  
    RedisOperations<String, String> operations = opsForSet.getOperations();  
    //双重ChinaA集合中指定的元素，返回删除成功的元素个数  
    Long remove = opsForSet.remove("ChinaA", "Guangdong", "Beijing", "LboLa");  
    //从集合ChinaA中随机弹出(删除)一个或者多个元素，并返回被弹出的元素名称  
    String pop1 = opsForSet.pop("ChinaA");  
    List<String> pop2 = opsForSet.pop("ChinaA", 2L);  
}

6：ZSetOperations之SortedSet类型操作

　　关于SortedSet里一些不是好理解的命令可以参考官方文档或者参考我之前写的 Redis命令大全 里的有序集合

基本方法：
方法：Boolean add(K key, V value, double score);
# 为有序集合中添加一个元素和分数
方法：Long add(K key, Set> tuples);
# 为有序集合中批量添加一个元素和分数
方法：Boolean addIfAbsent(K key, V value, double score);
# 为有序集合中添加一个元素和分数（存在此元素则不执行当前添加）
方法：Long addIfAbsent(K key, Set> tuples);
# 为有序集合中批量添加一个元素和分数（存在此元素则不执行当前添加）
方法：Double incrementScore(K key, V value, double delta);
# 为有序集合中的莫个元素分数累计相应的值
方法：Long count(K key, double min, double max);
# 计算有序集合中元素个数（按照分数筛选计算）
方法：Long lexCount(K key, Range range);
# 计算有序集合中元素个数（按照元素筛选计算）
方法：Long rank(K key, Object o);
# 正向（从小到大顺序）获取某个元素在当前有序集合的位置
方法：Long reverseRank(K key, Object o);
# 反向向（从大到小顺序）获取某个元素在当前有序集合的位置
方法：Long size(K key);
方法：Long zCard(K key);
# 上面两个方法都是计算当前有序集合的全部元素个数
方法：Double score(K key, Object o);
# 获取有序集合中某个元素的分数
方法：Cursor> scan(K key, ScanOptions options);
# 查询获取元素
方法：RedisOperations getOperations();
# 获取基本的key操作

####### 关于ZSetOperations查询Range及reverseRange
方法：Set range(K key, long start, long end);
# 获取有序集合中指定范围的元素（下标条件）
方法：Set rangeByScore(K key, double min, double max);
# 获取有序集合中指定范围的元素（分数条件）
方法：Set rangeByScore(K key, double min, double max, long offset, long count);
# 获取有序集合中指定范围的元素（分数条件）并设置偏移量和返回总个数count
方法：Set rangeByLex(K key, Range range)
# 获取有序集合中指定范围的元素（元素条件）
方法：Set rangeByLex(K key, Range range, Limit limit);
# 获取有序集合中指定范围的元素（元素条件）并设置limit条件里的offset/count
方法：Set> rangeByScoreWithScores(K key, double min, double max);
# 获取有序集合中指定范围的元素和分数（分数条件）
方法：Set> rangeByScoreWithScores(K key, double min, double max, long offset, long count);
# 获取有序集合中指定范围的元素和分数（分数条件）并设置偏移量和返回总个数count
方法：Set> rangeWithScores(K key, long start, long end);
# 获取有序集合中指定范围的元素（下标条件）

关于：reverseRange的一套方法和上面的几个方法使用上一样，只不过输出的是从大到小的返回

把上面方法的range换为reverseRange就是从大到小返回了，这里就不列举了

方法：Long intersectAndStore(K key, K otherKey, K destKey);
# 以key为主对比otherKey的交集，并把符合的元素存放到destKey有序集合上
方法：Long intersectAndStore(K key, Collection otherKeys, K destKey);
# 以key为主对比otherKeys多个有序集合的交集，并把符合的元素存放到destKey有序集合上
方法：Long intersectAndStore(K key, Collection otherKeys, K destKey, Aggregate aggregate)
# 以key为主对比otherKeys多个有序集合的交集，并把符合的元素存放到destKey有序集合上；并设置合并的分数处理方式sum/max/min
方法：Long intersectAndStore(K key, Collection otherKeys, K destKey, Aggregate aggregate, Weights weights);
# 和上面一样，就多出一个Weights权重计算（乘法因子）

关于：unionAndStore 并集方法参考上面四个，用法一样，只不过

方法：Long remove(K key, Object… values);
# 删除有序集合中指定的元素
方法：Long removeRange(K key, long start, long end);
# 删除有序集合中指定的元素（下标条件）
方法：Long removeRangeByScore(K key, double min, double max);
# 删除有序集合中指定的元素（分数条件）
方法：Long removeRangeByLex(K key, Range range);
# 删除有序集合中指定的元素（元素条件）

ZSetOperations基本方法

//注入键值都为String对象的RedisTemplate对象
@Autowired
private StringRedisTemplate stringRedisTemplate;

@Test  
void redisTemplateBase() {  
    //测试数据，在Redis客户端执行  
    //zadd myzsetA -5 && -2 ## 0 @@ 1 aa 5 bb 10 cc 15 dd 20 ee 25 ff 30 gg 35 hh 40 ii 45 jj 50 kk  
    //zadd chinas -10 Anhui 45 Shanghai 24 Beijing 33 Henan 87 Guangdong  
    //zadd zsetA 20 zhangsan 25 lisi 33 wanger 15 mazi 33 babao 23 xiechao  
    //zadd zsetB 5 zhangsan 10 lisi 15 mazi 20 babao  
    //zadd zsetC 10 aa 10 bb 10 cc 10 dd 10 ee 10 ff 10 gg 10 hh

    //获取基本的 ZSetOperations 操作对象（操作Redis的ZSet类型）  
    ZSetOperations<String, String> opsForZSet = stringRedisTemplate.opsForZSet();  
    //往有序集合里面插入一个元素  
    Boolean add1 = opsForZSet.add("ChinaA", "Beijing", 23D);  
    //往有序集合内部批量插入元素(返回添加成功的元素个数)  
    Set<ZSetOperations.TypedTuple<String>> batchKV1 = new HashSet<>();  
    batchKV1.add(ZSetOperations.TypedTuple.of("Shanghai", 22D));  
    batchKV1.add(ZSetOperations.TypedTuple.of("Anhui", 27D));  
    Long add2 = opsForZSet.add("ChinaA", batchKV1);  
    //往有序集合里面插入一个或多个元素（若当前集合存在此元素则不会添加）(返回添加成功的个数或返回true|false)  
    Boolean aBoolean = opsForZSet.addIfAbsent("ChinaA", "Beijing", 40D);  
    batchKV1.add(ZSetOperations.TypedTuple.of("Jiangsu", 66D));  
    Long chinaA = opsForZSet.addIfAbsent("ChinaA", batchKV1);  
    //对有序集合中的某个元素进行分数的累加 返回累加后的元素分数，此时我对“Beijing”累加10，返回33.0  
    Double increment = opsForZSet.incrementScore("ChinaA", "Beijing", 10D);

    //返回有序集合中指定范围的元素个数，根据分数条件  
    Long count1 = opsForZSet.count("myzsetA", 10D, 35D);  
    //返回有序集合中指定范围的元素个数，根据lex元素条件（红面方法有提到）  
    RedisZSetCommands.Range rq = RedisZSetCommands.Range.range();  
    rq.gt("bb");  
    rq.lt("ff");  
    Long count2 = opsForZSet.lexCount("zsetC", rq);

    //返回当前元素“Beijing”在集合“chinas”中的位置（从小到大） 返回1  
    Long rank1 = opsForZSet.rank("chinas", "Beijing");  
    //返回当前元素“Beijing”在集合“chinas”中的位置(从大到小)  返回3  
    Long rank2 = opsForZSet.reverseRank("chinas", "Beijing");

    //返回集合中元素个数  
    Long size1 = opsForZSet.size("chinas");  
    Long size2 = opsForZSet.zCard("chinas");  
    //返回有序集合中指定元素的分数  
    Double score = opsForZSet.score("chinas", "Shanghai");  
    //设置查询条件并且查询有序集合chinas的全部元素”\*“，为什么count没起效果没太注意  
    ScanOptions build = ScanOptions.scanOptions().match("\*").count(2L).build();  
    Cursor<ZSetOperations.TypedTuple<String>> scan = opsForZSet.scan("chinas", build);  
    while (scan.hasNext()) {  
        ZSetOperations.TypedTuple<String> next = scan.next();  
        System.out.println(next.getValue() + " : " + next.getScore());  
    }  
    //返回基本操作方法对象  
    RedisOperations<String, String> operations = opsForZSet.getOperations();  
}

//关于ZSetOperations查询Range及reverseRange  
//  Range：分数按照从低到高查询  
//  reverseRange：分数从高到地查询  
@Test  
void redisTemplateBaseRange() {  
    //关于 lex 查询  
    //创建关于lex的查询方式  
    //若某个有序集合使用元素查询时（lex），那么我推荐你最好使用分数都是相同的有序集合！  
    // RedisZSetCommands.Range对象说明：  
    // RedisZSetCommands.Range rq = RedisZSetCommands.Range.range();  
    //      rq.gt("bb"); 代表查询条件大于 “bb”  对于命令 (bb  
    //      rq.lt("ff"); 代表查询条件小于 “ff”  对于命令 (ff  
    //      rq.gte("bb"); 代表查询条件大于等于 “bb”  对于命令 \[bb  
    //      rq.lte("ff"); 代表查询条件小于等于 “ff”  对于命令 \[ff  
    //      rq.getMax();  代表查询条件从最大     对于命令 +  
    //      rq.getMin();  代表查询条件从最小     对于命令 -  
    // RedisZSetCommands.Limit对象说明：  
    // RedisZSetCommands.Limit limit = new RedisZSetCommands.Limit();  
    //      limit.count(2); 代表查询2个元素  
    //      limit.offset(3); 代表查询偏移量3，就是从第4个开始，必须存在count属性，偏移后查询几个

    //获取基本的 ZSetOperations 操作对象（操作Redis的ZSet类型）  
    ZSetOperations<String, String> opsForZSet = stringRedisTemplate.opsForZSet();  
    //基本方式查询，0 -1 代表查询全部  
    Set<String> range1 = opsForZSet.range("zsetA", 0L, -1L);  
    //关于 score 查询  
    //分数查询，查询集合元素分数在1~45的元素  
    Set<String> range2 = opsForZSet.rangeByScore("myzsetA", 1D, 45D);  
    //分数查询，查询集合元素分数在1~45的元素，偏移量1，查询数3（就是第二个开始查询，查询3个）  
    Set<String> range3 = opsForZSet.rangeByScore("myzsetA", 1D, 45D, 1L, 3L);  
    //条件  
    RedisZSetCommands.Range rq = RedisZSetCommands.Range.range();  
    rq.getMin();  
    rq.getMax();  
    RedisZSetCommands.Limit limit = new RedisZSetCommands.Limit();  
    limit.count(2);  
    limit.offset(3);  
    //查询有序集合zsetC的全部元素 - +  
    Set<String> range4 = opsForZSet.rangeByLex("zsetC", rq);  
    //查询有序集合zsetC的全部元素 - +  并且返回偏移3，count = 2  
    Set<String> range5 = opsForZSet.rangeByLex("zsetC", rq, limit);  
    //查询有序集合chinas分数在-30 ~ 40之间的全部元素（返回元素和分数）  
    Set<ZSetOperations.TypedTuple<String>> range6 = opsForZSet.rangeByScoreWithScores("chinas", -30D, 40D);  
    Iterator<ZSetOperations.TypedTuple<String>> iterator = range6.iterator();  
    while (iterator.hasNext()) {  
        ZSetOperations.TypedTuple<String> next = iterator.next();  
        System.out.println(next.getValue() + " : " + next.getScore());  
    }  
    //查询有序集合chinas分数在-30 ~ 40之间的全部元素  并且返回偏移1，count = 2  
    Set<ZSetOperations.TypedTuple<String>> range7 = opsForZSet.rangeByScoreWithScores("chinas", -30D, 40D, 1L, 2L);  
    //查询有序集合chinas分数在 - + （全部元素）  
    Set<ZSetOperations.TypedTuple<String>> range8 = opsForZSet.rangeWithScores("chinas", 0L, -1L);

    // reverseRange  
    // 关于：reverseRange的一套方法和上面的几个方法使用上一样，只不过输出的是从大到小的返回  
    //从大到小的基本方式查询，0 -1 代表查询全部  
    Set<String> reverse1 = opsForZSet.reverseRange("myzsetA", 0L, -1L);  
}

//关于ZSetOperations查询差异查询  
@Test  
void redisTemplateBaseDiff() {  
    //指定交集、并集的结果集的聚合方式：  
    //  枚举：RedisZSetCommands.Aggregate.MIN 指定min则交集并集的元素的分数取最小  
    //  枚举：RedisZSetCommands.Aggregate.MAX 指定max则交集并集的元素的分数取最大  
    //  枚举：RedisZSetCommands.Aggregate.SUM 指定sum（默认）则交集并集的元素的分数结合  
    //RedisZSetCommands.Weights:  
    //  RedisZSetCommands.Weights.fromSetCount(2)：输入排序集的集合计算，有几个集合就写几  
    //  RedisZSetCommands.Weights.of() :里面传入int或者double（一种）的可变参，有几个集合就传几个（做乘法计算）

    //获取基本的 ZSetOperations 操作对象（操作Redis的ZSet类型）  
    ZSetOperations<String, String> opsForZSet = stringRedisTemplate.opsForZSet();  
    //有序集合“zsetA” 对比 “zsetB” 获取交集数据存放到"interZSetA"集合上（分数为两个元素的相加）  
    Long intersect1 = opsForZSet.intersectAndStore("zsetA", "zsetB", "interZSetA");  
    //以有序集合“zsetA”为主对比其它一个或多个集合的交集（接收集合keys）  
    Long intersect2 = opsForZSet.intersectAndStore("zsetA", Arrays.asList("zsetB"), "interZSetA");  
    // Aggregate为max（代表并、交集取最大分数）  
    Long intersect3 = opsForZSet.intersectAndStore("zsetA", Arrays.asList("zsetB"), "interZSetB",  
            RedisZSetCommands.Aggregate.MAX);  
    // Weights权重计算（乘法因子）  
    Long intersect4 = opsForZSet.intersectAndStore("zsetA", Arrays.asList("zsetB"), "interZSetC",  
            RedisZSetCommands.Aggregate.MAX,  
            RedisZSetCommands.Weights.of(5, 10));  
    //unionAndStore  
    //关于：unionAndStore 并集方法参考上面四个，用法一样  
    //并集就是把几个集合的元素并到一起（不漏任何元素），然后单个元素单独计算，多个元素计算后合并到一起  
}

//删除方法  
@Test  
void redisTemplateBaseRemove() {  
    //获取基本的 ZSetOperations 操作对象（操作Redis的ZSet类型）  
    ZSetOperations<String, String> opsForZSet = stringRedisTemplate.opsForZSet();  
    //删除有序集合chinas里两个元素，返回删除成功的个数  
    Long remove1 = opsForZSet.remove("chinas", "Shanghai", "Henan");  
    //删除有序集合chinas里全部元素 0 -1  
    Long remove2 = opsForZSet.removeRange("chinas", 0L, -1L);  
    //删除有序集合myzsetA里5 ~ 30 之间的元素  
    Long remove3 = opsForZSet.removeRangeByScore("myzsetA", 5D, 30D);  
    //删除有序集合zsetC里全部元素  
    RedisZSetCommands.Range rq = RedisZSetCommands.Range.range();  
    rq.getMin();  
    rq.getMax();  
    Long remove4 = opsForZSet.removeRangeByLex("zsetC", rq);  
}

7：GeoOperations之Geo地理空间类型

依赖补充方法：
接口：Metric
对象：public CustomMetric(double multiplier)
对象：public CustomMetric(double multiplier, String abbreviation)
# 自定义指标接口
# 属性：
# multiplier：乘数，计算距离的乘积
# abbreviation：距离单位缩写；用来指定单位 m、km、ft、mi
# 方法：
# String getAbbreviation()：获取单位缩写
# double getMultiplier()：获取乘数
对象：public Point(double x, double y)
# 设置地理空间点值（X、Y）
# 方法：
# getX()、getY()：获取X、Y坐标
对象：public Distance(double value)
对象：public Distance(double value, Metric metric)
# 值对象表示给定度量中的距离
# 属性：
# double value：设置距离
# Metric metric：设置自定义指标
# 方法：
# Metric getMetric()：获取Metric对象
# double getNormalizedValue()：获取规格化值
# String getUnit()：获取单位
# double getValue()：获取距离值
对象：public Circle(Point center, double radius)
对象：public Circle(Point center, Distance radius)
# 设置地理空间范围值（半径）
# 属性：
# Point center：地理空间点值
# double radius：半径范围值
# Distance radius：值对象表示给定度量中的距离

基本方法：

方法：Long add(K key, Point point, M member);
方法：Long add(K key, GeoLocation location);
方法：Long add(K key, Map memberCoordinateMap);
方法：Long add(K key, Iterable> locations);
# 添加地理空间元素
方法：List position(K key, M… members);
# 获取元素地点坐标
方法：List hash(K key, M… members);
# 获取地点hash值
方法：Distance distance(K key, M member1, M member2, Metric metric);
方法：Distance distance(K key, M member1, M member2);
# 获取两点距离
方法：GeoResults> radius(K key, Circle within);
方法：GeoResults> radius(K key, M member, double radius);
方法：GeoResults> radius(K key, M member, Distance distance);
方法：GeoResults> radius(K key, Circle within, GeoRadiusCommandArgs args);
方法：GeoResults> radius(K key, M member, Distance distance, GeoRadiusCommandArgs args);
# 计算获取范围内的空间元素

GeoOperations基本方法

//注入键值都为String对象的RedisTemplate对象  
@Autowired  
private StringRedisTemplate stringRedisTemplate;

@Test  
void redisTemplateBase() {  
    //获取基本的 GeoOperations 操作对象（操作Redis的Geo地理空间类型）  
    GeoOperations<String, String> opsForGeo = stringRedisTemplate.opsForGeo();  
    // 初始化基本的坐标  
    Point hefei = new Point(117.30794D, 31.79322D);   // 合肥  
    Point wuhu = new Point(118.38548D, 31.34072D);    // 芜湖  
    Point bengbu = new Point(117.36779D, 32.94448D);  // 蚌埠  
    Point luan = new Point(116.53949D, 31.74933D);    // 六安  
    Point bozhou = new Point(115.77914D, 33.87641D);  // 亳州  
    Point chuzhou = new Point(118.30553D, 32.2948D);  // 滁州  
    Point fuyang = new Point(115.85668D, 32.91303D);  // 阜阳

    // 添加 hefei 地理空间坐标  
    opsForGeo.add("Anhui", hefei, "hefei");  
    // 添加 wuhu 地理空间坐标  
    RedisGeoCommands.GeoLocation<String> wuhu1 = new RedisGeoCommands.GeoLocation<>("wuhu", wuhu);  
    opsForGeo.add("Anhui", wuhu1);  
    // 使用map批量添加"bengbu" 、 "luan" 地理空间坐标  
    Map<String, Point> points = new HashMap<>();  
    points.put("bengbu", bengbu);  
    points.put("luan", luan);  
    opsForGeo.add("Anhui", points);  
    // 使用集合批量添加 “bozhou”、“chuzhou”、“fuyang” 地理空间坐标  
    List<RedisGeoCommands.GeoLocation<String>> lists = new ArrayList<>();  
    lists.add(new RedisGeoCommands.GeoLocation<>("bozhou", bozhou));  
    lists.add(new RedisGeoCommands.GeoLocation<>("chuzhou", chuzhou));  
    lists.add(new RedisGeoCommands.GeoLocation<>("fuyang", fuyang));  
    opsForGeo.add("Anhui", lists);

    // 从地理坐标集合里获取 “hefei”,"luan"地理坐标值，若获取的空间不存在则为null  
    List<Point> position = opsForGeo.position("Anhui", "hefei", "luan");  
    //for (Point p : position)  
    //System.out.println("X:" + p.getX() + "    Y:" + p.getY());  
    //X:117.30793744325638    Y:31.793219150805264  
    //X:116.53948992490768    Y:31.749330453931314

    //返回一个有效的hash字符串，返回的字符串是11位的字符,它与Redis内部的52位表示精度相差可以忽略  
    //若两个11位的hash字符串越接近，那么代表坐标越接近  
    List<String> hash = opsForGeo.hash("Anhui", "hefei", "luan");  
    //hash.forEach(System.out::println);  
    //wtekv7v0cj0  
    //wtduegv3qb0

    //计算 "hefei" 到 "luan" 的元素位置距离  
    Metric ms = new CustomMetric(1000D, "m");  
    Distance de = opsForGeo.distance("Anhui", "hefei", "luan", ms);  
    System.out.println("获取传入的Metric对象：" + de.getMetric());  
    System.out.println("获取传入的Metric对象的单位缩写：" + de.getMetric().getAbbreviation());  
    System.out.println("获取传入的Metric对象的乘数：" + de.getMetric().getMultiplier());  
    System.out.println("获取规格化值：" + de.getNormalizedValue() + " km");  
    System.out.println("获取单位：" + de.getUnit());  
    System.out.println("获取距离值：" + de.getValue() + " " + de.getMetric().getAbbreviation());  
    //计算 "wuhu" 到 "bengbu" 的元素位置距离（默认就是m）  
    Distance distance = opsForGeo.distance("Anhui", "wuhu", "bengbu");  
    System.out.println(distance.getValue() + "米");

    // 设置范围指标  
    Circle circle = new Circle(hefei, 100000D);  
    // 获取 ”Anhui“ 元素范围点的空间元素  
    GeoResults<RedisGeoCommands.GeoLocation<String>> radiusA = opsForGeo.radius("Anhui", circle);  
    List<Map<String, Object>> list = radiusPars(opsForGeo, radiusA);  
    System.out.println(list);  
    //删除元素  
    Long remove = opsForGeo.remove("Anhui", "hefei");  
}

private static List<Map<String, Object>> radiusPars(GeoOperations<String, String> opsForGeo, GeoResults<RedisGeoCommands.GeoLocation<String>> radiusA) {  
    //用来存储具体的地理空间元素信息  
    List<Map<String, Object>> listInfo = new ArrayList<>();  
    if (radiusA != null) {  
        //用来存储符合范围条件全部的地理空间元素  
        List<String> geos = new ArrayList<>();  
        //获取全部地理空间半径范围内的元素  
        List<GeoResult<RedisGeoCommands.GeoLocation<String>>> contents = radiusA.getContent();  
        for (GeoResult<RedisGeoCommands.GeoLocation<String>> s : contents) {  
            //获取一个个地理空间元素 并保存起来  
            RedisGeoCommands.GeoLocation<String> content = s.getContent();  
            geos.add(content.getName());  
        }  
        for (int i = 0; i < geos.size(); i++) {  
            String placeName = geos.get(i);     //地名  
            Point point = Objects.requireNonNull(opsForGeo.position("Anhui", placeName)).get(0); //获取具体坐标  
            Map<String, Object> map = new HashMap<>();  
            map.put("placeName", placeName);  
            map.put("point", point);  
            listInfo.add(map);  
        }  
    }  
    return listInfo;  
}

8：HyperLogLog之超级基数统计类型

　　HyperLogLog主要是用来大数据量统计的类型算法，比如我们统计网站的一天访问量；虽然我们可以使用Redis中String类型的incr、incrby来实现，但是它只能统计访问本网站的每个请求计数累加（除了程序控制），但是我要说每个IP请求多少次都算作一次，对于多个相同IP的请求需要去重计数，在这种环境下HyperLogLog是优选，虽然hash、set、bitmaps可以解决这种问题，但随着数据不断增加，导致占用空间越来越大，对于非常大的数据集是不切实际的；

基本方法：
方法：Long add(K key, V… values);
# 添加指定元素到hyperloglog中
方法：Long size(K… keys);
# 返回一个或多个键内统计基数（就是返回不相同的元素个数，用来统计），计算统计误差在0.81%
方法：Long union(K destination, K… sourceKeys);
# 统计一个或多个键内统计基数并放到外部集合里
方法：void delete(K key);
# 删除元素

//注入键值都为String对象的RedisTemplate对象  
@Autowired  
private StringRedisTemplate stringRedisTemplate;

@Test  
void redisTemplateBase() {  
    //获取基本的 HyperLogLogOperations 操作对象（操作Redis的超级基数统计类型）  
    HyperLogLogOperations<String, String> opsForHyperLogLog = stringRedisTemplate.opsForHyperLogLog();  
    //添加指定元素到hyperloglog中，如果指定的键不存在，该命令会自动创建一个空的hyperloglog结构  
    //注：重复时只保存一个  
    Long nameA = opsForHyperLogLog.add("nameA", "Tom", "Jack", "Lucy", "Lucy");  
    Long nameB = opsForHyperLogLog.add("nameB", "Jack", "Mia", "Emma", "Ava");  
    //获取存储的个数  
    Long size = opsForHyperLogLog.size("nameA");  
    //多键统计，把多个集合存放到一个集合中（重复则被剔除）  
    Long union = opsForHyperLogLog.union("nameC", "nameA", "nameB");  
    System.out.println(opsForHyperLogLog.size("nameC"));  
    //删除元素  
    opsForHyperLogLog.delete("nameC");  
}

9：BitMap[位图]=>ValueOperations之String类型操作

　　位图我则以一个示例来讲解，比如来记录一个员工月签到情况；签到只会分已签到和未签到，那就用1 签到 和0 未签到 来表示，一个月最大31天，那我可以用4个byte位来记录一个月，因为4*8=32byte；具体的BitMap不知道咋操作的可以参考我的 Redis基本命令（我们测试数据从这篇文章复制）

下面我来带你们看看蚂蚁小哥的签到情况吧：

//注入键值都为String对象的RedisTemplate对象  
@Autowired  
private StringRedisTemplate stringRedisTemplate;

@Test  
void redisTemplateBase() {  
    //这里我只是简单介绍了，后期遇到了会再次补充  
    //获取基本的 ValueOperations 操作对象（操作Redis的String类型）  
    ValueOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();

    //记录蚂蚁小哥 2、10、15、17、30这几天上班了（后面会执行测试数据覆盖这些数据）  
    opsForValue.setBit("record", 2, true);  
    opsForValue.setBit("record", 10, true);  
    opsForValue.setBit("record", 15, true);  
    opsForValue.setBit("record", 17, true);  
    opsForValue.setBit("record", 30, true);  
    //查询蚂蚁小哥20号和30号这两天是否上班了  有记录为true，未签到为false  
    Boolean record20 = opsForValue.getBit("record", 20L);  
    Boolean record30 = opsForValue.getBit("record", 30L);

    **// 注：RedisTemplate中并没有直接提供方法来调用bitCount方法，需要通过redisTemplate.execute来执行bitCount方法** // 统计蚂蚁小哥签到的record 记录前 16天（具体为什么16天参考上面的基础命令）  
    Long statisticsA = (Long) opsForValue.getOperations()  
            .execute((RedisCallback<Object>) e -> e.bitCount("record".getBytes(), 0L, 1L));  
    // 统计蚂蚁小哥签到的record一个月的全部记录  
    Long statisticsB = (Long) opsForValue.getOperations()  
            .execute((RedisCallback<Object>) e -> e.bitCount("record".getBytes()));  
    System.out.println("这个月蚂蚁小哥上班打开：" + statisticsB);

    //补充 在多个键中执行位运算，并将结果存储到目标键中  
    // RedisStringCommands.BitOperation.(AND|OR|XOR|NOT) 四种位运算  
    // “newBit” 把多个键运算后存放到此键中  
    // "bitA"、“bitB” 待处理的要运算的多个键  
    Long bitOp = (Long) opsForValue.getOperations().execute((RedisCallback<Object>) e ->  
            e.bitOp(RedisStringCommands.BitOperation.AND, "newBit".getBytes(), "bitA".getBytes(), "bitB".getBytes()));  
    System.out.println(bitOp);  
}

　　在RedisTemplate里我们可以看到execute（处理）和executePipelined（批处理）两种方法；下面我就针对这两种方式做个基本介绍说明

1：基本介绍

StringRedisTemplate继承RedisTemplate，只是提供字符串的操作，复杂的Java对象还要自行处理 RedisCallback：
让RedisTemplate进行回调，通过他们可以在同一条连接中执行多个redis命令（接近底层，不推荐使用，都是使用byte[]进行操作）
SessionCallback：
他比RedisCallback的优势在于SessionCallback提供了良好的封装
注：RedisCallback和Sessionallback都是在一个连接里，防止每执行一条命令创建一次连接
RedisConnection：
** redis连接对象，内部封装了redis的全部命令**
基本封装对象方法：
RedisKeyCommands keyCommands() 获取基本key操作
RedisStringCommands stringCommands() 获取String类型的命令
RedisHashCommands hashCommands() 获取Hash类型的命令
RedisListCommands listCommands() 获取List类型的命令
RedisSetCommands setCommands() 获取Set类型的命令
RedisZSetCommands zSetCommands() 获取ZSet类型的命令
RedisGeoCommands geoCommands() 获取Geo地理空间类型的命令
RedisHyperLogLogCommands hyperLogLogCommands()获取HyperLogLog超级基数统计类型的命令
RedisServerCommands serverCommands() 获取服务器的命令

2：execute处理

　　不管execute内执行多少条redis命令，最终只会返回一个结果，事务的除外，后面会说

//注入键值都为String对象的RedisTemplate对象  
@Autowired  
private StringRedisTemplate stringRedisTemplate;

@Autowired  
private RedisTemplate redisTemplate;

@Test  
void redisTemplateBase() {

    //使用 RedisCallback来处理  
    Object ex1 = redisTemplate.execute(new RedisCallback() {  
        @Override  
        public Object doInRedis(RedisConnection rc) throws DataAccessException {  
            return rc.set("name".getBytes(), "zhangsan".getBytes());  
        }  
    });  
    System.out.println("使用redisTemplate来操作execute设置值：" + ex1);  
    //使用 RedisCallback来处理  
    String ex1Str = stringRedisTemplate.execute(new RedisCallback<String>() {  
        @Override  
        public String doInRedis(RedisConnection rc) throws DataAccessException {  
            RedisStringCommands stringCommands = rc.stringCommands();  
            stringCommands.set("address".getBytes(), "anhui dianzi xueyuan".getBytes());  
            return new String(Objects.requireNonNull(stringCommands.get("address".getBytes())));  
        }  
    });  
    System.out.println("使用stringRedisTemplate来操作execute获取address：" + ex1Str);  
    //使用 SessionCallback来处理（推荐）  
    Object ex2 = redisTemplate.execute(new SessionCallback() {  
        @Override  
        public Object execute(RedisOperations operations) throws DataAccessException {  
            ValueOperations opsForValue = operations.opsForValue();  
            opsForValue.set("address", "anhui");  
            return opsForValue.get("address");  
        }  
    });  
    System.out.println("使用redisTemplate来操作execute获取address值：" + ex2);  
    //使用 SessionCallback来处理（推荐）  
    String ex2Str = stringRedisTemplate.execute(new SessionCallback<String>() {  
        @Override  
        public <K, V> String execute(RedisOperations<K, V> operations) throws DataAccessException {  
            ValueOperations<K, V> opsForValue = operations.opsForValue();  
            opsForValue.set((K)"sex",(V)"female");  
            return (String)opsForValue.get("sex");  
        }  
    });  
    System.out.println("使用stringRedisTemplate来操作execute获取sex：" + ex2Str);  
}

3：executePipelined批处理

　　我们在executePipelined内不管执行多少条redis命令，最终都会把每条的执行结果以集合方式返回

//注入键值都为String对象的RedisTemplate对象
@Autowired
private StringRedisTemplate stringRedisTemplate;

@Test  
void redisTemplateBase() {

    // 推荐使用 SessionCallback 因为对此有封装，而 RedisCallback 不推荐；；在这内部可以执行事务  
    List<Object> dataA = stringRedisTemplate.executePipelined(new SessionCallback<Object>() {  
        @Override  
        public <K, V> Object execute(RedisOperations<K, V> operations) throws DataAccessException {  
            //把RedisOperations接口赋值给StringRedisTemplate（字符串的K,V）  
            StringRedisTemplate stringRT = (StringRedisTemplate) operations;  
            //stringRT.multi(); 开启事务  
            //获取String类型的k,v操作  
            ValueOperations<String, String> opsForValue = stringRT.opsForValue();  
            //执行Redis命令，这执行的每一条语句最终都会返回，虽然后面返回 return null, 但是结果已经被封装返回了  
            opsForValue.set("name", "zhansgan");  
            opsForValue.set("address", "anhui");  
            opsForValue.set("salary", "40000.50");  
            opsForValue.get("name");  
            opsForValue.get("address");  
            opsForValue.get("salary");  
            //stringRT.exec(); 结束事务  
            return null;  
        }  
    });  
    System.out.println(dataA);  
    // 未开事务打印结果 \[true, true, true, zhansgan, anhui, 40000.50\]  
    // 开事务打印结果 \[\[true, true, true, zhansgan, anhui, 40000.50\]\]  
}  

.