文章目录
SpringBoot整合Redis Cluster 集群 以及Redis存储结构 String Hash set zSet List 的使用
（1）创建SpringBoot工程
创建过程我这里就略了…
如果linux/Redhat 服务器上未安装Redis 可参考我的文章Centos7 Redis5.0.5 三主三从Cluster集群安装和集群遇到的错误解决
（2）整合所需依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- SpringBoot2以后底层默认使用lettuce，同时依赖于commons-pool2依赖-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
<!--lombok 简化pojo类-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
因为我还测试了一系列Json的用法，以及项目中会经常性存储JSON字符串到Redis中，所以还需要一个JSON依赖，我这里使用的是阿里的
<!--阿里json-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.58</version>
</dependency>
（3）YML文件配置
SpringBoot工程的配置文件我习惯性使用yml格式，如项目所用properties格式则自己修改就可
spring:
redis:
timeout: 15000 #连接超时时间
password: pwd #密碼
cluster:
max-redirects: 6 # 获取失败 最大重定向次数
nodes: #Redis集群的节点
- 47.97.118.22:7000
- 47.97.118.22:7001
- 47.97.118.22:7002
- 47.97.118.22:7003
- 47.97.118.22:7004
- 47.97.118.22:7005
lettuce: #连接池使用lettuce lettuce主要利用netty实现与redis的同步和异步通信可多个线程间并发访问，是线程安全的 jedis在多线程环境下是非线程安全的
pool:
max-active: 1000 #连接池最大连接数（使用负值表示没有限制）
max-idle: 10 # 连接池中的最大空闲连接
min-idle: 5 # 连接池中的最小空闲连接
max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
说明：我项目redis连接池使用的lettuce lettuce主要利用netty实现与redis的同步和异步通信可多个线程间并发访问，是线程安全的 jedis在多线程环境下是非线程安全的
（4）实例化 RedisTemplate 对象配置
此对象配置主要是设置数据存入 redis 的序列化方式,并开启事务 避免中文存储像乱码一般 以及规定使用RedisTemplate 时的存储格式
配置类如下
package com.leilei.config;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* @author : leilei
* @date : 15:59 2020/2/17
* @desc : 实例化 RedisTemplate 对象 配置
*/
@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisConfig {
/**
* 实例化 RedisTemplate 对象
*
* @return
*/
@Bean
public RedisTemplate<String, Object> functionDomainRedisTemplate(
LettuceConnectionFactory lettuceConnectionFactory) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
initDomainRedisTemplate(redisTemplate, lettuceConnectionFactory);
return redisTemplate;
}
/**
* 设置数据存入 redis 的序列化方式,并开启事务
*
* @param redisTemplate
* @param factory
*/
private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, LettuceConnectionFactory factory) {
// 如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
// 开启事务
redisTemplate.setEnableTransactionSupport(true);
redisTemplate.setConnectionFactory(factory);
}
}
（5）使用Redis工具类进行操作
redis 工具类很多，可以自行测试百度 没问题以后·可以放入项目中使用
注意：工具类注入的RedisTemplate 须和RedisConfig配置类的泛型一致 否则操操作时报错
注意：如需使用StringRedisTemplate ,则和本文章的Redis工具类无关，请自行使用StringRedisTemplate自带的方法
package com.leilei.util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* @author : leilei
* @date : 16:59 2020/2/18
* @desc : Redis String Map set list 存储操作工具类
*/
@Component
public class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
public boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
// ============================String=============================
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期 单位为秒
* @return true成功 false 失败
*/
public boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
// ================================Map=================================
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmset(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
* @return
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0)
expire(key, time);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
* @return
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================list=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
* @return
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
* @return
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0)
expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0)
expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
2020/05/07 补充：
Redis操作工具类 添加Zset 操作 可自己copy到工具类中
/**
* 添加一个
*
* @param key zset 集合名
* @param value 存放的值
* @param score zet 中分数 默认升序排列
* @return
*/
public boolean sZset(String key, Object value, double score) {
try {
return redisTemplate.opsForZSet().add(key, value, score);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向zset集合中批量添加数据
* @param key
* @param tuples
* @return
*/
public Long sZsetList(String key, Set<TypedTuple<Object>> tuples) {
try {
return redisTemplate.opsForZSet().add(key, tuples);
} catch (Exception e) {
e.printStackTrace();
return 0L;
}
}
/**
* 删除元素 zrem 可同时删除多个值
*
* @param key zset 集合名
* @param value 要删除的value值 可变参数
*/
public Long zRemove(String key, Object... value) {
try {
return redisTemplate.opsForZSet().remove(key, value);
} catch (Exception e) {
e.printStackTrace();
return 0L;
}
}
/**
* score的增加or减少 zincrby 正数为增 负数为减
*
* @param key
* @param value
* @param score
*/
public Double zIncrScore(String key, String value, double score) {
try {
return redisTemplate.opsForZSet().incrementScore(key, value, score);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 查询value对应的score zscore
*
* @param key
* @param value
* @return
*/
public Double zScore(String key, String value) {
try {
return redisTemplate.opsForZSet().score(key, value);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 判断value在zset中的排名 zrank 返回的是位于为zet集合中索引值
*
* @param key
* @param value
* @return
*/
public Long zRank(String key, String value) {
try {
return redisTemplate.opsForZSet().rank(key, value);
} catch (Exception e) {
e.printStackTrace();
return -1L;
}
}
/**
* 查询集合中指定顺序的值， 0 -1 表示获取全部的集合内容 zrange
*
* 返回有序的集合，score小的在前面 （正序）
*
* @param key
* @param start 开始
* @param end 结束
* @return value的set集合
*/
public Set<Object> zRange(String key, int start, int end) {
return redisTemplate.opsForZSet().range(key, start, end);
}
/**
* 查询集合中指定顺序的值 zrevrange 0 -1 表示获取全部的集合内容
*
* 返回有序的集合中，score大的在前面 （倒序）
*
* @param key
* @param start
* @param end
* @return
*/
public Set<Object> reverseRange(String key, int start, int end) {
return redisTemplate.opsForZSet().reverseRange(key, start, end);
}
/**
* 查询集合中指定顺序的值和score，0, -1 表示获取全部的集合内容
*
* @param key
* @param start
* @param end
* @return
*/
public Set<ZSetOperations.TypedTuple<Object>> rangeWithScore(String key, int start, int end) {
return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
}
/**
* 根据score的值，来获取满足条件的集合 zrangebyscore
*
* @param key
* @param min
* @param max
* @return
*/
public Set<Object> rangeByScore(String key, double min, double max) {
return redisTemplate.opsForZSet().rangeByScore(key, min, max);
}
/**
* 根据score的值，来获取满足条件的集合 取出结果后根据索引 以及count 拿到元素集合
* @param key zset键
* @param min score 最小值 （条件）
* @param max score 最大值 （条件）
* @param offset 从score 拿到集合后 从offset 索引处取值
* @param count 总共取多少个元素
* @return 返回新的集合
*/
public Set<Object> rangeByScore(String key, double min, double max,Long offset,Long count) {
return redisTemplate.opsForZSet().rangeByScore(key, min, max,offset,count);
}
/**
* 返回集合的长度
*
* @param key
* @return
*/
public Long zSize(String key) {
return redisTemplate.opsForZSet().zCard(key);
}
（6）测试案例
（1） String
@Test
public void testString() {
redisUtil.set("a", 11111);
System.out.println(redisUtil.get("a"));
redisUtil.set("过期时间测试", 123, 50);
redisUtil.del("a");
}
（2）Map
@Test
public void testMapSuper() {
HashMap<String, Object> map = new HashMap<>();
map.put("a", 1L);
map.put("b", 2D);
map.put("c", 123);
map.put("d", LocalDateTime.now());
redisUtil.hmset("leilei:1:map", map);
redisUtil.hmset("leilei:2:map", map);
redisUtil.hmset("leilei:3:map", map);
redisUtil.hmset("leilei:4:map", map);
}
@Test
public void testMap2Bean (){
Map<String, Object> map = new HashMap<>();
map.put("username","王五");
map.put("password","123");
map.put("age",11);
redisUtil.hmset("Map2Bean", map);
Map<Object, Object> map2Bean = redisUtil.hmget("Map2Bean");
User user = mapToBean(map2Bean, new User());
System.out.println("Map2Bean"+user);
}
/**
* map转对象
*
* @param map
* @param bean
* @param <T>
* @return
*/
public static <T> T mapToBean(Map<Object, Object> map, T bean) {
BeanMap beanMap = BeanMap.create(bean);
beanMap.putAll(map);
return bean;
}
XXX:XX:map 这种键值 存入Redis中，用可视化工具看着会非常有趣，如同一个MYsql 中一个库中多张表
图如下：
（3）Set
注意：Set存储 不允许存在重复值,（其实可实现简单地数字排序），若真的需要排序功能 请使用zset
@Test
public void testSet() {
redisUtil.sSet("Set集合", 3,3,12, 1, 2, 5, 12, 666);
}
@Test
public void testSetBean() {
long l = redisUtil.sSet("魏将",
new User("许褚", "qq", 55),
new User("张辽", "dd", 62),
new User("典韦", "123", 49));
System.out.println(l);
}
（4）List
list 存入Redis不会排序 ，只会根据其放入的顺序生成索引，，也可通过索引取出对应值
@Test
public void testList() {
redisUtil.lSet("LIst测试", 1);
redisUtil.lSet("LIst测试", 2);
redisUtil.lSet("LIst测试", "aaaa");
List<Object> list = redisUtil.lGet("LIst测试", 1, 2);
System.out.println(list);
System.out.println(redisUtil.lGetListSize("LIst测试"));
System.out.println(redisUtil.lGetIndex("LIst测试", 2));
List<Object> listo = new ArrayList<>();
listo.add(1);
listo.add(2);
User user = new User();
user.setUsername("aa");
user.setPassword("123");
user.setAge(12);
listo.add(JSON.toJSONString(user));
redisUtil.lSet("list与json测试", listo);
String s = (String) redisUtil.lGetIndex("list与json测试", 2);
User user1 = JSON.parseObject(s, User.class);
System.out.println(user1);
}
（5）FastJson的使用
/**
* fastjson 部分使用
*/
@Test
public void testFastJson (){
//Java对象转json字符串
User aa = new User("aa", "123456", 15);
System.out.println(aa); //User(username=aa, password=123456, age=15)
String s = JSON.toJSONString(aa);
System.out.println(s); //{"age":15,"password":"123456","username":"aa"}
//json字符串转java对象
String ss = "{\"age\":15,\"password\":\"123456\",\"username\":\"aa\"}";
User user = JSON.parseObject(ss, User.class);
System.out.println(user); //User(username=aa, password=123456, age=15)
//Java集合转json字符串
List<Serializable> serializables = Arrays.asList(new User("a", "a", 1), new User("b", "b", 2));
String jsonString = JSON.toJSONString(serializables);
System.out.println(jsonString); //[{"age":1,"password":"a","username":"a"},{"age":2,"password":"b","username":"b"}]
//json字符串转java集合
String jsonlistString = "[{\"age\":1,\"password\":\"a\",\"username\":\"a\"},{\"age\":2,\"password\":\"b\",\"username\":\"b\"}]";
List<User> users = JSON.parseArray(jsonlistString, User.class);
users.forEach(e-> System.out.println(e)); //User(username=a, password=a, age=1) User(username=b, password=b, age=2)
//map转Json字符串
HashMap<String, Object> objectObjectHashMap = new HashMap<>();
objectObjectHashMap.put("a", 1);
objectObjectHashMap.put("b", 2L);
objectObjectHashMap.put("c", 3D);
objectObjectHashMap.put("d", 3f);
objectObjectHashMap.put("f", LocalDateTime.now());
String mapjsonString = JSON.toJSONString(objectObjectHashMap);
System.out.println(mapjsonString); //{"a":1,"b":2,"c":3.0,"d":3.0,"f":"2020-02-18T16:40:01.203"}
//map转json对象
JSONObject mapjsonobj = new JSONObject(objectObjectHashMap);
System.out.println("map转json对象"+mapjsonobj);
//json字符串转Map
//需要将json字符串转为json对象 json对象再转为map
JSONObject jsonObject = JSONObject.parseObject(mapjsonString);
Map<String,Object> map = (Map<String,Object>)jsonObject;
for (Map.Entry<String, Object> stringObjectEntry : map.entrySet()) {
System.out.println(stringObjectEntry.getKey() + "-------" + stringObjectEntry.getValue());
//a-------1
//b-------2
//c-------3.0
//d-------3.0
//f-------2020-02-18T16:45:37.452
}
}
（6）补充有序集合Zset的使用
zset 存储类型是Redis中 有序存储结构 其排列顺序是根据 score 正序排列 ，使用场景有 游戏排行榜/今日热门数据等等
/**
* test 添加
*/
@Test
public void test() {
redisUtil.sZset("天梯排行榜", "张三", 2);
redisUtil.sZset("天梯排行榜", "逍遥子", 1);
redisUtil.sZset("天梯排行榜", "无崖子", 3);
}
/**
* test zset 批量添加
*/
@Test
public void test1() {
DefaultTypedTuple<Object> a = new DefaultTypedTuple<>("张三丰大弟子", 3.2);
DefaultTypedTuple<Object> b = new DefaultTypedTuple<>("宋青书", 9.8);
DefaultTypedTuple<Object> c = new DefaultTypedTuple<>("时间刺客罗", 8.5);
Set<TypedTuple<Object>> defaultTypedTuples = new HashSet<>(Arrays.asList(a, b, c));
Long add = redisUtil.sZsetList("天梯排行榜", defaultTypedTuples);
System.out.println(add);
}
zset 操作命令大多与set一致，下边附上我的测试代码，大家可进行测试，在redisutil工具类中，我也详细写出了方法所需参数以及方法作用
/**
* test 获取排名 （返回位于zset集合中的索引值!!!!!）
*/
@Test
public void test2() {
Long aLong = redisUtil.zRank("天梯排行榜", "无崖子");
System.out.println(aLong);
}
/**
* test
*/
@Test
public void test3() {
redisUtil.zIncrScore("天梯排行榜", "无崖子", -0.5);
}
/**
* test 删除 可填入多个value
*/
@Test
public void test4() {
Long aLong = redisUtil.zRemove("天梯排行榜", "无崖子");
System.out.println(aLong);
}
/**
* test 获取score值
*/
@Test
public void test5() {
Double aDouble = redisUtil.zScore("天梯排行榜", "逍遥子");
System.out.println(aDouble);
}
/**
* test 获取zset集合大小
*/
@Test
public void test6() {
Long size = redisUtil.zSize("天梯排行榜");
System.out.println(size);
}
/**
* test 获取集合中的数据 正序倒序 获取指定范围数据
*/
@Test
public void test7() {
//正序
Set<Object> set = redisUtil.zRange("天梯排行榜", 0, -1);
set.forEach(e -> System.out.println(e));
System.out.println("---------");
//倒序
Set<Object> set1 = redisUtil.reverseRange("天梯排行榜", 0, -1);
set1.forEach(e -> System.out.println(e));
}
/**
* test 根据索引范围 获取某zset集合中 value 和 score
*/
@Test
public void test8() {
Set<TypedTuple<Object>> set = redisUtil.rangeWithScore("天梯排行榜", 0, -1);
for (TypedTuple<Object> objectTypedTuple : set) {
System.out.println(objectTypedTuple.getValue() + " == " + objectTypedTuple.getScore());
}
}
/**
* test 根据分数最大最小值获取set集合后再根据 索引以及显示个数返回全新set集合
*/
@Test
public void test9() {
Set<Object> set = redisUtil.rangeByScore("天梯排行榜", 1, 10);
//[逍遥子, 张三, 张三丰大弟子, 时间刺客罗, 宋青书]
System.out.println(set);
Set<Object> set1 = redisUtil.rangeByScore("天梯排行榜", 1, 10, 2L, 2L);
//[张三丰大弟子, 时间刺客罗]
System.out.println(set1);
}
附上list set zset 三者之间的区别关系图表
结语 项目地址
文章到这里就暂时结束了，，后续随着不断深入将继续更新
附上我的项目源码：springboot-redis-cluster
扫一扫
769
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
