凡人多烦事01

这个屌丝很懒，什么也没留下！

热门标签

微服务SpringBoot集成Redis 开始使用操作String、List、hash、Zset数据类型_spring redis list

作者：凡人多烦事01 | 2024-06-14 02:08:12

踩

spring redis list

微服务SpringBoot集成Redis

废话不多说，直接快速入门

1.导入jar包

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
1
2
3
4

2.在application.yml中配置redis

spring:
  redis:
    host: 106.14.171.136
    port: 6379
1
2
3
4

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
1
2
3
4
5

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是更好的选择。
1
2
3
4
5
6
7
8
9

4.操作String结构类型

1.普通插入和得到

首先先注入StringRedisTemplate和RedisTemplate

	@Autowired
    RedisTemplate redisTemplate;
    @Autowired
    StringRedisTemplate stringRedisTemplate;
1
2
3
4

下面我给出StringRedisTemplate和RedisTemplate这两种存储的区别：

RedisTemplate：

		 // 添加
        RedisTemplate.opsForValue().set("xiaobai","xiaobai");
        // 查
        String value = (String) RedisTemplate.opsForValue().get("xiaobai");
        // 删除
        RedisTemplate.delete("xiaobai");
1
2
3
4
5
6

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aFQfk0mw-1589282352228)(C:\Users\臭屁周\AppData\Roaming\Typora\typora-user-images\1588953270508.png)]$

StringRedisTemplate:

		 // 添加
        stringRedisTemplate.opsForValue().set("xiaobai","xiaobai");
        // 查
        String value = (String) stringRedisTemplate.opsForValue().get("xiaobai");
        // 删除
        stringRedisTemplate.delete("xiaobai");
1
2
3
4
5
6

1588953331125

由此可以看出StringRedisTemplate和RedisTemplate的区别，所以当你存储的是String类型的话，就用StringRedisTemplate比较好。

2.添加自动失效时间

		/**
         * 参数：
         * 1.key
         * 2.value
         * 3.存储时间值
         * 4.存储时间的单位
         */
        stringRedisTemplate.opsForValue().set("xiaobai2","xiaobai",10, TimeUnit.HOURS);
1
2
3
4
5
6
7
8

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("英雄","郭嘉");

        /*
            这样的插入的顺序应该是：刘备、关羽、张飞、曹操、许褚、郭嘉
         */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zfkrr2Tv-1589282352240)(C:\Users\臭屁周\AppData\Roaming\Typora\typora-user-images\image-20200509171217657.png)]$

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);
1
2
3
4
5
6
7
8
9
10
11
12
13

可以一次性插入数据

		/*
            可以传多个值，左边插入，这样就可以直接插入进去了
         */
        stringRedisTemplate.opsForList().leftPushAll("英雄","诸葛亮","马超","赵云");
        // 从右边插入 这个就不演示了，有兴趣的小伙伴可以去演示
        stringRedisTemplate.opsForList().rightPushAll("英雄","诸葛亮","马超","赵云");
1
2
3
4
5
6

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GhfyA9wv-1589282352253)(C:\Users\臭屁周\AppData\Roaming\Typora\typora-user-images\image-20200509172105875.png)]$

2.取出数据

		// 从右边取出一个值，取出的值将会载redis中删除
        String s = stringRedisTemplate.opsForList().rightPop("英雄");
        // 从左边边取出一个值，取出的值将会载redis中删除
        String s1 = stringRedisTemplate.opsForList().leftPop("英雄");
1
2
3
4

注意：这是取出数据，当你取出数据后，数据也会在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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.取出数据

获得数据根据hash和key获得值，在redis中不会移除得到的数据

		String o = (String) stringRedisTemplate.opsForHash().get("myHashMap", "英雄");
     	System.out.println(o);
1
2

根据hash和key删除数据

		Long myHashMap = stringRedisTemplate.opsForHash().delete("myHashMap","英雄");
        System.out.println(myHashMap);
1
2

通过hash值查询数据并把数据封装到map中

 		Map<Object, Object> map = stringRedisTemplate.opsForHash().entries("myHashMap");
        System.out.println(map);
1
2

根据Hash和key 判断是否存在此值，如果有则返回true，否者返回flash

		Boolean aBoolean = stringRedisTemplate.opsForHash().hasKey("myHashMap", "英雄1");
        System.out.println(aBoolean);
1
2

查到所有的key 封装到set集合中

		Set<Object> set = stringRedisTemplate.opsForHash().keys("myHashMap");
        System.out.println(set);
1
2

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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398

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;
}

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/715840