组件整合之redis(Spring Data Redis 2.X)
快速入门
pom依赖
<!-- spring-data-redis (注意与cluster的版本问题,也注意与spring的版本)-->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>2.1.9.RELEASE</version>
</dependency>
<!--2.9.1有连接泄露的bug-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.10.2</version>
</dependency>
可能会用到Jackson的相关依赖:
<!--Jackson-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.11.4</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.11.4</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jsr310</artifactId>
<version>2.11.4</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.11.4</version>
</dependency>
如何配置
单机模式
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
@Configuration
public class StandaloneRedisConfig {
/**
* 配置连接池
* @return
*/
@Bean
public JedisPoolConfig standalonePoolConfig(){
JedisPoolConfig poolConfig = new JedisPoolConfig();
//连接池中最多可空闲链接个数,这里取值20,表示即使没有用数据库链接依然保持20个空闲链接
poolConfig.setMaxIdle(20);
//控制一个pool可以分配多少个jedis实例
poolConfig.setMaxTotal(300);
//最大等待时间,当没有可用连接时,连接池等待链接被归还的最大时间ms,超过时间就抛出异常
poolConfig.setMaxWaitMillis(1000);
//在获取连接的时候检查链接的有效性
poolConfig.setTestOnCreate(true);
return poolConfig;
}
/**
* redis单机配置
* RedisStandaloneConfiguration 单机
* RedisSentinelConfiguration 主从复制(哨兵模式)
* RedisClusterConfiguration 集群
* @return
*/
@Bean
public RedisStandaloneConfiguration standaloneConfiguration(){
RedisStandaloneConfiguration standaloneConfiguration = new RedisStandaloneConfiguration();
standaloneConfiguration.setHostName("127.0.0.1");
standaloneConfiguration.setPort(6379);
standaloneConfiguration.setDatabase(0);
return standaloneConfiguration;
}
/**
* 配置连接工厂
* @return
*/
@Bean
public JedisConnectionFactory standaloneConnectionFactory(){
return new JedisConnectionFactory(standaloneConfiguration());
}
/**
* 配置Redis模板
*/
@Bean
public RedisTemplate standaloneRedisTemplate(){
RedisTemplate redisTemplate = new RedisTemplate();
redisTemplate.setConnectionFactory(standaloneConnectionFactory());
StringRedisSerializer keySerializer = new StringRedisSerializer();
GenericJackson2JsonRedisSerializer valueSerializer = new GenericJackson2JsonRedisSerializer();
//keySerializer、valueSerializer 配置Redis中的String类型key与value的序列化器
redisTemplate.setKeySerializer(keySerializer);
redisTemplate.setValueSerializer(valueSerializer);
//HashKeySerializer、HashValueSerializer 配置Redis中的Hash类型key与value的序列化器
redisTemplate.setHashKeySerializer(keySerializer);
redisTemplate.setHashValueSerializer(valueSerializer);
return redisTemplate;
}
}
主从模式(哨兵)
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
import java.util.ArrayList;
import java.util.List;
@Configuration
public class SentinelRedisConfig {
/**
* 配置连接池
* @return
*/
@Bean
public JedisPoolConfig sentinelPoolConfig(){
JedisPoolConfig poolConfig = new JedisPoolConfig();
//连接池中最多可空闲链接个数,这里取值20,表示即使没有用数据库链接依然保持20个空闲链接
poolConfig.setMaxIdle(20);
//控制一个pool可以分配多少个jedis实例
poolConfig.setMaxTotal(300);
//最大等待时间,当没有可用连接时,连接池等待链接被归还的最大时间ms,超过时间就抛出异常
poolConfig.setMaxWaitMillis(1000);
//在获取连接的时候检查链接的有效性
poolConfig.setTestOnCreate(true);
return poolConfig;
}
/**
* redis哨兵模式
* RedisStandaloneConfiguration 单机
* RedisSentinelConfiguration 主从复制(哨兵模式)
* RedisClusterConfiguration 集群
* @return
*/
@Bean
public RedisSentinelConfiguration sentinelConfiguration(){
RedisSentinelConfiguration sentinelConfiguration = new RedisSentinelConfiguration();
//主节点名称
sentinelConfiguration.setMaster("mymaster");
//哨兵监听的节点(一主二从)
List<RedisNode> redisNodeList = new ArrayList();
redisNodeList.add(new RedisNode("192.168.1.10", 6379));
redisNodeList.add(new RedisNode("192.168.1.11", 6379));
redisNodeList.add(new RedisNode("192.168.1.12", 6379));
sentinelConfiguration.setSentinels(redisNodeList);
//数据库
sentinelConfiguration.setDatabase(0);
return sentinelConfiguration;
}
/**
* 配置连接工厂
* @return
*/
@Bean
public JedisConnectionFactory sentinelConnectionFactory(){
return new JedisConnectionFactory(sentinelConfiguration());
}
/**
* 配置Redis模板
*/
@Bean
public RedisTemplate sentinelRedisTemplate(){
RedisTemplate redisTemplate = new RedisTemplate();
redisTemplate.setConnectionFactory(sentinelConnectionFactory());
StringRedisSerializer keySerializer = new StringRedisSerializer();
GenericJackson2JsonRedisSerializer valueSerializer = new GenericJackson2JsonRedisSerializer();
//keySerializer、valueSerializer 配置Redis中的String类型key与value的序列化器
redisTemplate.setKeySerializer(keySerializer);
redisTemplate.setValueSerializer(valueSerializer);
//HashKeySerializer、HashValueSerializer 配置Redis中的Hash类型key与value的序列化器
redisTemplate.setHashKeySerializer(keySerializer);
redisTemplate.setHashValueSerializer(valueSerializer);
return redisTemplate;
}
}
集群模式
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
@Configuration
public class ClusterRedisConfig {
/**
* 配置连接池
* @return
*/
@Bean
public JedisPoolConfig clusterPoolConfig(){
JedisPoolConfig poolConfig = new JedisPoolConfig();
//连接池中最多可空闲链接个数,这里取值20,表示即使没有用数据库链接依然保持20个空闲链接
poolConfig.setMaxIdle(20);
//控制一个pool可以分配多少个jedis实例
poolConfig.setMaxTotal(300);
//最大等待时间,当没有可用连接时,连接池等待链接被归还的最大时间ms,超过时间就抛出异常
poolConfig.setMaxWaitMillis(1000);
//在获取连接的时候检查链接的有效性
poolConfig.setTestOnCreate(true);
return poolConfig;
}
/**
* redis集群模式
* RedisStandaloneConfiguration 单机
* RedisSentinelConfiguration 主从复制(哨兵模式)
* RedisClusterConfiguration 集群
* @return
*/
@Bean
public RedisClusterConfiguration clusterConfiguration(){
RedisClusterConfiguration clusterConfiguration = new RedisClusterConfiguration();
clusterConfiguration.clusterNode("127.0.0.1", 6380);
clusterConfiguration.clusterNode("127.0.0.1", 6381);
clusterConfiguration.clusterNode("127.0.0.1", 6382);
return clusterConfiguration;
}
/**
* 配置连接工厂
* @return
*/
@Bean
public JedisConnectionFactory clusterConnectionFactory(){
return new JedisConnectionFactory(clusterConfiguration());
}
/**
* 配置Redis模板
*/
@Bean
public RedisTemplate clusterRedisTemplate(){
RedisTemplate redisTemplate = new RedisTemplate();
redisTemplate.setConnectionFactory(clusterConnectionFactory());
StringRedisSerializer keySerializer = new StringRedisSerializer();
GenericJackson2JsonRedisSerializer valueSerializer = new GenericJackson2JsonRedisSerializer();
//keySerializer、valueSerializer 配置Redis中的String类型key与value的序列化器
redisTemplate.setKeySerializer(keySerializer);
redisTemplate.setValueSerializer(valueSerializer);
//HashKeySerializer、HashValueSerializer 配置Redis中的Hash类型key与value的序列化器
redisTemplate.setHashKeySerializer(keySerializer);
redisTemplate.setHashValueSerializer(valueSerializer);
return redisTemplate;
}
}
JedisPoolConfig属性配置
//连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
config.setBlockWhenExhausted(true);
//设置的逐出策略类名, 默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数)
config.setEvictionPolicyClassName("org.apache.commons.pool2.impl.DefaultEvictionPolicy");
//是否启用pool的jmx(Java Management Extensions,即Java管理扩展)管理功能, 默认true
config.setJmxEnabled(true);
//是否启用后进先出, 默认true
config.setLifo(true);
//最大空闲连接数, 默认8个
config.setMaxIdle(10);
//最大连接数, 默认8个
config.setMaxTotal(50);
//获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间, 默认-1
config.setMaxWaitMillis(30000);
//资源池中资源最小空闲时间(单位为毫秒),达到此值后空闲资源将被移除 默认1800000毫秒(30分钟)
config.setMinEvictableIdleTimeMillis(60000);
//最小空闲连接数, 默认0
config.setMinIdle(0);
//每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
config.setNumTestsPerEvictionRun(3);
//对象空闲多久后逐出, 当空闲时间>该值 且 空闲连接>最大空闲数 时直接逐出,不再根据MinEvictableIdleTimeMillis判断 (默认逐出策略)
config.setSoftMinEvictableIdleTimeMillis(1800000);
//在获取连接的时候检查有效性, 默认false
config.setTestOnBorrow(false);
//是否开启空闲资源监测, 默认false
config.setTestWhileIdle(true);
//空闲资源的检测周期(单位为毫秒) 如果为负数,则不运行逐出线程, 默认-1
config.setTimeBetweenEvictionRunsMillis(-1);
RedisStandaloneConfiguration 单机配置
RedisStandaloneConfiguration standaloneConfiguration = new RedisStandaloneConfiguration();
standaloneConfiguration.setHostName("127.0.0.1");
standaloneConfiguration.setPort(6379);
standaloneConfiguration.setDatabase(0);
standaloneConfiguration.setPassword("123456");
RedisSentinelConfiguration 主从复制
RedisSentinelConfiguration sentinelConfiguration = new RedisSentinelConfiguration();
//主节点名称
sentinelConfiguration.setMaster("mymaster");
//哨兵监听的节点(一主二从)
List<RedisNode> redisNodeList = new ArrayList();
redisNodeList.add(new RedisNode("192.168.1.10", 6379));
redisNodeList.add(new RedisNode("192.168.1.11", 6379));
redisNodeList.add(new RedisNode("192.168.1.12", 6379));
sentinelConfiguration.setSentinels(redisNodeList);
//数据库
sentinelConfiguration.setDatabase(0);
sentinelConfiguration.setPassword("123456");
RedisClusterConfiguration 集群配置
RedisClusterConfiguration clusterConfiguration = new RedisClusterConfiguration();
clusterConfiguration.clusterNode("127.0.0.1", 6380);
clusterConfiguration.clusterNode("127.0.0.1", 6381);
clusterConfiguration.clusterNode("127.0.0.1", 6382);
clusterConfiguration.setMaxRedirects(100);
clusterConfiguration.setPassword("123456");
JedisConnectionFactory 连接工厂
在spring-data-redis2.0以上版本JedisConnectionFactory中的很多方法都过期了,官方推荐改为构造器中传入配置对象:
- 单机配置 RedisStandaloneConfiguration
- 主从复制 RedisSentinelConfiguration
- 集群 RedisClusterConfiguration
RedisTemplate Redis模板
(1)手动设置 key与value的序列化方式
序列化器:能够把我们储存的key与value做序列化处理的对象,是一个类似于converter的工具。
可以实现传入的java对象->redis可以识别的数据类型。 如:字符串。
默认的Serializer是StringRedisSerializer。
设定默认的序列化器是字符串序列化器,原因是redis可以存储的数据只有字符串和字节数组。
一般来说,我们代码中操作的数据对象都是java对象。
如果代码中,使用的数据载体就是字符串对象,那么使用Jackson2JsonRedisSerializer来做序列化器是否会有问题?
如果jackson插件的版本不合适,有错误隐患的话,可能将字符串数据转换为json字符串 -> {chars:[], bytes:[]}
使用StringRedisSerializer就没有这个问题,它不处理字符串转换的,认为代码中操作的key和value都是字符串。
测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes={RootConfig.class, WebConfig.class}) //如果是Java Config配置的,指定相关的配置类
@WebAppConfiguration
public class ClusterRedisTest {
@Autowired
private RedisTemplate clusterRedisTemplate;
@Test
public void test(){
clusterRedisTemplate.opsForValue().set("cluster", "hello");
System.out.println(clusterRedisTemplate.opsForValue().get("cluster"));
}
}
RedisTemplate API
通过bound封装指定的key
指定后进行一系列的操作而无须“显式”的再次指定Key,即BoundKeyOperations:
- BoundValueOperations
- BoundSetOperations
- BoundListOperations
- BoundSetOperations
- BoundHashOperations
//1、通过redisTemplate设置值
clusterRedisTemplate.boundValueOps("StringKey").set("StringValue");
clusterRedisTemplate.boundValueOps("StringKey").set("StringValue", 1, TimeUnit.MINUTES);
//2、通过BoundValueOperations设置值
BoundValueOperations stringKey = clusterRedisTemplate.boundValueOps("StringKey");
stringKey.set("StringValue");
stringKey.set("StringValue", 1, TimeUnit.MINUTES);
//3、通过ValueOperations设置值
ValueOperations ops = clusterRedisTemplate.opsForValue();
ops.set("StringKey", "StringValue");
ops.set("StringValue", "StringValue", 1, TimeUnit.MINUTES);
//1、通过redisTemplate获取值
String str1 = (String) clusterRedisTemplate.boundValueOps("StringKey").get();
//2、通过BoundValueOperations获取值
BoundValueOperations stringKey = clusterRedisTemplate.boundValueOps("StringKey");
String str2 = (String) stringKey.get();
//3、通过ValueOperations获取值
ValueOperations ops = clusterRedisTemplate.opsForValue();
String str3 = (String) ops.get("StringKey");
基本API
//删除key
clusterRedisTemplate.delete(keys);
//指定key的失效时间
clusterRedisTemplate.expire(key,time,TimeUnit.MINUTES);
//根据key获取过期时间
Long expire = clusterRedisTemplate.getExpire(key);
//判断key是否存在
clusterRedisTemplate.hasKey(key);
//顺序递增
clusterRedisTemplate.boundValueOps("StringKey").increment(3L);
//顺序递减
clusterRedisTemplate.boundValueOps("StringKey").increment(-3L);
Hash类型相关操作
1、设置值
//1、通过redisTemplate设置值
clusterRedisTemplate.boundHashOps("HashKey").put("SmallKey", "HashVaue");
//2、通过BoundValueOperations设置值
BoundHashOperations hashKey = clusterRedisTemplate.boundHashOps("HashKey");
hashKey.put("SmallKey", "HashVaue");
//3、通过ValueOperations设置值
HashOperations hashOps = clusterRedisTemplate.opsForHash();
hashOps.put("HashKey", "SmallKey", "HashVaue");
2、设置过期时间(单独设置)
clusterRedisTemplate.boundValueOps("HashKey").expire(1,TimeUnit.MINUTES);
clusterRedisTemplate.expire("HashKey",1,TimeUnit.MINUTES);
3、添加一个Map集合
HashMap<String, String> hashMap = new HashMap<>();
clusterRedisTemplate.boundHashOps("HashKey").putAll(hashMap);
4、提取Hash中的小key
//1、通过redisTemplate获取值
Set keys1 = clusterRedisTemplate.boundHashOps("HashKey").keys();
//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = clusterRedisTemplate.boundHashOps("HashKey");
Set keys2 = hashKey.keys();
//3、通过ValueOperations获取值
HashOperations hashOps = clusterRedisTemplate.opsForHash();
Set keys3 = hashOps.keys("HashKey");
5、提取所有的value值
//1、通过redisTemplate获取值
List values1 = clusterRedisTemplate.boundHashOps("HashKey").values();
//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = clusterRedisTemplate.boundHashOps("HashKey");
List values2 = hashKey.values();
//3、通过ValueOperations获取值
HashOperations hashOps = clusterRedisTemplate.opsForHash();
List values3 = hashOps.values("HashKey");
6、根据Hash的key提取value值
//1、通过redisTemplate获取
String value1 = (String) clusterRedisTemplate.boundHashOps("HashKey").get("SmallKey");
//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = clusterRedisTemplate.boundHashOps("HashKey");
String value2 = (String) hashKey.get("SmallKey");
//3、通过ValueOperations获取值
HashOperations hashOps = clusterRedisTemplate.opsForHash();
String value3 = (String) hashOps.get("HashKey", "SmallKey");
7、获取所有的键值对集合
//1、通过redisTemplate获取
Map entries = clusterRedisTemplate.boundHashOps("HashKey").entries();
//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = clusterRedisTemplate.boundHashOps("HashKey");
Map entries1 = hashKey.entries();
//3、通过ValueOperations获取值
HashOperations hashOps = clusterRedisTemplate.opsForHash();
Map entries2 = hashOps.entries("HashKey");
8、删除
//删除小key
clusterRedisTemplate.boundHashOps("HashKey").delete("SmallKey");
//删除大key
clusterRedisTemplate.delete("HashKey");
9、判断Hash中是否含有该值
Boolean isEmpty = clusterRedisTemplate.boundHashOps("HashKey").hasKey("SmallKey");
Set类型相关操作
1、添加
//1、通过redisTemplate设置值
clusterRedisTemplate.boundSetOps("setKey").add("setValue1", "setValue2", "setValue3");
//2、通过BoundValueOperations设置值
BoundSetOperations setKey = clusterRedisTemplate.boundSetOps("setKey");
setKey.add("setValue1", "setValue2", "setValue3");
//3、通过ValueOperations设置值
SetOperations setOps = clusterRedisTemplate.opsForSet();
setOps.add("setKey", "SetValue1", "setValue2", "setValue3");
2、设置过期时间(单独设置)
clusterRedisTemplate.boundValueOps("setKey").expire(1,TimeUnit.MINUTES);
clusterRedisTemplate.expire("setKey",1,TimeUnit.MINUTES);
3、根据key获取Set中的所有值
//1、通过redisTemplate获取值
Set set1 = clusterRedisTemplate.boundSetOps("setKey").members();
//2、通过BoundValueOperations获取值
BoundSetOperations setKey = clusterRedisTemplate.boundSetOps("setKey");
Set set2 = setKey.members();
//3、通过ValueOperations获取值
SetOperations setOps = clusterRedisTemplate.opsForSet();
Set set3 = setOps.members("setKey");
4、查询value是否已存在
Boolean isEmpty = clusterRedisTemplate.boundSetOps("setKey").isMember("setValue2");
5、获取Set的长度
Long size = clusterRedisTemplate.boundSetOps("setKey").size();
6、移除指定的元素
Long result1 = clusterRedisTemplate.boundSetOps("setKey").remove("setValue1");
7、移除指定的key
Boolean result2 = clusterRedisTemplate.delete("setKey");
LIST类型相关操作
1、添加
//1、通过redisTemplate设置值
clusterRedisTemplate.boundListOps("listKey").leftPush("listLeftValue1");
clusterRedisTemplate.boundListOps("listKey").rightPush("listRightValue2");
//2、通过BoundValueOperations设置值
BoundListOperations listKey = clusterRedisTemplate.boundListOps("listKey");
listKey.leftPush("listLeftValue3");
listKey.rightPush("listRightValue4");
//3、通过ValueOperations设置值
ListOperations opsList = clusterRedisTemplate.opsForList();
opsList.leftPush("listKey", "listLeftValue5");
opsList.rightPush("listKey", "listRightValue6");
2、将Java的List集合放入List类型
ArrayList<String> list = new ArrayList<>();
clusterRedisTemplate.boundListOps("listKey").rightPushAll(list);
clusterRedisTemplate.boundListOps("listKey").leftPushAll(list);
3、设置过期时间(单独设置)
clusterRedisTemplate.boundValueOps("listKey").expire(1,TimeUnit.MINUTES);
clusterRedisTemplate.expire("listKey",1,TimeUnit.MINUTES);
4、获取List缓存全部内容(起始索引,结束索引)
List listKey1 = clusterRedisTemplate.boundListOps("listKey").range(0, 10);
5、从左或从右弹出一个元素
String listKey2 = (String) clusterRedisTemplate.boundListOps("listKey").leftPop(); //从左侧弹出一个元素
String listKey3 = (String) clusterRedisTemplate.boundListOps("listKey").rightPop(); //从右侧弹出一个元素
6、根据索引查询元素
String listKey4 = (String) clusterRedisTemplate.boundListOps("listKey").index(1);
7、获取List缓存的长度
Long size = clusterRedisTemplate.boundListOps("listKey").size();
8、根据索引修改List中的某条数据(key,索引,值)
clusterRedisTemplate.boundListOps("listKey").set(3L,"listLeftValue3");
9、移除N个值为value(key,移除个数,值)
clusterRedisTemplate.boundListOps("listKey").remove(3L,"value");
Zset类型的相关操作
1、向集合中插入元素,并设置分数
//1、通过redisTemplate设置值
clusterRedisTemplate.boundZSetOps("zSetKey").add("zSetVaule", 100D);
//2、通过BoundValueOperations设置值
BoundZSetOperations zSetKey = clusterRedisTemplate.boundZSetOps("zSetKey");
zSetKey.add("zSetVaule", 100D);
//3、通过ValueOperations设置值
ZSetOperations zSetOps = clusterRedisTemplate.opsForZSet();
zSetOps.add("zSetKey", "zSetVaule", 100D);
2、向集合中插入多个元素,并设置分数
DefaultTypedTuple<String> p1 = new DefaultTypedTuple<>("zSetVaule1", 2.1D);
DefaultTypedTuple<String> p2 = new DefaultTypedTuple<>("zSetVaule2", 3.3D);
clusterRedisTemplate.boundZSetOps("zSetKey").add(new HashSet<>(Arrays.asList(p1,p2)));
3、按照排名先后(从小到大)打印指定区间内的元素, -1为打印全部
Set<String> range = clusterRedisTemplate.boundZSetOps("zSetKey").range(key, 0, -1);
4、获得指定元素的分数
Double score = clusterRedisTemplate.boundZSetOps("zSetKey").score("zSetVaule");
5、返回集合内的成员个数
Long size = clusterRedisTemplate.boundZSetOps("zSetKey").size();
6、返回集合内指定分数范围的成员个数(Double类型)
Long count = clusterRedisTemplate.boundZSetOps("zSetKey").count(0D, 2.2D);
7、返回集合内元素在指定分数范围内的排名(从小到大)
Set byScore = clusterRedisTemplate.boundZSetOps("zSetKey").rangeByScore(0D, 2.2D);
8、带偏移量和个数,(key,起始分数,最大分数,偏移量,个数)
Set<String> ranking2 = clusterRedisTemplate.opsForZSet().rangeByScore("zSetKey", 0D, 2.2D 1, 3);
9、返回集合内元素的排名,以及分数(从小到大)
Set<TypedTuple<String>> tuples = clusterRedisTemplate.boundZSetOps("zSetKey").rangeWithScores(0L, 3L);
for (TypedTuple<String> tuple : tuples) {
System.out.println(tuple.getValue() + " : " + tuple.getScore());
}
10、返回指定成员的排名
//从小到大
Long startRank = clusterRedisTemplate.boundZSetOps("zSetKey").rank("zSetVaule");
//从大到小
Long endRank = clusterRedisTemplate.boundZSetOps("zSetKey").reverseRank("zSetVaule");
11、从集合中删除指定元素
clusterRedisTemplate.boundZSetOps("zSetKey").remove("zSetVaule");
12、删除指定索引范围的元素(Long类型)
clusterRedisTemplate.boundZSetOps("zSetKey").removeRange(0L,3L);
13、删除指定分数范围内的元素(Double类型)
clusterRedisTemplate.boundZSetOps("zSetKey").removeRangeByScorssse(0D,2.2D);
14、为指定元素加分(Double类型)
Double score = clusterRedisTemplate.boundZSetOps("zSetKey").incrementScore("zSetVaule",1.1D);