微服务SpringBoot集成Redis 开始使用操作String、List、hash、Zset数据类型
微服务SpringBoot集成Redis
废话不多说，直接快速入门
1.导入jar包
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-data-redisartifactId>
dependency>
2.在application.yml中配置redis
spring:
redis:
host: 106.14.171.136
port: 6379
3.Redis中能够存储的类型：
| 结构类型 | 结构存储的值 | 结构的读写能力 |
|---|---|---|
| String | 可以是字符串，正数，或者浮点数 | 对整个字符串或者字符串的其中一部分执行操作；对象和浮点数执行自增或者自减 |
| List | 一个链表，链表上的每个节点都包含了一个字符串 | 从列表的两端推入或者弹出；根据偏移量对链表进行修剪，读取单个或者多个元素，根据值来查找或者移除元素 |
| Hash | 包含键值对的无序散列表 | 添加，获取，移除，单个元素对，获取所有键值对 |
| Set | 包含字符串的无序收集器，并且被包含的每个字符串都是独一无二的，宁各不相同 | 添加、获取、移除单个元素；检查一个元素或多个元素是否存在某个集合中；计算交集、并集、差集；从集合元素里随机获取元素 |
| Zset | 字符串成员与浮点数分值之间的有序映射，元素的排列顺序由分值的大小决定 | 添加、获取、删除单个元素；根据分值范围或者成员来获取元素 |
RedisTemplate redisTemplate.opsForValue();//操作字符串
RedisTemplate redisTemplate.opsForHash();//操作hash
RedisTemplate redisTemplate.opsForList();//操作list
RedisTemplate redisTemplate.opsForSet();//操作set
RedisTemplate redisTemplate.opsForZSet();//操作有序set
spring-data-redis给了5个方法，有时候不同公司，还会做不同封装，在课程中所给的CacheService工具类中
是对spring-data-redis方法的进一步封装，目的是为了操作起来更加方便。
知识小贴士：在CacheService工具类中使用的是StringRedisTemplate，他和RedisTemplate有什么区别？
1：StringRedisTemplate继承RedisTemplate
2：两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据， RedisTemplate只能管理RedisTemplate中的数据。
3：StringRedisTemplate默认采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的， RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。
当你的redis数据库里面本来存的是字符串数据或者你要存取的数据就是字符串类型数据的时候，那么你就使用 StringRedisTemplate即可，但是如果你的数据是复杂的对象类型，而取出的时候又不想做任何的数据转换，直接从 Redis里面取出一个对象，那么使用RedisTemplate是更好的选择。
4.操作String结构类型
1.普通插入和得到
首先先注入StringRedisTemplate和RedisTemplate
@Autowired
RedisTemplate redisTemplate;
@Autowired
StringRedisTemplate stringRedisTemplate;
下面我给出StringRedisTemplate和RedisTemplate这两种存储的区别：
RedisTemplate：
// 添加
RedisTemplate.opsForValue().set("xiaobai","xiaobai");
// 查
String value = (String) RedisTemplate.opsForValue().get("xiaobai");
// 删除
RedisTemplate.delete("xiaobai");
StringRedisTemplate:
// 添加
stringRedisTemplate.opsForValue().set("xiaobai","xiaobai");
// 查
String value = (String) stringRedisTemplate.opsForValue().get("xiaobai");
// 删除
stringRedisTemplate.delete("xiaobai");
由此可以看出StringRedisTemplate和RedisTemplate的区别，所以当你存储的是String类型的话，就用StringRedisTemplate比较好。
2.添加自动失效时间
/**
* 参数：
* 1.key
* 2.value
* 3.存储时间值
* 4.存储时间的单位
*/
stringRedisTemplate.opsForValue().set("xiaobai2","xiaobai",10, TimeUnit.HOURS);
5.操作List结构类型
1.插入数据
1.一次插入一个value
/**
* 这是从list数据结构左边插入
*/
stringRedisTemplate.opsForList().leftPush("英雄","张飞");
stringRedisTemplate.opsForList().leftPush("英雄","关羽");
stringRedisTemplate.opsForList().leftPush("英雄","刘备");
/**
* 这是从list数据结构右边插入
*/
stringRedisTemplate.opsForList().rightPush("英雄","曹操");
stringRedisTemplate.opsForList().rightPush("英雄","许褚");
stringRedisTemplate.opsForList().rightPush("英雄","郭嘉");
/*
这样的插入的顺序应该是：刘备、关羽、张飞、曹操、许褚、郭嘉
*/
2.一次插入多个值
根据集合集体插入
// 可以根据集合集体右边插入
List<String> list = new ArrayList<>();
list.add("马超");
list.add("诸葛亮");
list.add("赵云");
stringRedisTemplate.opsForList().rightPushAll("英雄",list);
// 可以根据集合集体左边插入
List<String> list = new ArrayList<>();
list.add("马超");
list.add("诸葛亮");
list.add("赵云");
stringRedisTemplate.opsForList().leftPushAll("英雄",list);
可以一次性插入数据
/*
可以传多个值，左边插入，这样就可以直接插入进去了
*/
stringRedisTemplate.opsForList().leftPushAll("英雄","诸葛亮","马超","赵云");
// 从右边插入 这个就不演示了，有兴趣的小伙伴可以去演示
stringRedisTemplate.opsForList().rightPushAll("英雄","诸葛亮","马超","赵云");
2.取出数据
// 从右边取出一个值，取出的值将会载redis中删除
String s = stringRedisTemplate.opsForList().rightPop("英雄");
// 从左边边取出一个值，取出的值将会载redis中删除
String s1 = stringRedisTemplate.opsForList().leftPop("英雄");
注意：这是取出数据，当你取出数据后，数据也会在redis List 集合中被移除。
6.操作hash结构数据类型
1.插入数据
/**
* 参数：
* 第一个：hash key
* 第二个：key
* 第三个：value
*/
stringRedisTemplate.opsForHash().put("myHash","英雄","诸葛亮");
// 可以设置一个map进去存储信息
Map<String,Object> map = new HashMap<>();
map.put("英雄","凤雏");
map.put("英雄1","曹操");
map.put("英雄2","马超");
stringRedisTemplate.opsForHash().putAll("myHashMap",map);
2.取出数据
获得数据根据hash和key获得值，在redis中不会移除得到的数据
String o = (String) stringRedisTemplate.opsForHash().get("myHashMap", "英雄");
System.out.println(o);
根据hash和key删除数据
Long myHashMap = stringRedisTemplate.opsForHash().delete("myHashMap","英雄");
System.out.println(myHashMap);
通过hash值查询数据并把数据封装到map中
Map<Object, Object> map = stringRedisTemplate.opsForHash().entries("myHashMap");
System.out.println(map);
根据Hash和key 判断是否存在此值，如果有则返回true，否者返回flash
Boolean aBoolean = stringRedisTemplate.opsForHash().hasKey("myHashMap", "英雄1");
System.out.println(aBoolean);
查到所有的key 封装到set集合中
Set<Object> set = stringRedisTemplate.opsForHash().keys("myHashMap");
System.out.println(set);
7.Zset数据结构
Zest集合是可以排序的，根据分数排序，所以当你添加元素，可以添加他的分数，分数可以试用当前时间的毫秒值。
我把所有的Zset集合需要的
/**
* 添加元素,有序集合是按照元素的score值由小到大排列
*
* @param key
* @param value
* @param score
* @return
*/
public Boolean zAdd(String key, String value, double score) {
return stringRedisTemplate.opsForZSet().add(key, value, score);
}
/**
*
* @param key
* @param values
* @return
*/
public Long zAdd(String key, Set<TypedTuple<String>> values) {
return stringRedisTemplate.opsForZSet().add(key, values);
}
/**
*
* @param key
* @param values
* @return
*/
public Long zRemove(String key, Object... values) {
return stringRedisTemplate.opsForZSet().remove(key, values);
}
public Long zRemove(String key, Collection<String> values) {
if(values!=null&&!values.isEmpty()){
Object[] objs = values.toArray(new Object[values.size()]);
return stringRedisTemplate.opsForZSet().remove(key, objs);
}
return 0L;
}
/**
* 增加元素的score值，并返回增加后的值
*
* @param key
* @param value
* @param delta
* @return
*/
public Double zIncrementScore(String key, String value, double delta) {
return stringRedisTemplate.opsForZSet().incrementScore(key, value, delta);
}
/**
* 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
*
* @param key
* @param value
* @return 0表示第一位
*/
public Long zRank(String key, Object value) {
return stringRedisTemplate.opsForZSet().rank(key, value);
}
/**
* 返回元素在集合的排名,按元素的score值由大到小排列
*
* @param key
* @param value
* @return
*/
public Long zReverseRank(String key, Object value) {
return stringRedisTemplate.opsForZSet().reverseRank(key, value);
}
/**
* 获取集合的元素, 从小到大排序
*
* @param key
* @param start
* 开始位置
* @param end
* 结束位置, -1查询所有
* @return
*/
public Set<String> zRange(String key, long start, long end) {
return stringRedisTemplate.opsForZSet().range(key, start, end);
}
/**
* 获取zset集合的所有元素, 从小到大排序
*
*/
public Set<String> zRangeAll(String key) {
return zRange(key,0,-1);
}
/**
* 获取集合元素, 并且把score值也获取
*
* @param key
* @param start
* @param end
* @return
*/
public Set<TypedTuple<String>> zRangeWithScores(String key, long start,
long end) {
return stringRedisTemplate.opsForZSet().rangeWithScores(key, start, end);
}
/**
* 根据Score值查询集合元素
*
* @param key
* @param min
* 最小值
* @param max
* 最大值
* @return
*/
public Set<String> zRangeByScore(String key, double min, double max) {
return stringRedisTemplate.opsForZSet().rangeByScore(key, min, max);
}
/**
* 根据Score值查询集合元素, 从小到大排序
*
* @param key
* @param min
* 最小值
* @param max
* 最大值
* @return
*/
public Set<TypedTuple<String>> zRangeByScoreWithScores(String key,
double min, double max) {
return stringRedisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
}
/**
*
* @param key
* @param min
* @param max
* @param start
* @param end
* @return
*/
public Set<TypedTuple<String>> zRangeByScoreWithScores(String key,
double min, double max, long start, long end) {
return stringRedisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max,
start, end);
}
/**
* 获取集合的元素, 从大到小排序
*
* @param key
* @param start
* @param end
* @return
*/
public Set<String> zReverseRange(String key, long start, long end) {
return stringRedisTemplate.opsForZSet().reverseRange(key, start, end);
}
public Set<String> zReverseRangeByScore(String key, long min, long max) {
return stringRedisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
}
/**
* 获取集合的元素, 从大到小排序, 并返回score值
*
* @param key
* @param start
* @param end
* @return
*/
public Set<TypedTuple<String>> zReverseRangeWithScores(String key,
long start, long end) {
return stringRedisTemplate.opsForZSet().reverseRangeWithScores(key, start,
end);
}
/**
* 根据Score值查询集合元素, 从大到小排序
*
* @param key
* @param min
* @param max
* @return
*/
public Set<String> zReverseRangeByScore(String key, double min,
double max) {
return stringRedisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
}
/**
* 根据Score值查询集合元素, 从大到小排序
*
* @param key
* @param min
* @param max
* @return
*/
public Set<TypedTuple<String>> zReverseRangeByScoreWithScores(
String key, double min, double max) {
return stringRedisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,
min, max);
}
/**
*
* @param key
* @param min
* @param max
* @param start
* @param end
* @return
*/
public Set<String> zReverseRangeByScore(String key, double min,
double max, long start, long end) {
return stringRedisTemplate.opsForZSet().reverseRangeByScore(key, min, max,
start, end);
}
/**
* 根据score值获取集合元素数量
*
* @param key
* @param min
* @param max
* @return
*/
public Long zCount(String key, double min, double max) {
return stringRedisTemplate.opsForZSet().count(key, min, max);
}
/**
* 获取集合大小
*
* @param key
* @return
*/
public Long zSize(String key) {
return stringRedisTemplate.opsForZSet().size(key);
}
/**
* 获取集合大小
*
* @param key
* @return
*/
public Long zZCard(String key) {
return stringRedisTemplate.opsForZSet().zCard(key);
}
/**
* 获取集合中value元素的score值
*
* @param key
* @param value
* @return
*/
public Double zScore(String key, Object value) {
return stringRedisTemplate.opsForZSet().score(key, value);
}
/**
* 移除指定索引位置的成员
*
* @param key
* @param start
* @param end
* @return
*/
public Long zRemoveRange(String key, long start, long end) {
return stringRedisTemplate.opsForZSet().removeRange(key, start, end);
}
/**
* 根据指定的score值的范围来移除成员
*
* @param key
* @param min
* @param max
* @return
*/
public Long zRemoveRangeByScore(String key, double min, double max) {
return stringRedisTemplate.opsForZSet().removeRangeByScore(key, min, max);
}
/**
* 获取key和otherKey的并集并存储在destKey中
*
* @param key
* @param otherKey
* @param destKey
* @return
*/
public Long zUnionAndStore(String key, String otherKey, String destKey) {
return stringRedisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey);
}
/**
*
* @param key
* @param otherKeys
* @param destKey
* @return
*/
public Long zUnionAndStore(String key, Collection<String> otherKeys,
String destKey) {
return stringRedisTemplate.opsForZSet()
.unionAndStore(key, otherKeys, destKey);
}
/**
* 交集
*
* @param key
* @param otherKey
* @param destKey
* @return
*/
public Long zIntersectAndStore(String key, String otherKey,
String destKey) {
return stringRedisTemplate.opsForZSet().intersectAndStore(key, otherKey,
destKey);
}
/**
* 交集
*
* @param key
* @param otherKeys
* @param destKey
* @return
*/
public Long zIntersectAndStore(String key, Collection<String> otherKeys,
String destKey) {
return stringRedisTemplate.opsForZSet().intersectAndStore(key, otherKeys,
destKey);
}
/**
*
* @param key
* @param options
* @return
*/
public Cursor<TypedTuple<String>> zScan(String key, ScanOptions options) {
return stringRedisTemplate.opsForZSet().scan(key, options);
}
/**
* 扫描主键，建议使用
* @param patten
* @return
*/
public Set<String> scan(String patten){
Set<String> keys = stringRedisTemplate.execute((RedisCallback<Set<String>>) connection -> {
Set<String> result = new HashSet<>();
try (Cursor<byte[]> cursor = connection.scan(new ScanOptions.ScanOptionsBuilder()
.match(patten).count(10000).build())) {
while (cursor.hasNext()) {
result.add(new String(cursor.next()));
}
} catch (IOException e) {
e.printStackTrace();
}
return result;
});
return keys;
}
/**
* 管道技术，提高性能
* @param type
* @param values
* @return
*/
public List<Object> lRightPushPipeline(String type,Collection<String> values){
List<Object> results = stringRedisTemplate.executePipelined(new RedisCallback<Object>() {
public Object doInRedis(RedisConnection connection) throws DataAccessException {
StringRedisConnection stringRedisConn = (StringRedisConnection)connection;
//集合转换数组
String[] strings = values.toArray(new String[values.size()]);
//直接批量发送
stringRedisConn.rPush(type, strings);
return null;
}
});
return results;
}
ing> values){
List results = stringRedisTemplate.executePipelined(new RedisCallback() {
public Object doInRedis(RedisConnection connection) throws DataAccessException {
StringRedisConnection stringRedisConn = (StringRedisConnection)connection;
//集合转换数组
String[] strings = values.toArray(new String[values.size()]);
//直接批量发送
stringRedisConn.rPush(type, strings);
return null;
}
});
return results;
}