implements IShopService {
48 |
49 | @Autowired
50 | private StringRedisTemplate stringRedisTemplate;
51 | @Autowired
52 | private CacheClient cacheClient;
53 |
54 | @Override
55 | public Result queryById(Long id) {
56 | // 缓存穿透
57 | // Shop shop = queryWithPassThrough(id);
58 | // Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
59 |
60 | // 互斥锁解决缓存击穿
61 | Shop shop = queryWithMutex(id);
62 |
63 | // 逻辑过期解决缓存冲击
64 | // Shop shop = queryWithLogicalExpire(id);
65 | // Shop shop = cacheClient.queryWithLogicalExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, 20L, TimeUnit.SECONDS);
66 | if (shop == null) {
67 | return Result.fail("店铺不存在！");
68 | }
69 | // 7.返回
70 | return Result.ok(shop);
71 | }
72 |
73 | private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
74 |
75 | /**
76 | * 通过id查询店铺信息，使用【逻辑过期】策略 解决【缓存击穿】
77 | *
78 | * @param id 店铺id
79 | * @return 返回查询到的店铺，没有返回null
80 | */
81 | private Shop queryWithLogicalExpire(Long id) {
82 | // 1.从redis查询商铺缓存
83 | String key = CACHE_SHOP_KEY + id;
84 | String shopJson = stringRedisTemplate.opsForValue().get(key);
85 | // 2.判断是否存在
86 | if (StrUtil.isBlank(shopJson)) {
87 | // 3.不存在，直接放回null
88 | return null;
89 | }
90 | // 4.命中，需要先把json反序列化为对象
91 | RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
92 | JSONObject data = (JSONObject) redisData.getData();
93 | Shop shop = JSONUtil.toBean(data, Shop.class);
94 | LocalDateTime expireTime = redisData.getExpireTime();
95 | // 5.判断是否过期
96 | if (expireTime.isAfter(LocalDateTime.now())) {
97 | // 5.1 未过期，直接返回店铺信息
98 | return shop;
99 | }
100 | // 6.缓存重建
101 | // 6.1 获取互斥锁
102 | String lockKey = LOCK_SHOP_KEY + id;
103 | boolean isLock = tryLock(lockKey);
104 | // 6.2 判断是否获取锁成功
105 | if (isLock) {
106 | // 6.3 成功，开启独立线程，实现缓存重建
107 | CACHE_REBUILD_EXECUTOR.submit(() -> {
108 | // 重建缓存
109 | try {
110 | this.saveShop2Redis(id, 20L);
111 | } catch (Exception e) {
112 | throw new RuntimeException(e);
113 | } finally {
114 | // 释放锁
115 | this.unlock(lockKey);
116 | }
117 | });
118 | }
119 | // 6.4 返回过期的商城信息
120 | return shop;
121 | }
122 |
123 | /**
124 | * 通过id查询店铺信息，使用【互斥锁】策略 解决【缓存击穿】
125 | *
126 | * @param id 店铺id
127 | * @return 返回查询到的店铺，没有返回null
128 | */
129 | private Shop queryWithMutex(Long id) {
130 | // 1.从redis查询商铺缓存
131 | String key = CACHE_SHOP_KEY + id;
132 | String shopJson = stringRedisTemplate.opsForValue().get(key);
133 | // 2.判断是否存在
134 | if (!StrUtil.isBlank(shopJson)) {
135 | // 3.存在，直接放回
136 | return JSONUtil.toBean(shopJson, Shop.class);
137 | }
138 | // 【缓存穿透】判断命中的是否是空值
139 | if (shopJson != null) { // shopJson = "" - 缓存的空值
140 | // 返回一个错误信息
141 | // "店铺信息不存在！"
142 | return null;
143 | }
144 | // 4.实现缓存重建
145 | // 4.1 获取互斥锁
146 | String lockKey = "lock:shop:" + id;
147 | Shop shop;
148 | try {
149 | boolean isLock = tryLock(lockKey);
150 | // 4.2 判断是否获取成功
151 | if (!isLock) {
152 | // 4.3 失败，则休眠并重试
153 | Thread.sleep(50);
154 | return queryWithMutex(id);
155 | }
156 | // 4.4 成功，根据id查询数据库
157 | // 4.不存在
158 | shop = getById(id);
159 | // 5.不存在，返回错误
160 | if (shop == null) {
161 | // 【缓存穿透】将空值写入redis
162 | stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
163 | // 返回错误信息
164 | // "店铺不存在！"
165 | return null;
166 | }
167 | // 6.存在，写入redis
168 | stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
169 | } catch (InterruptedException e) {
170 | throw new RuntimeException(e);
171 | }
172 | // 7.释放互斥锁
173 | unlock(lockKey);
174 | // 8.返回
175 | return shop;
176 | }
177 |
178 | /**
179 | * 通过 id 查询店铺，同时解决 【缓存穿透】 问题
180 | *
181 | * @param id 店铺id
182 | * @return 返回查询到的店铺信息，若店铺不存在，返回 null
183 | */
184 | private Shop queryWithPassThrough(Long id) {
185 | // 1.从redis查询商铺缓存
186 | String key = CACHE_SHOP_KEY + id;
187 | String shopJson = stringRedisTemplate.opsForValue().get(key);
188 | // 2.判断是否存在
189 | if (!StrUtil.isBlank(shopJson)) {
190 | // 3.存在，直接放回
191 | return JSONUtil.toBean(shopJson, Shop.class);
192 | }
193 | // 【缓存穿透】判断命中的是否是空值
194 | if (shopJson != null) {
195 | // 返回一个错误信息
196 | //"店铺信息不存在！"
197 | return null;
198 | }
199 | // 4.不存在，根据id查询数据库
200 | Shop shop = getById(id);
201 | // 5.不存在，返回错误
202 | if (shop == null) {
203 | // 【缓存穿透】将空置写入redis
204 | stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
205 | // 返回错误信息
206 | // "店铺不存在！"
207 | return null;
208 | }
209 | // 6.存在，写入redis
210 | stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
211 | // 7.返回
212 | return shop;
213 | }
214 |
215 | /**
216 | * 获取锁（setnx命令）
217 | *
218 | * @param key redis的key值
219 | * @return 获取成功返回 true，否则返回 false
220 | */
221 | private boolean tryLock(String key) {
222 | // setIfAbsent == setnx
223 | Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
224 | return BooleanUtil.isTrue(flag);
225 | }
226 |
227 | /**
228 | * 释放redis锁（删除对应key的缓存）
229 | *
230 | * @param key 锁的key值
231 | */
232 | private void unlock(String key) {
233 | stringRedisTemplate.delete(key);
234 | }
235 |
236 | /**
237 | * 热点店铺
238 | *
239 | * 根据id从数据库中查询出商店信息，添加过期时间，封装成 {@link RedisData} 类存入Redis中
240 | *
241 | * @param id 店铺id
242 | * @param expireSeconds 过期时间
243 | */
244 | public void saveShop2Redis(Long id, Long expireSeconds) {
245 | // 1.查询店铺数据
246 | Shop shop = getById(id);
247 | // 2.封装逻辑过期时间
248 | RedisData redisData = new RedisData();
249 | redisData.setData(shop);
250 | redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
251 | // 3.写入Redis
252 | stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
253 | }
254 |
255 | /**
256 | * 更新店铺操作
257 | *
258 | * @param shop 要更新的店铺
259 | * @return 返回更新的结果
260 | */
261 | @Override
262 | @Transactional // 添加事务注解控制原子性操作 -- 方便出现异常时数据库进行回滚
263 | public Result update(Shop shop) {
264 | Long id = shop.getId();
265 | if (id == null) {
266 | return Result.fail("店铺id不能为空！");
267 | }
268 | // 1.更新数据库
269 | updateById(shop);
270 | // 2.删除缓存（当删除失败可能会导致缓存中为旧数据）
271 | stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
272 | return Result.ok();
273 | }
274 |
275 | @Override
276 | public Result queryShopByType(Integer typeId, Integer current, Double x, Double y) {
277 | // 1.判断是否需要根据坐标查询
278 | if (x == null || y == null) {
279 | // 不需要坐标查询，按照数据库查询
280 | // 根据类型分页查询
281 | Page page = query()
282 | .eq("type_id", typeId)
283 | .page(new Page<>(current, SystemConstants.DEFAULT_PAGE_SIZE));
284 | // 返回数据
285 | return Result.ok(page.getRecords());
286 | }
287 | // 2.计算分页参数
288 | int from = (current - 1) * SystemConstants.DEFAULT_PAGE_SIZE;
289 | int end = current * SystemConstants.DEFAULT_PAGE_SIZE;
290 |
291 | // 3.查询redis，按照距离排序、分页，结果：shopId、distance
292 | String key = SHOP_GEO_KEY + typeId;
293 | GeoResults> results = stringRedisTemplate
294 | .opsForGeo() // GEOSEARCH key BYLONLAT x y BYRADIUS 10 WITHDISTANCE
295 | .search(
296 | key,
297 | GeoReference.fromCoordinate(x, y),
298 | new Distance(5000.),
299 | RedisGeoCommands
300 | .GeoSearchCommandArgs
301 | .newGeoSearchArgs()
302 | .includeDistance()
303 | .limit(end)
304 | );
305 | // 4.解析出id
306 | if (results == null) {
307 | return Result.ok();
308 | }
309 | List>> list = results.getContent();
310 | if (list.size() <= from) {
311 | // 没有一下页了
312 | return Result.ok();
313 | }
314 | // 4.1 截取 from ~ end 的部分
315 | List
93 | */
94 | @Override
95 | public Result seckillVoucher(Long voucherId) {
96 | Long userId = UserHolder.getUser().getId();
97 | // 1.执行lua脚本
98 | Long result = stringRedisTemplate.execute(
99 | SECKILL_SCRIPT,
100 | Collections.emptyList(),
101 | voucherId.toString(),
102 | userId.toString(),
103 | Long.toString(LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli())
104 | );
105 | int r = result == null ? 0 : result.intValue();
106 | // 2.判断结果是否为0
107 | if (r != 0) {
108 | // 2.1 不为0，代表没有购买资格
109 | String errorMsg = r == 1 ? "秒杀尚未开始！" : r == 2 ? "秒杀已经结束！" : r == 3 ? "库存不足！" : "不能重复下单！";
110 | log.warn(errorMsg);
111 | return Result.fail(errorMsg);
112 | }
113 | // 2.2 为0，有购买资格，把下单信息保存到阻塞队列中
114 | // 2.3 订单id
115 | long orderId = redisIdWorker.nextId("order");
116 | VoucherOrder voucherOrder = new VoucherOrder();
117 | voucherOrder.setId(orderId);
118 | // 2.4 用户id
119 | voucherOrder.setUserId(userId);
120 | // 2.5 代金券id
121 | voucherOrder.setVoucherId(voucherId);
122 |
123 | //// // 保存阻塞队列 -- 通过线程池 异步执行 数据库读写任务
124 | // orderTasks.add(voucherOrder);
125 | //// // 获取当前类代理对象并赋值
126 | // proxy = (IVoucherOrderService) AopContext.currentProxy();
127 |
128 | // 发送到消息队列
129 | mqSender.sendSeckillMessage(voucherOrder, false);
130 |
131 | // 3.返回订单id
132 | return Result.ok(orderId);
133 | }
134 |
135 | @Deprecated
136 | private class VoucherOrderHandler implements Runnable {
137 |
138 | @Override
139 | public void run() {
140 | while (true) {
141 | try {
142 | // 1.获取队列中的订单信息
143 | VoucherOrder voucherOrder = orderTasks.take();
144 | // 2.创建订单
145 | handleVoucherOrder(voucherOrder);
146 | } catch (Exception e) {
147 | log.error("处理订单异常", e);
148 | }
149 | }
150 | }
151 | }
152 |
153 | @Deprecated
154 | private void handleVoucherOrder(VoucherOrder voucherOrder) {
155 | // 1.获取用户
156 | Long userId = voucherOrder.getUserId();
157 | // 2.创建锁对象
158 | RLock redisLock = redissonClient.getLock("lock:order:" + userId);
159 | // 3.获取锁
160 | boolean isLock = redisLock.tryLock();
161 | // 4.判断获取锁是否成功
162 | if (!isLock) {
163 | // 获取锁失败，直接放回失败或者重试
164 | log.error("不允许重复下单！");
165 | return;
166 | }
167 | try {
168 | proxy.createVoucherOrder(voucherOrder);
169 | } finally {
170 | // 释放锁
171 | redisLock.unlock();
172 | }
173 | }
174 |
175 | @Transactional
176 | @Override
177 | public void createVoucherOrder(VoucherOrder voucherOrder) {
178 | Long userId = voucherOrder.getUserId();
179 | Long voucherId = voucherOrder.getVoucherId();
180 | // 创建锁对象
181 | RLock redisLock = redissonClient.getLock("order" + userId); // name 不应该和其他键同名
182 | boolean isLock = redisLock.tryLock();
183 | if (!isLock) {
184 | // 获取锁失败，直接放回失败或者重试
185 | log.error("不允许重复下单！");
186 | return;
187 | }
188 | try {
189 | // 5.1 查询订单
190 | Integer count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
191 | // 5.2 判断是否存在
192 | if (count > 0) {
193 | // 用户已经购买过了
194 | log.error("该用户已经购买过一次！");
195 | return;
196 | }
197 | // 6.扣减库存
198 | boolean success = seckillVoucherService.update()
199 | .setSql("stock = stock - 1")
200 | .eq("voucher_id", voucherId)
201 | // .eq("stock", voucher.getStock()) // CAS法实现乐观锁，解决并发问题（失败率高）
202 | .gt("stock", 0) // CAS优化，只要库存大于0就可以秒杀成功
203 | .update();
204 |
205 | if (!success) {
206 | // 扣减失败
207 | log.error("库存不足！");
208 | return;
209 | }
210 | // 保存订单
211 | save(voucherOrder);
212 | } finally {
213 | // 释放锁
214 | redisLock.unlock();
215 | }
216 | }
217 | }
218 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/service/impl/VoucherServiceImpl.java:
--------------------------------------------------------------------------------
1 | package com.xydp.service.impl;
2 |
3 | import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
4 | import com.xydp.dto.Result;
5 | import com.xydp.entity.Voucher;
6 | import com.xydp.mapper.VoucherMapper;
7 | import com.xydp.entity.SeckillVoucher;
8 | import com.xydp.service.ISeckillVoucherService;
9 | import com.xydp.service.IVoucherService;
10 | import com.xydp.utils.RedisConstants;
11 | import org.springframework.data.redis.core.StringRedisTemplate;
12 | import org.springframework.stereotype.Service;
13 | import org.springframework.transaction.annotation.Transactional;
14 |
15 | import javax.annotation.Resource;
16 | import java.time.LocalDateTime;
17 | import java.time.ZoneId;
18 | import java.util.HashMap;
19 | import java.util.List;
20 | import java.util.Map;
21 |
22 | /**
23 | *
24 | * 服务实现类
25 | *
26 | *
27 | * @author 虎哥
28 | * @since 2021-12-22
29 | */
30 | @Service
31 | public class VoucherServiceImpl extends ServiceImpl implements IVoucherService {
32 |
33 | @Resource
34 | private ISeckillVoucherService seckillVoucherService;
35 | @Resource
36 | private StringRedisTemplate stringRedisTemplate;
37 |
38 | @Override
39 | public Result queryVoucherOfShop(Long shopId) {
40 | // 查询优惠券信息
41 | List vouchers = getBaseMapper().queryVoucherOfShop(shopId);
42 | // 返回结果
43 | return Result.ok(vouchers);
44 | }
45 |
46 | @Override
47 | @Transactional
48 | public void addSeckillVoucher(Voucher voucher) {
49 | // 保存优惠券
50 | save(voucher);
51 | // 保存秒杀信息
52 | SeckillVoucher seckillVoucher = new SeckillVoucher();
53 | seckillVoucher.setVoucherId(voucher.getId());
54 | seckillVoucher.setStock(voucher.getStock());
55 | seckillVoucher.setBeginTime(voucher.getBeginTime());
56 | seckillVoucher.setEndTime(voucher.getEndTime());
57 | seckillVoucherService.save(seckillVoucher);
58 | // 保存库存到redis中
59 | // stringRedisTemplate.opsForValue().set(RedisConstants.SECKILL_STOCK_KEY + voucher.getId(), String.valueOf(voucher.getStock()));
60 | Map map = new HashMap<>();
61 | if (seckillVoucher.getBeginTime() == null) {
62 | seckillVoucher.setBeginTime(LocalDateTime.now());
63 | }
64 | if (seckillVoucher.getEndTime() == null) {
65 | seckillVoucher.setEndTime(LocalDateTime.now());
66 | }
67 | map.put("stock", Integer.toString(seckillVoucher.getStock()));
68 | map.put("begin", Long.toString(seckillVoucher.getBeginTime().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()));
69 | map.put("end", Long.toString(seckillVoucher.getEndTime().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()));
70 | stringRedisTemplate.opsForHash().putAll(RedisConstants.SECKILL + voucher.getId(), map);
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/CacheClient.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | import cn.hutool.core.util.BooleanUtil;
4 | import cn.hutool.core.util.StrUtil;
5 | import cn.hutool.json.JSONObject;
6 | import cn.hutool.json.JSONUtil;
7 | import lombok.extern.slf4j.Slf4j;
8 | import org.springframework.data.redis.core.StringRedisTemplate;
9 | import org.springframework.stereotype.Component;
10 |
11 | import java.time.LocalDateTime;
12 | import java.util.concurrent.ExecutorService;
13 | import java.util.concurrent.Executors;
14 | import java.util.concurrent.TimeUnit;
15 | import java.util.function.Function;
16 |
17 | import static com.xydp.utils.RedisConstants.*;
18 |
19 | /**
20 | * 缓存工具封装类
21 | */
22 | @Slf4j
23 | @Component
24 | @SuppressWarnings("Duplicates")
25 | public class CacheClient {
26 | private final StringRedisTemplate stringRedisTemplate;
27 |
28 | public CacheClient(StringRedisTemplate stringRedisTemplate) {
29 | this.stringRedisTemplate = stringRedisTemplate;
30 | }
31 |
32 | public void set(String key, Object value, Long timeout, TimeUnit unit) {
33 | stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), timeout, unit);
34 | }
35 |
36 | public void setWithLogicalExpire(String key, Object value, Long timeout, TimeUnit unit) {
37 | // 设置逻辑过期
38 | RedisData redisData = new RedisData();
39 | redisData.setData(value);
40 | redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(timeout)));
41 | // 写入Redis缓存
42 | stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
43 | }
44 |
45 | /**
46 | * 通过 id 查询实体，使用 【返回空对象】 解决 【缓存穿透】 问题
47 | *
48 | * @param id 实体Bean id
49 | * @return 返回查询到的 实体Bean 信息，若实体不存在，返回 null
50 | */
51 | public R queryWithPassThrough(
52 | String keyPrefix, ID id, Class type, Function dbFallback, Long timeout, TimeUnit unit) {
53 | // 1.从redis查询商铺缓存
54 | String key = keyPrefix + id;
55 | String json = stringRedisTemplate.opsForValue().get(key);
56 | // 2.判断是否存在
57 | if (!StrUtil.isBlank(json)) {
58 | // 3.存在，直接放回
59 | return JSONUtil.toBean(json, type);
60 | }
61 | // 【缓存穿透】判断命中的是否是空值
62 | if (json != null) {
63 | // 返回一个错误信息
64 | return null;
65 | }
66 | // 4.不存在，根据id查询数据库
67 | R r = dbFallback.apply(id);
68 | // 5.不存在，返回错误
69 | if (r == null) {
70 | // 【缓存穿透】将空置写入redis
71 | stringRedisTemplate.opsForValue().set(key, "", timeout, unit);
72 | // 返回错误信息
73 | // "店铺不存在！"
74 | return null;
75 | }
76 | // 6.存在，写入redis
77 | this.set(key, r, timeout, unit);
78 | // 7.返回
79 | return r;
80 | }
81 |
82 | private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
83 |
84 | /**
85 | * 通过id查询实体 Bean 信息，使用【逻辑过期】策略 解决【缓存击穿】
86 | *
87 | * 使用逻辑过期策略一般需要提前将热点 Key 导入数据库中
88 | *
89 | * @param id 实体Bean id
90 | * @param 返回的 实体Bean 类型
91 | * @param 实体Bean ID 类型
92 | * @return 返回查询到的 实体Bean，没有返回null
93 | */
94 | public R queryWithLogicalExpire(
95 | String keyPrefix, ID id, Class type, Function dbFallback, Long timeout, TimeUnit unit) {
96 | // 1.从redis查询商铺缓存
97 | String key = keyPrefix + id;
98 | String json = stringRedisTemplate.opsForValue().get(key);
99 | // 2.判断是否存在
100 | if (StrUtil.isBlank(json)) {
101 | // 3.不存在，直接放回null
102 | return null;
103 | }
104 | // 4.命中，需要先把json反序列化为对象
105 | RedisData redisData = JSONUtil.toBean(json, RedisData.class);
106 | JSONObject data = (JSONObject) redisData.getData();
107 | R r = JSONUtil.toBean(data, type);
108 | LocalDateTime expireTime = redisData.getExpireTime();
109 | // 5.判断是否过期
110 | if (expireTime.isAfter(LocalDateTime.now())) {
111 | // 5.1 未过期，直接放回店铺信息
112 | return r;
113 | }
114 | // 6.缓存重建
115 | // 6.1 获取互斥锁
116 | String lockKey = LOCK_SHOP_KEY + id;
117 | boolean isLock = tryLock(lockKey);
118 | // 6.2 判断是否获取锁成功
119 | if (isLock) {
120 | // 6.3 成功，开启独立线程，实现缓存重建
121 | CACHE_REBUILD_EXECUTOR.submit(() -> {
122 | try {
123 | // 重建缓存
124 | R r1 = dbFallback.apply(id);
125 | // 写入Redis
126 | this.setWithLogicalExpire(key, r1, timeout, unit);
127 | } catch (Exception e) {
128 | throw new RuntimeException(e);
129 | } finally {
130 | // 释放锁
131 | this.unlock(lockKey);
132 | }
133 | });
134 | }
135 | // 6.4 返回过期的商城信息
136 | return r;
137 | }
138 |
139 | private boolean tryLock(String key) {
140 | // setIfAbsent == setnx
141 | Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10L, TimeUnit.SECONDS);
142 | return BooleanUtil.isTrue(flag);
143 | }
144 |
145 | private void unlock(String key) {
146 | stringRedisTemplate.delete(key);
147 | }
148 | }
149 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/CommonUtils.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | import java.util.Random;
4 |
5 | /**
6 | * 通用工具类
7 | *
8 | * @author Wuxy
9 | * @version 1.0
10 | * @ClassName CommonUtils
11 | * @since 2023/6/3 17:27
12 | */
13 | public class CommonUtils {
14 | private static final String ALL_CHAR_NUM = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
15 |
16 |
17 | /**
18 | * 获取指定长度的随机串
19 | *
20 | * @param length 指定长度
21 | * @return 返回指定长度的随机字符串
22 | */
23 | public static String getStringNumRandom(int length) {
24 | // 生成随机数字和字母
25 | Random random = new Random();
26 | StringBuilder sb = new StringBuilder(length);
27 | for (int i = 0; i < length; i++) {
28 | sb.append(ALL_CHAR_NUM.charAt(random.nextInt(ALL_CHAR_NUM.length())));
29 | }
30 | return sb.toString();
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/ILock.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | public interface ILock {
4 |
5 | /**
6 | * 尝试获取锁
7 | *
8 | * @param timeoutSec 锁持有的超时时间，过期后自动释放
9 | * @return 获取锁成功返回true，否则返回false
10 | */
11 | boolean tryLock(long timeoutSec);
12 |
13 | /**
14 | * 释放锁
15 | */
16 | void unlock();
17 | }
18 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/IPUtils.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | import javax.servlet.http.HttpServletRequest;
4 | import java.net.InetAddress;
5 | import java.net.UnknownHostException;
6 |
7 | /**
8 | * IP 工具类
9 | *
10 | * @author Wuxy
11 | * @version 1.0
12 | * @ClassName IPUtils
13 | * @since 2023/1/13 17:17
14 | **/
15 | public class IPUtils {
16 |
17 | /**
18 | * 获取 HttpRequest 的请求 IP
19 | *
20 | * @param request http request
21 | * @return 返回真实 IP
22 | */
23 | public static String getIpAddr(HttpServletRequest request) {
24 | String ipAddress;
25 | try {
26 | ipAddress = request.getHeader("x-forwarded-for");
27 | if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
28 | ipAddress = request.getHeader("Proxy-Client-IP");
29 | }
30 | if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
31 | ipAddress = request.getHeader("WL-Proxy-Client-IP");
32 | }
33 | if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
34 | ipAddress = request.getRemoteAddr(); // localhost会被解析为 ipv6：0:0:0:0:0:0:0:1
35 | if (ipAddress.equals("127.0.0.1")) {
36 | // 根据网卡取本机配置的IP
37 | InetAddress inet = null;
38 | try {
39 | inet = InetAddress.getLocalHost();
40 | } catch (UnknownHostException e) {
41 | e.printStackTrace();
42 | }
43 | assert inet != null;
44 | ipAddress = inet.getHostAddress();
45 | }
46 | }
47 | // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
48 | if (ipAddress != null && ipAddress.length() > 15) { // "***.***.***.***".length()
49 | // = 15
50 | if (ipAddress.indexOf(",") > 0) {
51 | ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
52 | }
53 | }
54 | } catch (Exception e) {
55 | ipAddress = request.getRemoteAddr();
56 | }
57 | return ipAddress;
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/MQConstants.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | /**
4 | * MQ 常量类
5 | *
6 | * @author Wuxy
7 | * @version 1.0
8 | * @ClassName MQConstants
9 | * @since 2023/1/13 23:42
10 | */
11 | public class MQConstants {
12 |
13 | public static final String QUEUE = "queue";
14 |
15 | public static final String SECKILL_QUEUE = "seckill.queue";
16 |
17 | public static final String SECKILL_EXCHANGE = "seckill_exchange";
18 |
19 | public static final String SECKILL_ROUTING_KEY = "seckill_routing_key";
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/PasswordEncoder.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | import cn.hutool.core.util.RandomUtil;
4 | import org.springframework.util.DigestUtils;
5 |
6 | import java.nio.charset.StandardCharsets;
7 |
8 | public class PasswordEncoder {
9 |
10 | public static String encode(String password) {
11 | // 生成盐
12 | String salt = RandomUtil.randomString(20);
13 | // 加密
14 | return encode(password,salt);
15 | }
16 | private static String encode(String password, String salt) {
17 | // 加密
18 | return salt + "@" + DigestUtils.md5DigestAsHex((password + salt).getBytes(StandardCharsets.UTF_8));
19 | }
20 | public static Boolean matches(String encodedPassword, String rawPassword) {
21 | if (encodedPassword == null || rawPassword == null) {
22 | return false;
23 | }
24 | if(!encodedPassword.contains("@")){
25 | throw new RuntimeException("密码格式不正确！");
26 | }
27 | String[] arr = encodedPassword.split("@");
28 | // 获取盐
29 | String salt = arr[0];
30 | // 比较
31 | return encodedPassword.equals(encode(rawPassword, salt));
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/RedisConstants.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | public class RedisConstants {
4 | public static final String LOGIN_CODE_KEY = "login:code:";
5 | public static final Long LOGIN_CODE_TTL = 2L;
6 | public static final String LOGIN_USER_KEY = "login:token:";
7 | public static final Long LOGIN_USER_TTL = 36000L; // 36000L
8 | public static final Long CACHE_NULL_TTL = 2L;
9 | public static final Long CACHE_SHOP_TTL = 30L;
10 | public static final String CACHE_SHOP_KEY = "cache:shop:";
11 | public static final String CACHE_SHOP_TYPE_KEY = "cache:shoptype";
12 | public static final String LOCK_SHOP_KEY = "lock:shop:";
13 | public static final Long LOCK_SHOP_TTL = 10L;
14 | public static final String SECKILL_STOCK_KEY = "seckill:stock:";
15 | public static final String SECKILL = "seckill:";
16 | public static final String BLOG_LIKED_KEY = "blog:liked:";
17 | public static final String FEED_KEY = "feed:";
18 | public static final String SHOP_GEO_KEY = "shop:geo:";
19 | public static final String USER_SIGN_KEY = "sign:";
20 | public static final String ACCESS_LIMIT_IP_KEY = "access:limit:ip:";
21 | public static final String ACCESS_LIMIT_USER_KEY = "access:limit:user:";
22 |
23 | /**
24 | * 提交订单令牌的缓存 key
25 | */
26 | public static final String SUBMIT_ORDER_TOKEN_KEY = "order:submit:%s:%s";
27 | }
28 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/RedisData.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | import lombok.Data;
4 |
5 | import java.time.LocalDateTime;
6 |
7 | @Data
8 | public class RedisData {
9 | /**
10 | * 过期时间
11 | */
12 | private LocalDateTime expireTime;
13 | /**
14 | * Shop 对象数据
15 | */
16 | private Object data;
17 | }
18 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/RedisIdWorker.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | import org.springframework.beans.factory.annotation.Autowired;
4 | import org.springframework.data.redis.core.StringRedisTemplate;
5 | import org.springframework.stereotype.Component;
6 |
7 | import java.time.LocalDateTime;
8 | import java.time.ZoneOffset;
9 | import java.time.format.DateTimeFormatter;
10 |
11 | /**
12 | * 基于Redis的订单id生成工具类
13 | */
14 | @Component
15 | public class RedisIdWorker {
16 |
17 | /**
18 | * 开始时间戳
19 | */
20 | private static final long START_TIMESTAMP = 1640995200L;
21 |
22 | /**
23 | * 序列号位数
24 | */
25 | private static final int COUNT_BITS = 32;
26 |
27 | @Autowired
28 | private StringRedisTemplate stringRedisTemplate;
29 |
30 | public long nextId(String keyPrefix) {
31 | // 1.生成时间戳
32 | LocalDateTime now = LocalDateTime.now();
33 | long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
34 | long timestamp = nowSecond - START_TIMESTAMP;
35 | // 2.生成序列号
36 | // 2.1 获取当前日期，精确到天
37 | String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
38 | // 2.2 自增长
39 | long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);
40 | // 3.拼接并返回
41 | return timestamp << COUNT_BITS | count;
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/RegexPatterns.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | /**
4 | * @author 虎哥
5 | */
6 | public abstract class RegexPatterns {
7 | /**
8 | * 手机号正则
9 | */
10 | public static final String PHONE_REGEX = "^1([38][0-9]|4[579]|5[0-3,5-9]|6[6]|7[0135678]|9[89])\\d{8}$";
11 | /**
12 | * 邮箱正则
13 | */
14 | public static final String EMAIL_REGEX = "^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$";
15 | /**
16 | * 密码正则。4~32位的字母、数字、下划线
17 | */
18 | public static final String PASSWORD_REGEX = "^\\w{4,32}$";
19 | /**
20 | * 验证码正则, 6位数字或字母
21 | */
22 | public static final String VERIFY_CODE_REGEX = "^[a-zA-Z\\d]{6}$";
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/RegexUtils.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | import cn.hutool.core.util.StrUtil;
4 |
5 | /**
6 | * @author 虎哥
7 | */
8 | public class RegexUtils {
9 | /**
10 | * 是否是无效手机格式
11 | *
12 | * @param phone 要校验的手机号
13 | * @return true:符合，false：不符合
14 | */
15 | public static boolean isPhoneInvalid(String phone) {
16 | return mismatch(phone, RegexPatterns.PHONE_REGEX);
17 | }
18 |
19 | /**
20 | * 是否是无效邮箱格式
21 | *
22 | * @param email 要校验的邮箱
23 | * @return true:符合，false：不符合
24 | */
25 | public static boolean isEmailInvalid(String email) {
26 | return mismatch(email, RegexPatterns.EMAIL_REGEX);
27 | }
28 |
29 | /**
30 | * 是否是无效验证码格式
31 | *
32 | * @param code 要校验的验证码
33 | * @return true:符合，false：不符合
34 | */
35 | public static boolean isCodeInvalid(String code) {
36 | return mismatch(code, RegexPatterns.VERIFY_CODE_REGEX);
37 | }
38 |
39 | // 校验是否不符合正则格式
40 | private static boolean mismatch(String str, String regex) {
41 | if (StrUtil.isBlank(str)) {
42 | return true;
43 | }
44 | return !str.matches(regex);
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/SimpleRedisLock.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | import cn.hutool.core.lang.UUID;
4 | import org.springframework.core.io.ClassPathResource;
5 | import org.springframework.data.redis.core.StringRedisTemplate;
6 | import org.springframework.data.redis.core.script.DefaultRedisScript;
7 |
8 | import java.util.Collections;
9 | import java.util.concurrent.TimeUnit;
10 |
11 | /**
12 | * 基于Redis的分布式锁
13 | */
14 | public class SimpleRedisLock implements ILock {
15 | private final String name;
16 |
17 | private final StringRedisTemplate stringRedisTemplate;
18 |
19 | private static final String KEY_PREFIX = "lock:";
20 |
21 | /**
22 | * 线程id前缀，确保不同的JVM的线程一定存在不一样的线程id
23 | */
24 | private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";
25 |
26 | private static final DefaultRedisScript UNLOCK_SCRIPT;
27 |
28 | static {
29 | UNLOCK_SCRIPT = new DefaultRedisScript<>();
30 | UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
31 | UNLOCK_SCRIPT.setResultType(Long.class);
32 | }
33 |
34 |
35 | public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
36 | this.name = name;
37 | this.stringRedisTemplate = stringRedisTemplate;
38 | }
39 |
40 | @Override
41 | public boolean tryLock(long timeoutSec) {
42 | // 获取线程标识
43 | String threadId = ID_PREFIX + Thread.currentThread().getId();
44 | // 获取锁：set lock thread1 nx ex t -- （nx是互斥、ex是超时时间）
45 | Boolean success = stringRedisTemplate.opsForValue()
46 | .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
47 | return Boolean.TRUE.equals(success);
48 | }
49 |
50 | /**
51 | * 释放锁，并且确保当前id只能释放自己获取的锁，从而避免并发情况下，由于阻塞等异常情况，导致错误释放其它线程的锁
52 | */
53 | @Override
54 | public void unlock() {
55 | // 调用lua脚本，使得释放锁的两个操作（1、获取线程标识；2、释放锁）成为原子操作，避免高并发异常情况
56 | stringRedisTemplate.execute(
57 | UNLOCK_SCRIPT,
58 | Collections.singletonList(KEY_PREFIX + name),
59 | ID_PREFIX + Thread.currentThread().getId());
60 | }
61 |
62 | /*@Override
63 | public void unlock() {
64 | // 获取线程标识
65 | String threadId = ID_PREFIX + Thread.currentThread().getId();
66 | // 获取锁中的标识
67 | String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
68 | // 判断标识是否一致
69 | if (threadId.equals(id)) {
70 | // 释放锁
71 | stringRedisTemplate.delete(KEY_PREFIX + name);
72 | }
73 | }*/
74 | }
75 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/SystemConstants.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | public class SystemConstants {
4 | public static final String IMAGE_UPLOAD_DIR = "D:\\lessons\\Redis\\primary\\nginx-1.18.0\\html\\hmdp\\imgs\\";
5 | public static final String USER_NICK_NAME_PREFIX = "user_";
6 | public static final int DEFAULT_PAGE_SIZE = 5;
7 | public static final int MAX_PAGE_SIZE = 10;
8 | }
9 |
--------------------------------------------------------------------------------
/src/main/java/com/xydp/utils/UserHolder.java:
--------------------------------------------------------------------------------
1 | package com.xydp.utils;
2 |
3 | import com.xydp.dto.UserDTO;
4 |
5 | public class UserHolder {
6 | private static final ThreadLocal tl = new ThreadLocal<>();
7 |
8 | public static void saveUser(UserDTO user){
9 | tl.set(user);
10 | }
11 |
12 | public static UserDTO getUser(){
13 | return tl.get();
14 | }
15 |
16 | public static void removeUser(){
17 | tl.remove();
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/src/main/resources/application.yaml:
--------------------------------------------------------------------------------
1 | server:
2 | port: 8081
3 | spring:
4 | application:
5 | name: hmdp
6 | datasource:
7 | driver-class-name: com.mysql.jdbc.Driver
8 | url: jdbc:mysql://127.0.0.1:3306/hmdp?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
9 | username: root
10 | password: 123456
11 | redis:
12 | host: 127.0.0.1
13 | port: 6379
14 | password: # redis没有设置密码时，此参数不需要设置
15 | lettuce:
16 | pool:
17 | max-active: 10
18 | max-idle: 10
19 | min-idle: 1
20 | time-between-eviction-runs: 10s
21 | jackson:
22 | default-property-inclusion: non_null # JSON处理时忽略非空字段
23 | # RabbitMQ配置
24 | rabbitmq:
25 | host: 127.0.0.1
26 | port: 5672
27 | username: admin
28 | password: admin
29 | virtual-host: /
30 | publisher-confirm-type: correlated # 确认消息已发送到交换机（交互类型）
31 | publisher-returns: true
32 | template:
33 | mandatory: true #设置为 true 后 消费者在消息没有被路由到合适队列情况下会被return监听，而不会自动删除
34 | # 消费者配置
35 | listener:
36 | direct:
37 | auto-startup: true
38 | retry:
39 | enabled: true
40 | max-attempts: 3
41 | simple:
42 | acknowledge-mode: manual # 设置消费者为手动确认模式
43 | mybatis-plus:
44 | type-aliases-package: com.xydp.entity # 别名扫描包
45 | logging:
46 | level:
47 | com.xydp: debug
--------------------------------------------------------------------------------
/src/main/resources/mapper/VoucherMapper.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
13 |
14 |
--------------------------------------------------------------------------------
/src/main/resources/reentrantTryLock.lua:
--------------------------------------------------------------------------------
1 | ---
2 | --- Generated by EmmyLua(https://github.com/EmmyLua)
3 | --- Created by Wuxy.
4 | --- DateTime: 2022/5/12 21:18
5 | --- 获取锁的Lua脚本
6 | local key = KEYS[1]; -- 锁的key
7 | local threadId = ARGV[1]; -- 线程唯一标识
8 | local releaseTime = ARGV[2]; -- 锁的自动释放时间
9 | -- 判断是否存在
10 | if (redis.call('exists', key) == 0) then
11 | -- 不存在，获取锁
12 | redis.call('hset', key, threadId, '1');
13 | -- 设置有效期
14 | redis.call('expire', key, releaseTime);
15 | return 1; -- 返回结果
16 | end;
17 | -- 锁已经存在，判断threadId是否是自己
18 | if (redis.call('hexists', key, threadId) == 1) then
19 | -- 不存在，获取锁，重入次数+1
20 | redis.call('hincrby', key, threadId, '1');
21 | -- 设置有效期
22 | redis.call('expire', key, releaseTime);
23 | return 1; -- 返回结果
24 | end;
25 | return 0; --- 代码走到这里，说明获取的锁不是自己，获取锁失败
26 |
--------------------------------------------------------------------------------
/src/main/resources/reentrantUnlock.lua:
--------------------------------------------------------------------------------
1 | ---
2 | --- Generated by EmmyLua(https://github.com/EmmyLua)
3 | --- Created by Wuxy.
4 | --- DateTime: 2022/5/12 21:25
5 | ---
6 | local key = KEYS[1]; -- 锁的key
7 | local threadId = ARGV[1]; -- 线程唯一标识
8 | local releaseTime = ARGV[2]; -- 锁的自动释放时间
9 | -- 判断当前锁是否还是被自己持有
10 | if (redis.call('HEXISTS', key, threadId) == 0) then
11 | return nil; -- 如果已经不是自己，则直接放回
12 | end;
13 | -- 是自己的锁，则重入次数-1
14 | local count = redis.call('HINCBY', key, threadId, -1);
15 | -- 判断是否冲入次数是否已经为0
16 | if (count > 0) then
17 | -- 大于0说明不能释放锁，重置有效期然后放回
18 | redis.call('EXPIRE', key, releaseTime);
19 | return nil;
20 | else -- 等于0说明可以释放锁，直接删除
21 | redis.call('DEL', key);
22 | return nil;
23 | end;
--------------------------------------------------------------------------------
/src/main/resources/seckill.lua:
--------------------------------------------------------------------------------
1 | ---
2 | --- Generated by EmmyLua(https://github.com/EmmyLua)
3 | --- Created by Wuxy.
4 | --- DateTime: 2022/5/12 23:59
5 | ---
6 | -- 1.参数列表
7 | -- 1.1 优惠券id
8 | local voucherId = ARGV[1]
9 | -- 1.2 用户id
10 | local userId = ARGV[2]
11 | -- 1.3 当前时间戳
12 | local timestamp = ARGV[3]
13 |
14 | -- 2.数据key
15 | -- 2.1 库存key
16 | local stockKey = 'seckill:' .. voucherId
17 | -- 2.2 订单key
18 | local orderKey = 'seckill:order:' .. voucherId
19 |
20 | -- 3.脚本业务
21 | -- 3.1 判断当前时间戳是否大于开始时间
22 | if (redis.call('hget', 'seckill:' .. voucherId, 'begin') > timestamp) then
23 | -- 3.2 秒杀还未开始
24 | return 1;
25 | end;
26 | if (redis.call('hget', 'seckill:' .. voucherId, 'end') < timestamp) then
27 | -- 3.3 秒杀已经结束
28 | return 2;
29 | end;
30 | -- 3.4 判断库存是否充足 hget stockKey stock
31 | if (tonumber(redis.call('hget', stockKey, 'stock')) <= 0) then
32 | -- 3.5 库存不足，放回1
33 | return 3;
34 | end;
35 | -- 3.6 判断用户是否下单 SISMEMBER orderKey userId
36 | if (redis.call('sismember', orderKey, userId) == 1) then
37 | -- 3.7 存在，说明是重复下单，返回2
38 | return 4;
39 | end;
40 | -- 3.4 扣库存 incrby stockKey -1
41 | redis.call('hincrby', 'seckill:' .. voucherId, 'stock', -1);
42 | -- 3.5 下单（保存用户）sadd orderKey userId
43 | redis.call('sadd', orderKey, userId);
44 | -- todo: 3.6 发送消息到队列中， XADD stream.orders * k1 v1 k2 v2 ...
45 | --redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId);
46 | return 0; -- 成功，返回0
47 |
--------------------------------------------------------------------------------
/src/main/resources/seckillBackup.lua:
--------------------------------------------------------------------------------
1 | ---
2 | --- Generated by EmmyLua(https://github.com/EmmyLua)
3 | --- Created by Wuxy.
4 | --- DateTime: 2022/5/12 23:59
5 | ---
6 | -- 1.参数列表
7 | -- 1.1 优惠券id
8 | local voucherId = ARGV[1]
9 | -- 1.2 用户id
10 | local userId = ARGV[2]
11 | -- 1.3 订单id
12 | local orderId = ARGV[4]
13 |
14 | -- 2.数据key
15 | -- 2.1 库存key
16 | local stockKey = 'seckill:stock:' .. voucherId
17 | -- 2.2 订单key
18 | local orderKey = 'seckill:order:' .. voucherId
19 |
20 | -- 3.脚本业务
21 | -- 3.1 判断库存是否充足 get stockKey
22 | if (tonumber(redis.call('get', stockKey)) <= 0) then
23 | -- 3.2 库存不足，放回1
24 | return 1;
25 | end;
26 | -- 3.2 判断用户是否下单 SISMEMBER orderKey userId
27 | if (redis.call('sismember', orderKey, userId) == 1) then
28 | -- 3.3 存在，说明是重复下单，返回2
29 | return 2;
30 | end;
31 | -- 3.4 扣库存 incrby stockKey -1
32 | redis.call('incrby', stockKey, -1);
33 | -- 3.5 下单（保存用户）sadd orderKey userId
34 | redis.call('sadd', orderKey, userId);
35 | -- todo: 3.6 发送消息到队列中， XADD stream.orders * k1 v1 k2 v2 ...
36 | --redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId);
37 | return 0; -- 成功，返回0
--------------------------------------------------------------------------------
/src/main/resources/unlock.lua:
--------------------------------------------------------------------------------
1 | -- 获取锁中的线程标识 get key
2 | local id = redis.call('get', KEYS[1])
3 | -- 比较线程标识与锁中的标识是否一致
4 | if (id == ARGV[1]) then
5 | -- 释放锁 del key
6 | return redis.call('del', KEYS[1])
7 | end
8 | return 0
--------------------------------------------------------------------------------
/src/test/java/com/xydp/HmDianPingApplicationTests.java:
--------------------------------------------------------------------------------
1 | package com.xydp;
2 |
3 | import com.xydp.entity.Shop;
4 | import com.xydp.service.impl.ShopServiceImpl;
5 | import com.xydp.utils.CacheClient;
6 | import com.xydp.utils.RedisIdWorker;
7 | import org.junit.jupiter.api.Test;
8 | import org.springframework.beans.factory.annotation.Autowired;
9 | import org.springframework.boot.test.context.SpringBootTest;
10 | import org.springframework.data.geo.Point;
11 | import org.springframework.data.redis.connection.RedisGeoCommands;
12 | import org.springframework.data.redis.core.StringRedisTemplate;
13 |
14 | import javax.annotation.Resource;
15 | import java.util.ArrayList;
16 | import java.util.List;
17 | import java.util.Map;
18 | import java.util.concurrent.CountDownLatch;
19 | import java.util.concurrent.ExecutorService;
20 | import java.util.concurrent.Executors;
21 | import java.util.concurrent.TimeUnit;
22 | import java.util.stream.Collectors;
23 |
24 | import static com.xydp.utils.RedisConstants.CACHE_SHOP_KEY;
25 |
26 | @SpringBootTest
27 | class HmDianPingApplicationTests {
28 |
29 | @Autowired
30 | private CacheClient cacheClient;
31 |
32 | @Resource
33 | private ShopServiceImpl shopService;
34 |
35 | @Resource
36 | private RedisIdWorker redisIdWorker;
37 |
38 | @Resource
39 | private StringRedisTemplate stringRedisTemplate;
40 |
41 | private final ExecutorService es = Executors.newFixedThreadPool(500);
42 |
43 | @Test
44 | void testSaveShop() {
45 | shopService.saveShop2Redis(1L, 10L);
46 | }
47 |
48 | @Test
49 | void testSaveLogicalExpire() {
50 | Shop shop = shopService.getById(1L);
51 | cacheClient.setWithLogicalExpire(CACHE_SHOP_KEY + 1L, shop, 10L, TimeUnit.SECONDS);
52 | }
53 |
54 | @Test
55 | void testIdWorker() throws InterruptedException {
56 | CountDownLatch latch = new CountDownLatch(300);
57 | Runnable task = () -> {
58 | for (int i = 0; i < 100; i++) {
59 | long id = redisIdWorker.nextId("order");
60 | System.out.println("id: " + id);
61 | }
62 | latch.countDown();
63 | };
64 | long begin = System.currentTimeMillis();
65 | for (int i = 0; i < 300; i++) {
66 | es.submit(task);
67 | }
68 | latch.await();
69 | long end = System.currentTimeMillis();
70 | System.out.println("time = " + (end - begin));
71 | }
72 |
73 | @Test
74 | void loadShopData() {
75 | // 1.查询店铺信息
76 | List list = shopService.list();
77 | // 2.把店铺分组，按照typeId分组，id一致的放到一个集合
78 | Map> map = list.stream().collect(Collectors.groupingBy(Shop::getTypeId));
79 | // 3.分批完成写入Redis
80 | for (Map.Entry> entry : map.entrySet()) {
81 | // 3.1 获取类型id
82 | Long typeId = entry.getKey();
83 | String key = "shop:geo:" + typeId;
84 | // 3.2 获取同类型的店铺的集合
85 | List value = entry.getValue();
86 | List> locations = new ArrayList<>(value.size());
87 | // 3.3 写入Redis GEOADD key 经度 纬度 member
88 | for (Shop shop : value) {
89 | // stringRedisTemplate.opsForGeo().add(key, new Point(shop.getX(), shop.getY()), shop.getId().toString());
90 | locations.add(new RedisGeoCommands.GeoLocation<>(
91 | shop.getId().toString(),
92 | new Point(shop.getX(), shop.getY())));
93 | }
94 | // 批量写入，提高效率
95 | stringRedisTemplate.opsForGeo().add(key, locations);
96 | }
97 | }
98 |
99 | @Test
100 | void testHyperLogLog() {
101 | String[] values = new String[1000];
102 | for (int i = 0; i < 1000000; i++) {
103 | values[i % 1000] = "user_" + i;
104 | if (i % 1000 == 999) {
105 | // 发送到Redis
106 | stringRedisTemplate.opsForHyperLogLog().add("hl2", values);
107 | }
108 | }
109 | // 统计数量
110 | Long count = stringRedisTemplate.opsForHyperLogLog().size("hl2");
111 | System.out.println("count: " + count);
112 | }
113 | }
114 |
--------------------------------------------------------------------------------
/src/test/java/com/xydp/RedissonTest.java:
--------------------------------------------------------------------------------
1 | package com.xydp;
2 |
3 | import lombok.extern.slf4j.Slf4j;
4 | import org.junit.jupiter.api.BeforeEach;
5 | import org.junit.jupiter.api.Test;
6 | import org.redisson.RedissonMultiLock;
7 | import org.redisson.api.RLock;
8 | import org.redisson.api.RedissonClient;
9 | import org.springframework.boot.test.context.SpringBootTest;
10 |
11 | import javax.annotation.Resource;
12 | import java.util.concurrent.TimeUnit;
13 |
14 | @Slf4j
15 | @SpringBootTest
16 | public class RedissonTest {
17 |
18 | @Resource
19 | private RedissonClient redissonClient;
20 | @Resource
21 | private RedissonClient redissonClient2; // 测试Redis集群（主从分离）
22 | @Resource
23 | private RedissonClient redissonClient3;
24 |
25 | private RLock lock;
26 |
27 | @BeforeEach
28 | void setUp() {
29 | RLock lock1 = redissonClient.getLock("order");
30 | RLock lock2 = redissonClient2.getLock("order");
31 | RLock lock3 = redissonClient3.getLock("order");
32 |
33 | // 创建联锁 multiLock
34 | lock = new RedissonMultiLock(lock1, lock2, lock3);
35 | }
36 |
37 | @Test
38 | void method1() throws InterruptedException {
39 | // 尝试获取锁
40 | boolean isLock = lock.tryLock(1L, TimeUnit.SECONDS);
41 | if (!isLock) {
42 | log.error("获取锁失败 ....1");
43 | return;
44 | }
45 | try {
46 | log.info("获取锁成功 ....1");
47 | method2();
48 | log.info("开始执行业务 ....1");
49 | } finally {
50 | log.warn("准备释放锁 ....1");
51 | lock.unlock();
52 | }
53 | }
54 |
55 | @Test
56 | void method2() {
57 | // 尝试获取锁
58 | boolean isLock = lock.tryLock();
59 | if (!isLock) {
60 | log.error("获取锁失败 ....2");
61 | return;
62 | }
63 | try {
64 | log.info("获取锁成功 ....2");
65 | log.info("开始执行业务 ....2");
66 | } finally {
67 | log.warn("准备释放锁 ....2");
68 | lock.unlock();
69 | }
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/src/test/java/com/xydp/VoucherOrderControllerTest.java:
--------------------------------------------------------------------------------
1 | package com.xydp;
2 |
3 | import cn.hutool.core.lang.Assert;
4 | import cn.hutool.core.thread.ThreadUtil;
5 | import com.fasterxml.jackson.databind.ObjectMapper;
6 | import com.xydp.dto.LoginFormDTO;
7 | import com.xydp.dto.Result;
8 | import com.xydp.entity.User;
9 | import com.xydp.service.IUserService;
10 | import lombok.SneakyThrows;
11 | import org.junit.jupiter.api.DisplayName;
12 | import org.junit.jupiter.api.Test;
13 | import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
14 | import org.springframework.boot.test.context.SpringBootTest;
15 | import org.springframework.http.MediaType;
16 | import org.springframework.test.web.servlet.MockMvc;
17 | import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
18 | import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
19 |
20 | import javax.annotation.Resource;
21 | import java.io.BufferedWriter;
22 | import java.io.File;
23 | import java.io.OutputStreamWriter;
24 | import java.nio.charset.StandardCharsets;
25 | import java.nio.file.Files;
26 | import java.util.List;
27 | import java.util.concurrent.CopyOnWriteArrayList;
28 | import java.util.concurrent.CountDownLatch;
29 | import java.util.concurrent.ExecutorService;
30 | import java.util.stream.Collectors;
31 |
32 | /**
33 | * @author Wuxy
34 | * @version 1.0
35 | * @ClassName VoucherOrderControllerTest
36 | * @since 2023/1/13 11:45
37 | */
38 | @SpringBootTest
39 | @AutoConfigureMockMvc
40 | class VoucherOrderControllerTest {
41 |
42 | @Resource
43 | private MockMvc mockMvc;
44 |
45 | @Resource
46 | private IUserService userService;
47 |
48 | @Resource
49 | private ObjectMapper mapper;
50 |
51 | @Test
52 | @SneakyThrows
53 | @DisplayName("登录1000个用户，并输出到文件中")
54 | void login() {
55 | List phoneList = userService.lambdaQuery().select(User::getPhone).last("limit 1000").list().stream().map(User::getPhone).collect(Collectors.toList());
56 | ExecutorService executorService = ThreadUtil.newExecutor(phoneList.size());
57 | List tokenList = new CopyOnWriteArrayList<>();
58 | CountDownLatch countDownLatch = new CountDownLatch(phoneList.size());
59 | phoneList.forEach(phone -> executorService.execute(() -> {
60 | try {
61 | // 验证码
62 | String codeJson = mockMvc.perform(MockMvcRequestBuilders.post("/user/code").queryParam("phone", phone)).andExpect(MockMvcResultMatchers.status().isOk()).andReturn().getResponse().getContentAsString();
63 | Result result = mapper.readerFor(Result.class).readValue(codeJson);
64 | Assert.isTrue(result.getSuccess(), String.format("获取“%s”手机号的验证码失败", phone));
65 | String code = result.getData().toString();
66 | LoginFormDTO formDTO = LoginFormDTO.builder().code(code).phone(phone).build();
67 | String json = mapper.writeValueAsString(formDTO);
68 | // token
69 | String tokenJson = mockMvc.perform(MockMvcRequestBuilders.post("/user/login").content(json).contentType(MediaType.APPLICATION_JSON)).andExpect(MockMvcResultMatchers.status().isOk()).andReturn().getResponse().getContentAsString();
70 | result = mapper.readerFor(Result.class).readValue(tokenJson);
71 | Assert.isTrue(result.getSuccess(), String.format("获取“%s”手机号的token失败,json为“%s”", phone, json));
72 | String token = result.getData().toString();
73 | tokenList.add(token);
74 | countDownLatch.countDown();
75 | } catch (Exception e) {
76 | e.printStackTrace();
77 | }
78 | }));
79 | countDownLatch.await();
80 | executorService.shutdown();
81 | Assert.isTrue(tokenList.size() == phoneList.size());
82 | writeToTxt(tokenList, "\\tokens.txt");
83 | System.out.println("写入完成！");
84 | }
85 |
86 | private static void writeToTxt(List list, String suffixPath) throws Exception {
87 | // 1. 创建文件
88 | File file = new File(System.getProperty("user.dir") + "\\src\\main\\resources" + suffixPath);
89 | if (!file.exists()) {
90 | System.out.println("The state of file create is " + file.createNewFile());
91 | }
92 | // 2. 输出
93 | BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(Files.newOutputStream(file.toPath()), StandardCharsets.UTF_8));
94 | for (String content : list) {
95 | bw.write(content);
96 | bw.newLine();
97 | }
98 | bw.close();
99 | }
100 | }
101 |
--------------------------------------------------------------------------------