1
[Unit]
2
Description=redis-server
3
After=network.target
4

5
[Service]
6
Type=forking
7
ExecStart=/usr/local/bin/redis-server /usr/local/src/redis-6.2.14/redis.conf
8
PrivateTmp=true
9

10
[Install]
11
WantedBy=multi-user.target

1
<dependency>
2
    <groupId>redis.clients</groupId>
3
    <artifactId>jedis</artifactId>
4
    <version>3.7.0</version>
5
</dependency>

1
private Jedis jedis;
2

3
@BeforeEach
4
void setUp() {
5
    // 建立连接
6
    jedis = new Jedis("192.168.150.101", 6379);
7
    // 设置密码
8
    jedis.auth("123321");
9
    // 选择库
10
    jedis.select(0);
11
}

1
@Test
2
void testString() {
3
    // 插入数据，方法名称就是redis命令名称，非常简单
4
    String result = jedis.set("name", "张三");
5
    System.out.println("result = " + result);
6
    // 获取数据
7
    String name = jedis.get("name");
8
    System.out.println("name = " + name);
9
}

1
@AfterEach
2
void tearDown() {
3
    // 释放资源
4
    if (jedis != null) {
5
        jedis.close();
6
    }
7
}

1
package com.zzyang.jedis;
2

3
import org.junit.jupiter.api.AfterEach;
4
import org.junit.jupiter.api.BeforeEach;
5
import org.junit.jupiter.api.Test;
6
import redis.clients.jedis.Jedis;
7

8
public class JedisTest {
9

10
    private Jedis jedis;
11

12
    @BeforeEach
13
    void setUp() {
14
        jedis = new Jedis("192.168.9.128", 6379);
15
        jedis.auth("Zzy20020913.");
16
        jedis.select(0);
17
    }
18

19
    @Test
20
    void testString() {
21
        String result = jedis.set("name", "zzy");
22
        System.out.println("result = " + result);
23

24
        String name = jedis.get("name");
25
        System.out.println("name = " + name);
26
    }
27

28
    @Test
29
    void testHash() {
30
        // 插入hash数据
31
        jedis.hmset("user:5", Map.of("name", "Jack"));
32
        jedis.hmset("user:5", Map.of("age", "21"));
33
        Map<String, String> map = jedis.hgetAll("user:5");
34
        System.out.println("map = " + map);
35
    }
36

37
    @AfterEach
38
    void tearDown() {
39
        if (jedis != null) {
40
            jedis.close();
41
        }
42
    }
43
}

1
package com.zzyang.jedis.utils;
2

3
import redis.clients.jedis.Jedis;
4
import redis.clients.jedis.JedisPool;
5
import redis.clients.jedis.JedisPoolConfig;
6

7
public class JedisConnectionFactory {
8

9
    private static final JedisPool jedisPool;
10

11
    static {
12
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
13
        jedisPoolConfig.setMaxTotal(8); // 最大连接数
14
        jedisPoolConfig.setMaxIdle(8);  // 最大空闲连接数
15
        jedisPoolConfig.setMinIdle(0);   // 最小空闲连接数
16
        jedisPoolConfig.setMaxWaitMillis(1000); // 设置获取连接的最大等待时间，单位毫秒
17
        jedisPool = new JedisPool(jedisPoolConfig, "192.168.9.128", 6379, 1000, "密码");
18
    }
19

20
    public static Jedis getJedis() {
21
        return jedisPool.getResource();
22
    }
23
}

1
    @BeforeEach
2
    void setUp() {
3
//        jedis = new Jedis("192.168.9.128", 6379);
4
        jedis = JedisConnectionFactory.getJedis();
5
        jedis.auth("Zzy20020913.");
6
        jedis.select(0);
7
    }

1
<!--Redis依赖-->
2
<dependency>
3
    <groupId>org.springframework.boot</groupId>
4
    <artifactId>spring-boot-starter-data-redis</artifactId>
5
</dependency>
6
<!--连接池依赖-->
7
<dependency>
8
    <groupId>org.apache.commons</groupId>
9
    <artifactId>commons-pool2</artifactId>
10
</dependency>

1
spring:
2
  redis:
3
    host: 192.168.150.101
4
    port: 6379
5
    password: 123321
6
    lettuce:
7
      pool:
8
        max-active: 8  # 最大连接
9
        max-idle: 8    # 最大空闲连接
10
        min-idle: 0    # 最小空闲连接
11
        max-wait: 100  # 连接等待时间

1
@Autowired
2
private RedisTemplate redisTemplate;

1
@SpringBootTest
2
public class RedisTest {
3

4
    @Autowired
5
    private RedisTemplate redisTemplate;
6

7
    @Test
8
    void testString() {
9
        // 插入一条string类型数据
10
        redisTemplate.opsForValue().set("name", "李四");
11
        // 读取一条string类型数据
12
        Object name = redisTemplate.opsForValue().get("name");
13
        System.out.println("name = " + name);
14
    }
15
}

1
@Configuration
2
public class RedisConfiguration {
3
    @Bean
4
    @SuppressWarnings("all")
5
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
6

7
        // 我们为了自己开发方便，一般直接使用 <String, Object>
8
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
9
        template.setConnectionFactory(factory);
10

11
        // Json序列化配置
12
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
13
        ObjectMapper om = new ObjectMapper();
14
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
15
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
16
        jackson2JsonRedisSerializer.setObjectMapper(om);
17

18
        // String 的序列化
19
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
20

21
        // key采用String的序列化方式
22
        template.setKeySerializer(stringRedisSerializer);
23

24
        // hash的key也采用String的序列化方式
25
        template.setHashKeySerializer(stringRedisSerializer);
26

27
        // value序列化方式采用jackson
28
        template.setValueSerializer(jackson2JsonRedisSerializer);
29

30
        // hash的value序列化方式采用jackson
31
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
32
        template.afterPropertiesSet();
33
        return template;
34
    }
35
}

1
/**
2
 * Redis工具类
3
 */
4
@Component
5
public class RedisUtil {
6

7
    @Autowired
8
    private RedisTemplate redisTemplate;
9

10
    /****************** common start ****************/
11
    /**
12
     * 指定缓存失效时间
13
     * @param key 键
14
     * @param time 时间(秒)
15
     * @return
16
     */
17
    public boolean expire(String key, long time) {
18
        try {
19
            if (time > 0) {
20
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
21
            }
22
            return true;
23
        } catch (Exception e) {
24
            e.printStackTrace();
25
            return false;
26
        }
27
    }
28

29
    /**
30
     * 根据key 获取过期时间
31
     * @param key 键 不能为null
32
     * @return 时间(秒) 返回0代表为永久有效
33
     */
34
    public long getExpire(String key) {
35
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
36
    }
37

38
    /**
39
     * 判断key是否存在
40
     * @param key 键
41
     * @return true 存在 false不存在
42
     */
43
    public boolean hasKey(String key) {
44
        try {
45
            return redisTemplate.hasKey(key);
46
        } catch (Exception e) {
47
            e.printStackTrace();
48
            return false;
49
        }
50
    }
51

52
    /**
53
     * 删除缓存
54
     * @param key 可以传一个值 或多个
55
     */
56
    @SuppressWarnings("unchecked")
57
    public void del(String... key) {
58
        if (key != null && key.length > 0) {
59
            if (key.length == 1) {
60
                redisTemplate.delete(key[0]);
61
            } else {
62
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
63
            }
64
        }
65
    }
66
    /****************** common end ****************/
67

68

69
    /****************** String start ****************/
70

71
    /**
72
     * 普通缓存获取
73
     * @param key 键
74
     * @return 值
75
     */
76
    public Object get(String key) {
77
        return key == null ? null : redisTemplate.opsForValue().get(key);
78
    }
79

80
    /**
81
     * 普通缓存放入
82
     * @param key 键
83
     * @param value 值
84
     * @return true成功 false失败
85
     */
86
    public boolean set(String key, Object value) {
87
        try {
88
            redisTemplate.opsForValue().set(key, value);
89
            return true;
90
        } catch (Exception e) {
91
            e.printStackTrace();
92
            return false;
93
        }
94
    }
95
    /**
96
     * 普通缓存放入并设置时间
97
     * @param key 键
98
     * @param value 值
99
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
100
     * @return true成功 false 失败
101
     */
102
    public boolean set(String key, Object value, long time) {
103
        try {
104
            if (time > 0) {
105
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
106
            } else {
107
                set(key, value);
108
            }
109
            return true;
110
        } catch (Exception e) {
111
            e.printStackTrace();
112
            return false;
113
        }
114
    }
115
    /**
116
     * 递增
117
     * @param key 键
118
     * @param delta 要增加几(大于0)
119
     * @return
120
     */
121
    public long incr(String key, long delta) {
122
        if (delta < 0) {
123
            throw new RuntimeException("递增因子必须大于0");
124
        }
125
        return redisTemplate.opsForValue().increment(key, delta);
126
    }
127
    /**
128
     * 递减
129
     * @param key 键
130
     * @param delta 要减少几(小于0)
131
     * @return
132
     */
133
    public long decr(String key, long delta) {
134
        if (delta < 0) {
135
            throw new RuntimeException("递减因子必须大于0");
136
        }
137
        return redisTemplate.opsForValue().increment(key, -delta);
138
    }
139
    /****************** String end ****************/
140

141

142
    /****************** Map start ****************/
143

144
    /**
145
     * HashGet
146
     * @param key 键 不能为null
147
     * @param item 项 不能为null
148
     * @return 值
149
     */
150
    public Object hget(String key, String item) {
151
        return redisTemplate.opsForHash().get(key, item);
152
    }
153
    /**
154
     * 获取hashKey对应的所有键值
155
     * @param key 键
156
     * @return 对应的多个键值
157
     */
158
    public Map<Object, Object> hmget(String key) {
159
        return redisTemplate.opsForHash().entries(key);
160
    }
161
    /**
162
     * HashSet
163
     * @param key 键
164
     * @param map 对应多个键值
165
     * @return true 成功 false 失败
166
     */
167
    public boolean hmset(String key, Map<String, Object> map) {
168
        try {
169
            redisTemplate.opsForHash().putAll(key, map);
170
            return true;
171
        } catch (Exception e) {
172
            e.printStackTrace();
173
            return false;
174
        }
175
    }
176
    /**
177
     * HashSet 并设置时间
178
     * @param key 键
179
     * @param map 对应多个键值
180
     * @param time 时间(秒)
181
     * @return true成功 false失败
182
     */
183
    public boolean hmset(String key, Map<String, Object> map, long time) {
184
        try {
185
            redisTemplate.opsForHash().putAll(key, map);
186
            if (time > 0) {
187
                expire(key, time);
188
            }
189
            return true;
190
        } catch (Exception e) {
191
            e.printStackTrace();
192
            return false;
193
        }
194
    }
195
    /**
196
     * 向一张hash表中放入数据,如果不存在将创建
197
     * @param key 键
198
     * @param item 项
199
     * @param value 值
200
     * @return true 成功 false失败
201
     */
202
    public boolean hset(String key, String item, Object value) {
203
        try {
204
            redisTemplate.opsForHash().put(key, item, value);
205
            return true;
206
        } catch (Exception e) {
207
            e.printStackTrace();
208
            return false;
209
        }
210
    }
211
    /**
212
     * 向一张hash表中放入数据,如果不存在将创建
213
     * @param key 键
214
     * @param item 项
215
     * @param value 值
216
     * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
217
     * @return true 成功 false失败
218
     */
219
    public boolean hset(String key, String item, Object value, long time) {
220
        try {
221
            redisTemplate.opsForHash().put(key, item, value);
222
            if (time > 0) {
223
                expire(key, time);
224
            }
225
            return true;
226
        } catch (Exception e) {
227
            e.printStackTrace();
228
            return false;
229
        }
230
    }
231
    /**
232
     * 删除hash表中的值
233
     * @param key 键 不能为null
234
     * @param item 项 可以使多个 不能为null
235
     */
236
    public void hdel(String key, Object... item) {
237
        redisTemplate.opsForHash().delete(key, item);
238
    }
239
    /**
240
     * 判断hash表中是否有该项的值
241
     * @param key 键 不能为null
242
     * @param item 项 不能为null
243
     * @return true 存在 false不存在
244
     */
245
    public boolean hHasKey(String key, String item) {
246
        return redisTemplate.opsForHash().hasKey(key, item);
247
    }
248
    /**
249
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
250
     * @param key 键
251
     * @param item 项
252
     * @param by 要增加几(大于0)
253
     * @return
254
     */
255
    public double hincr(String key, String item, long by) {
256
        return redisTemplate.opsForHash().increment(key, item, by);
257
    }
258
    /**
259
     * hash递减
260
     * @param key 键
261
     * @param item 项
262
     * @param by 要减少记(小于0)
263
     * @return
264
     */
265
    public double hdecr(String key, String item, long by) {
266
        return redisTemplate.opsForHash().increment(key, item, -by);
267
    }
268

269

270
    /****************** Map end ****************/
271

272

273

274
    /****************** Set start ****************/
275

276
    /**
277
     * 根据key获取Set中的所有值
278
     * @param key 键
279
     * @return
280
     */
281
    public Set<Object> sGet(String key) {
282
        try {
283
            return redisTemplate.opsForSet().members(key);
284
        } catch (Exception e) {
285
            e.printStackTrace();
286
            return null;
287
        }
288
    }
289
    /**
290
     * 根据value从一个set中查询,是否存在
291
     * @param key 键
292
     * @param value 值
293
     * @return true 存在 false不存在
294
     */
295
    public boolean sHasKey(String key, Object value) {
296
        try {
297
            return redisTemplate.opsForSet().isMember(key, value);
298
        } catch (Exception e) {
299
            e.printStackTrace();
300
            return false;
301
        }
302
    }
303

304

305
    /**
306
     * 将数据放入set缓存
307
     * @param key 键
308
     * @param values 值 可以是多个
309
     * @return 成功个数
310
     */
311
    public long sSet(String key, Object... values) {
312
        try {
313
            return redisTemplate.opsForSet().add(key, values);
314
        } catch (Exception e) {
315
            e.printStackTrace();
316
            return 0;
317
        }
318
    }
319

320
    /**
321
     * 将set数据放入缓存
322
     * @param key 键
323
     * @param time 时间(秒)
324
     * @param values 值 可以是多个
325
     * @return 成功个数
326
     */
327
    public long sSetAndTime(String key, long time, Object... values) {
328
        try {
329
            Long count = redisTemplate.opsForSet().add(key, values);
330
            if (time > 0)
331
                expire(key, time);
332
            return count;
333
        } catch (Exception e) {
334
            e.printStackTrace();
335
            return 0;
336
        }
337
    }
338

339

340
    /**
341
     * 获取set缓存的长度
342
     * @param key 键
343
     * @return
344
     */
345
    public long sGetSetSize(String key) {
346
        try {
347
            return redisTemplate.opsForSet().size(key);
348
        } catch (Exception e) {
349
            e.printStackTrace();
350
            return 0;
351
        }
352
    }
353

354

355
    /**
356
     * 移除值为value的
357
     * @param key 键
358
     * @param values 值 可以是多个
359
     * @return 移除的个数
360
     */
361
    public long setRemove(String key, Object... values) {
362
        try {
363
            Long count = redisTemplate.opsForSet().remove(key, values);
364
            return count;
365
        } catch (Exception e) {
366
            e.printStackTrace();
367
            return 0;
368
        }
369
    }
370

371

372
    /****************** Set end ****************/
373

374
    /****************** List start ****************/
375

376
    /**
377
     * 获取list缓存的内容
378
     * @param key 键
379
     * @param start 开始
380
     * @param end 结束 0 到 -1代表所有值
381
     * @return
382
     */
383
    public List<Object> lGet(String key, long start, long end) {
384
        try {
385
            return redisTemplate.opsForList().range(key, start, end);
386
        } catch (Exception e) {
387
            e.printStackTrace();
388
            return null;
389
        }
390
    }
391

392

393
    /**
394
     * 获取list缓存的长度
395
     * @param key 键
396
     * @return
397
     */
398
    public long lGetListSize(String key) {
399
        try {
400
            return redisTemplate.opsForList().size(key);
401
        } catch (Exception e) {
402
            e.printStackTrace();
403
            return 0;
404
        }
405
    }
406

407

408
    /**
409
     * 通过索引 获取list中的值
410
     * @param key 键
411
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
412
     * @return
413
     */
414
    public Object lGetIndex(String key, long index) {
415
        try {
416
            return redisTemplate.opsForList().index(key, index);
417
        } catch (Exception e) {
418
            e.printStackTrace();
419
            return null;
420
        }
421
    }
422

423
    /**
424
     * 将list放入缓存
425
     * @param key 键
426
     * @param value 值
427
     * @return
428
     */
429
    public boolean lSet(String key, Object value) {
430
        try {
431
            redisTemplate.opsForList().rightPush(key, value);
432
            return true;
433
        } catch (Exception e) {
434
            e.printStackTrace();
435
            return false;
436
        }
437
    }
438

439
    /**
440
     * 将list放入缓存
441
     * @param key 键
442
     * @param value 值
443
     * @param time 时间(秒)
444
     * @return
445
     */
446
    public boolean lSet(String key, Object value, long time) {
447
        try {
448
            redisTemplate.opsForList().rightPush(key, value);
449
            if (time > 0)
450
                expire(key, time);
451
            return true;
452
        } catch (Exception e) {
453
            e.printStackTrace();
454
            return false;
455
        }
456
    }
457

458
    /**
459
     * 将list放入缓存
460
     * @param key 键
461
     * @param value 值
462
     * @return
463
     */
464
    public boolean lSet(String key, List<Object> value) {
465
        try {
466
            redisTemplate.opsForList().rightPushAll(key, value);
467
            return true;
468
        } catch (Exception e) {
469
            e.printStackTrace();
470
            return false;
471
        }
472
    }
473

474
    /**
475
     * 将list放入缓存
476
     * @param key 键
477
     * @param value 值
478
     * @param time 时间(秒)
479
     * @return
480
     */
481
    public boolean lSet(String key, List<Object> value, long time) {
482
        try {
483
            redisTemplate.opsForList().rightPushAll(key, value);
484
            if (time > 0)
485
                expire(key, time);
486
            return true;
487
        } catch (Exception e) {
488
            e.printStackTrace();
489
            return false;
490
        }
491
    }
492

493
    /**
494
     * 根据索引修改list中的某条数据
495
     * @param key 键
496
     * @param index 索引
497
     * @param value 值
498
     * @return
499
     */
500
    public boolean lUpdateIndex(String key, long index, Object value) {
501
        try {
502
            redisTemplate.opsForList().set(key, index, value);
503
            return true;
504
        } catch (Exception e) {
505
            e.printStackTrace();
506
            return false;
507
        }
508
    }
509

510
    /**
511
     * 移除N个值为value
512
     * @param key 键
513
     * @param count 移除多少个
514
     * @param value 值
515
     * @return 移除的个数
516
     */
517
    public long lRemove(String key, long count, Object value) {
518
        try {
519
            Long remove = redisTemplate.opsForList().remove(key, count, value);
520
            return remove;
521
        } catch (Exception e) {
522
            e.printStackTrace();
523
            return 0;
524
        }
525
    }
526
    /****************** List end ****************/
527

528
}