工作中Redis的使用

1
@Configuration
2
public class RedisConfig {
3

4
    @Bean
5
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
6
        RedisTemplate<String, Object> template = new RedisTemplate<>();
7
        template.setConnectionFactory(factory);
8

9
        // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
10
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
11
        ObjectMapper mapper = new ObjectMapper();
12
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
13
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
14
        jackson2JsonRedisSerializer.setObjectMapper(mapper);
15

16
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
17
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
18

19
        // key采用String的序列化方式
20
        template.setKeySerializer(stringRedisSerializer);
21
        // hash的key也采用String的序列化方式
22
        template.setHashKeySerializer(stringRedisSerializer);
23
        // value序列化方式采用jackson
24
        template.setValueSerializer(jackson2JsonRedisSerializer);
25
        // hash的value序列化方式采用jackson
26
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
27

28
        template.afterPropertiesSet();
29
        return template;
30
    }
31
}

1
@Component
2
public class RedisUtils {
3

4
    @Autowired
5
    private RedisTemplate<String, Object> redisTemplate;
6

7
    // =============================String类型操作=============================
8

9
    /**
10
     * 设置缓存
11
     */
12
    public void set(String key, Object value, long time) {
13
        redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
14
    }
15

16
    /**
17
     * 获取缓存
18
     */
19
    public Object get(String key) {
20
        return key == null ? null : redisTemplate.opsForValue().get(key);
21
    }
22

23
    /**
24
     * 判断key是否存在
25
     */
26
    public Boolean hasKey(String key) {
27
        return redisTemplate.hasKey(key);
28
    }
29

30
    /**
31
     * 删除缓存
32
     */
33
    public Boolean delete(String key) {
34
        return redisTemplate.delete(key);
35
    }
36

37
    /**
38
     * 批量删除
39
     */
40
    public Long delete(Collection<String> keys) {
41
        return redisTemplate.delete(keys);
42
    }
43

44
    /**
45
     * 设置过期时间
46
     */
47
    public Boolean expire(String key, long time) {
48
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
49
    }
50

51
    /**
52
     * 获取过期时间
53
     */
54
    public Long getExpire(String key) {
55
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
56
    }
57

58
    /**
59
     * 自增
60
     */
61
    public Long increment(String key) {
62
        return redisTemplate.opsForValue().increment(key);
63
    }
64

65
    /**
66
     * 自增指定值
67
     */
68
    public Long increment(String key, long delta) {
69
        return redisTemplate.opsForValue().increment(key, delta);
70
    }
71

72
    /**
73
     * 自减
74
     */
75
    public Long decrement(String key) {
76
        return redisTemplate.opsForValue().decrement(key);
77
    }
78

79
    // =============================Hash类型操作=============================
80

81
    /**
82
     * 获取Hash中的值
83
     */
84
    public Object hGet(String key, String field) {
85
        return redisTemplate.opsForHash().get(key, field);
86
    }
87

88
    /**
89
     * 设置Hash中的值
90
     */
91
    public void hSet(String key, String field, Object value) {
92
        redisTemplate.opsForHash().put(key, field, value);
93
    }
94

95
    /**
96
     * 获取Hash中所有值
97
     */
98
    public Map<Object, Object> hGetAll(String key) {
99
        return redisTemplate.opsForHash().entries(key);
100
    }
101

102
    /**
103
     * 设置整个Hash
104
     */
105
    public void hSetAll(String key, Map<String, Object> map) {
106
        redisTemplate.opsForHash().putAll(key, map);
107
    }
108

109
    /**
110
     * 删除Hash中的字段
111
     */
112
    public Long hDelete(String key, Object... fields) {
113
        return redisTemplate.opsForHash().delete(key, fields);
114
    }
115

116
    /**
117
     * 判断Hash中是否存在该字段
118
     */
119
    public Boolean hHasKey(String key, String field) {
120
        return redisTemplate.opsForHash().hasKey(key, field);
121
    }
122

123
    // =============================List类型操作=============================
124

125
    /**
126
     * 获取List中的值
127
     */
128
    public Object lGet(String key, long index) {
129
        return redisTemplate.opsForList().index(key, index);
130
    }
131

132
    /**
133
     * 获取List指定范围内的值
134
     */
135
    public List<Object> lGet(String key, long start, long end) {
136
        return redisTemplate.opsForList().range(key, start, end);
137
    }
138

139
    /**
140
     * 从右边插入
141
     */
142
    public Long lPush(String key, Object value) {
143
        return redisTemplate.opsForList().rightPush(key, value);
144
    }
145

146
    /**
147
     * 从右边弹出
148
     */
149
    public Object rPop(String key) {
150
        return redisTemplate.opsForList().rightPop(key);
151
    }
152

153
    /**
154
     * 获取List长度
155
     */
156
    public Long lSize(String key) {
157
        return redisTemplate.opsForList().size(key);
158
    }
159
}

1
@Service
2
public class UserService {
3

4
    @Autowired
5
    private RedisUtils redisUtils;
6

7
    public User getUserById(String userId) {
8
        // 先从缓存获取
9
        Object cached = redisUtils.get("user:" + userId);
10
        if (cached != null) {
11
            return (User) cached;
12
        }
13

14
        // 缓存没有，从数据库查询
15
        User user = userMapper.selectById(userId);
16

17
        // 存入缓存，设置1小时过期
18
        if (user != null) {
19
            redisUtils.set("user:" + userId, user, 3600);
20
        }
21

22
        return user;
23
    }
24

25
    public void updateUser(User user) {
26
        // 更新数据库
27
        userMapper.updateById(user);
28

29
        // 删除缓存（保证一致性）
30
        redisUtils.delete("user:" + user.getId());
31
    }
32
}