输入key 输入value 输出key 输出value
18 | */
19 | public class MyOrderMapper extends Mapper
18 | * 实现消息过期时间的功能
19 | */
20 | @Slf4j
21 | public class ConsumerInterceptorTTL implements ConsumerInterceptor
47 | * 有很多种方法可以有效地解决缓存穿透问题，最常见的则是采用布隆过滤器，将所有可能存在的数据哈希到一个足够大的bitmap中，一个一定不存在的数据会被 这个bitmap拦截掉，
48 | * 从而避免了对底层存储系统的查询压力。另外也有一个更为简单粗暴的方法（我们采用的就是这种），如果一个查询返回的数据为空（不管是数 据不存在，还是系统故障），
49 | * 我们仍然把这个空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。
50 | *
51 | * 2. 无论db返回什么都进行缓存，但如果缓存的为空值，那么可以设置他的过期时间较短，比如五分钟
52 | */
53 | private static void bloomFilter() {
54 | int size = 1000000;
55 | BloomFilter
82 | * 简单说就是当检测到一个key失效时，对其使用分布式锁。用一个获取到锁的线程去加载数据，其他线程等在加载完成，锁被
83 | * 解除了才能够继续使用继续获取。
84 | *
85 | * 2.不由redis控制过期时间，由程序维护，无论有没有查询到数据都直接返回。在获得的数据时若发现超时，则由程序发起异步线程进行缓存更新。
86 | * 优点是不会产生死锁，缺点数据一致性较低
87 | */
88 | private static String updateCache(String key) {
89 | String stop = "stop";
90 | String value = jedis.get(key);
91 | if (value == null) {
92 | if (jedis.setnx(stop, "1") == 1) {
93 | System.out.println("已获取到锁，正在更新缓存");
94 | jedis.expire(stop, 3 * 60);
95 | value = dbGet(key);
96 | jedis.set(key, value);
97 | System.out.println("缓存更新完成！！！");
98 | jedis.del(stop);
99 | } else {
100 | try {
101 | Thread.sleep(50);
102 | } catch (InterruptedException e) {
103 | e.printStackTrace();
104 | }
105 | System.out.println("当前已被加锁，准备重试");
106 | value = updateCache(key);
107 | }
108 |
109 | }
110 | return value;
111 | }
112 |
113 | /**
114 | * 使用更好的锁方式实现，不推荐上边的加锁方式，存在线程不安全的问题
115 | *
116 | * @param key
117 | * @return
118 | */
119 | private static String safeUpdateCache(String key) {
120 | String stop = "stop";
121 | String lockId = UUID.randomUUID().toString();
122 | String value = jedis.get(key);
123 | if (value == null) {
124 | //redis分布式锁
125 | if (DistributedTool.acquireDistributedLock(jedis, stop, lockId, Long.valueOf(180))) {
126 | System.out.println("已获取到锁，正在更新缓存");
127 | value = dbGet(key);
128 | jedis.set(key, value);
129 | System.out.println("缓存更新完成！！！");
130 | DistributedTool.releaseDistributedLock(jedis, stop, lockId);
131 | } else {
132 | try {
133 | Thread.sleep(50);
134 | } catch (InterruptedException e) {
135 | e.printStackTrace();
136 | }
137 | System.out.println("当前已被加锁，准备重试");
138 | value = safeUpdateCache(key);
139 | }
140 |
141 | }
142 | return value;
143 | }
144 |
145 | /**
146 | * 2. 该种方式就是模拟当获取不到值时，使用一个新的线程进行数据库值进行更新，问题是
147 | * 这种方式问题是数据一致性较低，当第一次获取时永远时返回为空。
148 | */
149 | private static String getByTimeOut(String key) {
150 | String stop = "stop";
151 | AtomicReference
12 | * redis集群情况下可以考虑使用redisson。
13 | */
14 | public class DistributedTool {
15 |
16 | private static final Logger logger = LoggerFactory.getLogger(DistributedTool.class);
17 |
18 | private static final String LOCK_STATUS = "OK";
19 | /**
20 | * 当key不存在时进行当前操作，若存在则不操作
21 | */
22 | private static final String SET_IF_NOT_EXIST = "NX";
23 | /**
24 | * 设定key的超时时间
25 | */
26 | private static final String SET_WITH_EXPIRE_TIME = "PX";
27 |
28 | /**
29 | * @param jedis redis客户端
30 | * @param key 使用key来当作锁，保证唯一性
31 | * @param lockId 要保证每次加锁和解锁是一个来自客户端，只用一个key是无法保证的，这里使用value值作为一次完整加锁解锁请求id来保证。
32 | * @param time 超时时间，设定了超时时间后，即使持有锁的客户端发生崩溃，key也会因为过期而自动删除，从而释放锁。
33 | * @return 加锁状态
34 | */
35 | public static Boolean acquireDistributedLock(Jedis jedis, String key, String lockId, Long time) {
36 | String status = jedis.set(key, lockId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, time);
37 | if (LOCK_STATUS.equals(status)) {
38 | logger.info("获取锁成功，当前：" + key + "-" + lockId);
39 | return true;
40 | }
41 | return false;
42 | }
43 |
44 |
45 | /**
46 | * @param jedis redis客户端
47 | * @param key 锁
48 | * @param lockId 锁对应的请求id
49 | * @return 释放锁结果
50 | *
51 | * 使用lua脚本是为了保证操作的原子性，redisson中使用同样的方式进行锁释放。
52 | *
53 | * 为什么锁redis使用lua是线程安全的？
54 | * 因为redis本身就是单线程的，而redis内置了lua的解析器，从而能保证线程安全（不够严谨）
55 | */
56 | public static Boolean releaseDistributedLock(Jedis jedis, String key, String lockId) {
57 | //lua脚本
58 | String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
59 | //调用evel交给redis服务端执行脚本
60 | Object status = jedis.eval(luaScript, Collections.singletonList(key), Collections.singletonList(lockId));
61 | if (LOCK_STATUS.equals(status)) {
62 | logger.info("释放锁成功，当前：" + key + "-" + lockId);
63 | return true;
64 | }
65 | return false;
66 | }
67 |
68 | }
69 |
--------------------------------------------------------------------------------
/src/main/java/com/tools/redis/lettuce/LettuceTools.java:
--------------------------------------------------------------------------------
1 | package com.tools.redis.lettuce;
2 |
3 | public enum LettuceTools {
4 |
5 | URL("redis://localhost:6379/0");
6 |
7 | private String value;
8 |
9 | LettuceTools(String value){
10 | this.value = value;
11 | }
12 |
13 | public String getValue() {
14 | return value;
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/src/main/java/com/tools/redis/lettuce/MyListener.java:
--------------------------------------------------------------------------------
1 | package com.tools.redis.lettuce;
2 |
3 | import io.lettuce.core.pubsub.RedisPubSubListener;
4 |
5 | public class MyListener implements RedisPubSubListener {
6 | @Override
7 | public void message(Object channel, Object message) {
8 |
9 | }
10 |
11 | @Override
12 | public void message(Object pattern, Object channel, Object message) {
13 |
14 | }
15 |
16 | @Override
17 | public void subscribed(Object channel, long count) {
18 |
19 | }
20 |
21 | @Override
22 | public void psubscribed(Object pattern, long count) {
23 |
24 | }
25 |
26 | @Override
27 | public void unsubscribed(Object channel, long count) {
28 |
29 | }
30 |
31 | @Override
32 | public void punsubscribed(Object pattern, long count) {
33 |
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/src/main/java/com/tools/redis/lettuce/PubSubByLettuce.java:
--------------------------------------------------------------------------------
1 | package com.tools.redis.lettuce;
2 |
3 | import io.lettuce.core.RedisClient;
4 | import io.lettuce.core.RedisFuture;
5 | import io.lettuce.core.cluster.RedisClusterClient;
6 | import io.lettuce.core.cluster.pubsub.StatefulRedisClusterPubSubConnection;
7 | import io.lettuce.core.cluster.pubsub.api.async.RedisClusterPubSubAsyncCommands;
8 | import io.lettuce.core.cluster.pubsub.api.sync.RedisClusterPubSubCommands;
9 | import io.lettuce.core.pubsub.StatefulRedisPubSubConnection;
10 | import io.lettuce.core.pubsub.api.async.RedisPubSubAsyncCommands;
11 | import io.lettuce.core.pubsub.api.reactive.RedisPubSubReactiveCommands;
12 | import io.lettuce.core.pubsub.api.sync.RedisPubSubCommands;
13 | import org.slf4j.Logger;
14 | import org.slf4j.LoggerFactory;
15 |
16 | /**
17 | *
18 | */
19 | public class PubSubByLettuce {
20 |
21 | private static Logger logger = LoggerFactory.getLogger(PubSubByLettuce.class);
22 |
23 | public static void main(String[] args) {
24 | RedisClient redisClient = RedisClient.create(LettuceTools.URL.getValue());
25 |
26 | /**
27 | * 同步订阅 synchronous subscription
28 | */
29 | StatefulRedisPubSubConnection