xx点评简单后端项目

SOURCE hmdp.sql;

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/hmdp?useSSL=false&serverTimezone=UTC
    username: xx
    password: xx
  redis:
    host: 127.0.0.1
    port: 6379
    lettuce:
      pool:
        max-active: 10
        max-idle: 10
        min-idle: 1
        time-between-eviction-runs: 10s

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

stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY+phone,code,LOGIN_CODE_TTL, TimeUnit.MINUTES);

String code = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY+phone);

客户端请求
   ↓
Filter（编码 / 跨域等）
   ↓
DispatcherServlet
   ↓
Interceptor.preHandle()
   ↓
Controller
   ↓
Interceptor.postHandle()
   ↓
Interceptor.afterCompletion()

String token = request.getHeader("Authorization");

// 将Hash数据转为UserDTO对象
UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap,new UserDTO(),false);
UserHolder.saveUser(userDTO);

    // 防御缓存穿透相关代码，留作备份
//    public Shop queryWithPassThrough(Long id){
//        String key = CACHE_SHOP_KEY + id;
//        // 从redis查询缓存
//        String shopJson = stringRedisTemplate.opsForValue().get(key);
//
//        // 注意这里的isNotBlank仅仅判断查询到的shopJson有没有值，null、空值等不包括在内，因此下面还要做一次校验
//        if (StrUtil.isNotBlank(shopJson)){
//            return JSONUtil.toBean(shopJson, Shop.class);
//        }
//
//        // 如果查询到的不是null，那么就只能是我们设置的空值
//        if (shopJson != null) {
//            return null;
//        }
//
//        Shop shop = getById(id);
//        // 如果数据库里面都不存在，则需要先缓存一下空值，然后返回fail
//        if (shop == null){
//            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL + RandomUtil.randomLong(1,6),TimeUnit.MINUTES);
//            return null;
//        }
//        // 若存在则先保存到redis，然后返回给用户
//        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL + RandomUtil.randomLong(1,6), TimeUnit.MINUTES);
//
//        return shop;
//    }

public Shop queryWithMutex(Long id){
     String key = CACHE_SHOP_KEY + id;
     // 从redis查询缓存
     String shopJson = stringRedisTemplate.opsForValue().get(key);

     // 注意这里的isNotBlank仅仅判断查询到的shopJson有没有值，null、空值等不包括在内，因此下面还要做一次校验
     if (StrUtil.isNotBlank(shopJson)){
         return JSONUtil.toBean(shopJson, Shop.class);
     }

     // 如果查询到的不是null，那么就只能是我们设置的空值
     if (shopJson != null) {
         return null;
     }

     // 到这为止就是“未命中”，需要尝试获取互斥锁
     String keyLock = LOCK_SHOP_KEY + id;
     Shop shop = null;
     try {

         // 如果锁获取失败，那么需要休眠一段时间再来获取，用递归实现
         if (!tryLock(keyLock)) {
             Thread.sleep(50);
             return queryWithMutex(id);
         }

         shop = getById(id);
         // 如果数据库里面都不存在，则需要先缓存一下空值，然后返回fail
         if (shop == null){
             stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL + RandomUtil.randomLong(1,6),TimeUnit.MINUTES);
             return null;
         }
         // 若存在则先保存到redis，然后返回给用户
         stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL + RandomUtil.randomLong(1,6), TimeUnit.MINUTES);

     } catch (Exception e) {
         throw new RuntimeException(e);
     }finally {
         unlock(keyLock);
     }
     return shop;
 }

public Shop queryWithMutex(Long id) {
    boolean isLock = tryLock();

    try {
        if (!tryLock(keyLock)) {
           Thread.sleep(50);
           return queryWithMutex(id);
        }
    } finally {
        unlock(keyLock);
    }
}

String valueInRedis = stringRedisTemplate.opsForValue().get(key);
if (lockValue.equals(valueInRedis)) {
    stringRedisTemplate.delete(key);
}

if redis.call('get', KEYS[1]) == ARGV[1] then
    return redis.call('del', KEYS[1])
else
    return 0
end
/*
KEYS[1] → Redis 脚本的第一个 key，在 Java 里传的是锁 key
ARGV[1] → Redis 脚本的第一个参数，在 Java 里传的是锁 value（UUID token）
redis.call('get', KEYS[1]) → 拿到当前锁的 value
判断 get(key) 是否等于我们自己的 token（保证安全解锁）
相等 → 删除锁 (del) 并返回 1
不相等 → 不删除，返回 0
*/

stringRedisTemplate.execute(
    UNLOCK_SCRIPT,                 // Lua 脚本
    Collections.singletonList(key),// KEYS
    value                          // ARGV
);

@Test
    public void testConcurrentQuery() throws InterruptedException {
        Long id = 1L;

        stringRedisTemplate.delete(CACHE_SHOP_KEY + id); // 模拟缓存未命中

        // 模拟50个并发请求
        int threadCount = 50;
        CountDownLatch latch = new CountDownLatch(threadCount);


        // 循环启动50个线程，第一个线程拿到锁去查询数据库，然后存到缓存里面，其它的线程阻塞等待第一个线程拿到数据或者超时返回null
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    Shop shop = (Shop) shopService.queryById(id).getData();
                    System.out.println(Thread.currentThread().getName() + ": " + shop);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            }).start();
        }

        latch.await();
    }

// 创建10个线程池
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

// 逻辑过期解决缓存穿透
public Shop queryWithLogicalExpire(Long id){
    String key = CACHE_SHOP_KEY + id;
    // 从redis查询缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);

    // 这里默认一定命中，若未命中则认为不是热点key，不需要处理
    if (StrUtil.isBlank(shopJson)){
        return null;
    }

    // 若命中则需要判断缓存是否过期，先把查询到的redis字符串反序列化为对象
    RedisData redisData = JSONUtil.toBean(shopJson,RedisData.class);
    Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(),Shop.class);
    LocalDateTime expireTime = redisData.getExpireTime();

    // 判断逻辑是否过期，若未过期则直接返回即可，如果过期，则需要利用互斥锁，让一个线程去重建缓存，其它的线程先直接返回过期信息即可
    if (expireTime.isAfter(LocalDateTime.now())){
        return shop;
    }

    String keyLock = LOCK_SHOP_KEY + id;
    String valueLock = UUID.randomUUID().toString();
    boolean isLock = tryLock(keyLock,valueLock);

    // 拿到锁了之后新创建一个新的线程，让它去重建缓存，自己先直接返回旧数据
    if (isLock){
        // 拿到锁之后仍然要做一次double check
        shopJson = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isNotBlank(shopJson)) {
            redisData = JSONUtil.toBean(shopJson,RedisData.class);
            if (redisData.getExpireTime().isAfter(LocalDateTime.now())){
                shop = JSONUtil.toBean((JSONObject) redisData.getData(),Shop.class);
                unlock(keyLock,valueLock);
                return shop;
            }
        }

        CACHE_REBUILD_EXECUTOR.submit(() -> {
           try {
               this.saveShop2Redis(id,20L);
           } catch (Exception e){
               // 异步线程抛异常不会回到主线程，因此其抛异常没有什么意义，应该做一下日志
               log.error("缓存重建失败，shopId={}", id, e);
           }finally{
               unlock(keyLock,valueLock);
           }
        });
    }

    return shop;
}

new Runnable() {
    @Override
    public void run() {
        this.saveShop2Redis(id, 20L);
    }
}

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

Shop shop = cacheStrategy.queryById(id, () -> getById(id));

shop:
  cache:
    strategy: mutexStrategy

package com.hmdp.utils;

/*
    全局id生成工具类
    生成的id共为64bit的序列号，第一位为符号位（不用管），中间31位为时间戳，后面32位为实际递增的序列号
 */

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;

@Component
public class RedisIdWorker {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    // 初始时间戳
    private static final long BEGIN_TIMESTAMP = 1640995200L;

    // 时间戳左移的位数，可更改
    private static final int COUNT_BITS = 32;

    public long nextId(String keyPrefix){
        // 生成时间戳
        LocalDateTime now = LocalDateTime.now();
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
        long timestamp = nowSecond - BEGIN_TIMESTAMP;

        /*
            用redis的字符串自增策略生成序列号
         */
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        // 把key对应的value + 1，若不存在则视为0（value必须不存在或者为整数，非整数均会报错）
        long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);

        return timestamp << COUNT_BITS | count;


    }

}

@Autowired
private RedisIdWorker redisIdWorker;

// 创建一个 最多 500 个线程的线程池
private static final ExecutorService es = Executors.newFixedThreadPool(500);
@Test
public void testRedisIdWorker() throws InterruptedException {

    // 可以理解为一个300的计数器。每完成一个任务-1,变成 0 时await() 才会放行
    CountDownLatch latch = new CountDownLatch(300);

    // 每个用户请求 100 次 ID，共300个线程，所以一共发起了300x100=30000个请求
    Runnable task = () -> {
        for (int i = 0; i < 100; i++){
            long id = redisIdWorker.nextId("order");
            System.out.println("id = " + id);
        }

        // 表示一个进程结束了
        latch.countDown();
    };
    long begin = System.currentTimeMillis();
    for (int i = 0; i < 300; i++) {
        es.submit(task);
    }

    // 阻塞当前测试线程，直到 300 个 task 全部执行完
    latch.await();
    long end = System.currentTimeMillis();

    System.out.println("time = " + (end - begin));
}

package com.hmdp.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.time.LocalDateTime;

/**
 * <p>
 * 秒杀优惠券表，与优惠券是一对一关系
 * </p>
 *
 * @author 虎哥
 * @since 2022-01-04
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
// 上面三个注解均是lombok
// EqualsAndHashCode表示生成 equals 和 hashCode 时，不调用父类的字段
// 意思就是在判断两个对象是否相等、以及计算哈希值时，只看当前这个类自己声明的字段，不管它父类里有什么字段，但这个类没父类，所以可有可无

// Accessors表示开启链式调用

@TableName("tb_seckill_voucher")
// 告诉 MyBatis-Plus这个实体类对应哪张表。如果没有它，MyBatis-Plus 会默认SeckillVoucher → seckill_voucher

// Serializable表明这个对象可以被序列化（变成字节流）
public class SeckillVoucher implements Serializable {

    // 防止序列化版本不一致导致反序列化失败，一般写1L，不写也可以
    private static final long serialVersionUID = 1L;

    /**
     * 关联的优惠券的id
     */
    // value表示Java 字段 voucherId ↔ 数据库字段 voucher_id。
    // type表示MyBatis-Plus 主键策略，这里用的是INPUT，表明插入 tb_seckill_voucher 时，voucher_id 必须自己传
    @TableId(value = "voucher_id", type = IdType.INPUT)
    private Long voucherId;

    /**
     * 库存
     */
    private Integer stock;

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

    /**
     * 生效时间
     */
    private LocalDateTime beginTime;

    /**
     * 失效时间
     */
    private LocalDateTime endTime;

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;


}

package com.hmdp.service.impl;

import com.hmdp.dto.Result;
import com.hmdp.entity.SeckillVoucher;
import com.hmdp.entity.VoucherOrder;
import com.hmdp.mapper.VoucherOrderMapper;
import com.hmdp.service.ISeckillVoucherService;
import com.hmdp.service.IVoucherOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.utils.RedisIdWorker;
import com.hmdp.utils.UserHolder;
import org.apache.tomcat.jni.Local;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.time.LocalDateTime;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 虎哥
 * @since 2021-12-22
 */
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {

    @Resource
    private ISeckillVoucherService seckillVoucherService;

    @Resource
    private RedisIdWorker redisIdWorker;

    @Override
    public Result seckillVoucher(Long voucherId) {
        // 查询优惠券
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);

        // 判断秒杀时间
        if (voucher.getBeginTime().isAfter(LocalDateTime.now()) || voucher.getEndTime().isBefore(LocalDateTime.now())){
            return Result.fail("当前不在秒杀时间");
        }

        // 判断库存数量
        if (voucher.getStock() < 1){
            return Result.fail("库存不足");
        }

        // 先让库存数减一
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId).update();
        if (!success){
            // 扣减库存失败，一般认为也是库存不足
            return Result.fail("库存不足");
        }

        // 创建订单
        VoucherOrder voucherOrder = new VoucherOrder();

        // 获取订单id，用前面的全局id生成器
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);

        // 获取用户id，用UserHolder
        Long userId = UserHolder.getUser().getId();
        voucherOrder.setUserId(userId);

        // 优惠券id直接根据传入的即可
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);

        // 返回订单编号
        return Result.ok(orderId);

    }
}

boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId).eq("stock",voucher.getStock()).update();

boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId).gt("stock",0).update();

@Transactional
    public synchronized Result createVoucherOrder(Long voucherId) {
        // 判断该用户是否已经买过
        Long userId = UserHolder.getUser().getId();
        int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
        if (count > 0){
            return Result.fail("用户已购买过一次！");
        }

        // 先让库存数减一
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId).gt("stock",0).update();
        if (!success){
            // 扣减库存失败，一般认为也是库存不足
            return Result.fail("库存不足");
        }


        // 创建订单
        VoucherOrder voucherOrder = new VoucherOrder();

        // 获取订单id，用前面的全局id生成器
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);

        voucherOrder.setUserId(userId);

        // 优惠券id直接根据传入的即可
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);

        // 返回订单编号
        return Result.ok(orderId);
    }

@Transactional
   public Result createVoucherOrder(Long voucherId) {
       // 判断该用户是否已经买过
       Long userId = UserHolder.getUser().getId();
       synchronized (userId.toString().intern()) {
           int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
           if (count > 0) {
               return Result.fail("用户已购买过一次！");
           }

           // 先让库存数减一
           boolean success = seckillVoucherService.update()
                   .setSql("stock = stock - 1")
                   .eq("voucher_id", voucherId).gt("stock", 0).update();
           if (!success) {
               // 扣减库存失败，一般认为也是库存不足
               return Result.fail("库存不足");
           }


           // 创建订单
           VoucherOrder voucherOrder = new VoucherOrder();

           // 获取订单id，用前面的全局id生成器
           long orderId = redisIdWorker.nextId("order");
           voucherOrder.setId(orderId);

           voucherOrder.setUserId(userId);

           // 优惠券id直接根据传入的即可
           voucherOrder.setVoucherId(voucherId);
           save(voucherOrder);

           // 返回订单编号
           return Result.ok(orderId);
       }
   }

@Resource
private IVoucherOrderService voucherOrderService;

@Test
public void testConcurrentCreateVoucherOrder() throws InterruptedException {
    int threadCount = 100;
    ExecutorService executorService = Executors.newFixedThreadPool(20);
    CountDownLatch latch = new CountDownLatch(threadCount);

    Long voucherId = 11L;   // 数据库里真实存在的秒杀券 ID
    Long userId = 10001L;  // 随便写一个userId模拟同一个用户

    for (int i = 0; i < threadCount; i++) {
        executorService.submit(() -> {
            try {
                // 模拟登录逻辑，保证ThreadLocal里面有User信息
                UserDTO user = new UserDTO();
                user.setId(userId);
                UserHolder.saveUser(user);

                Result result = voucherOrderService.seckillVoucher(voucherId);
                if (result.getSuccess()) {
                    System.out.println(Thread.currentThread().getName()
                            + " SUCCESS, orderId=" + result.getData());
                } else {
                    System.out.println(Thread.currentThread().getName()
                            + " FAIL, reason=" + result.getErrorMsg());
                }


            } finally {
                // 必须清理ThreadLocal
                UserHolder.removeUser();
                latch.countDown();
            }
        });
    }

    latch.await();
}

Long userId = UserHolder.getUser().getId();
synchronized (userId.toString().intern()) {
	return createVoucherOrder(voucherId,userId);
}

调用 Bean 方法 -> 代理对象 intercept -> 开启事务 -> 调用原始方法 -> 方法返回 -> 提交/回滚事务

synchronized (userId.toString().intern()) {
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId,userId);
        }

<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
</dependency>

package com.hmdp.utils;

import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.concurrent.TimeUnit;

public class SimpleRedisLock implements ILock{

    // 可以把userId用来做保证唯一性的key
    private String name;
    private StringRedisTemplate stringRedisTemplate;

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate){
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    private static final String KEY_PREFIX = "lock:";

    @Override
    public boolean tryLock(long timeoutSec) {

        // 获取线程标识
        long threadId = Thread.currentThread().getId();
        // 获取锁
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name, threadId + "", timeoutSec, TimeUnit.SECONDS);

        // 防止自动拆箱出现空指针
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {
        stringRedisTemplate.delete(KEY_PREFIX + name);
    }
}

synchronized (userId.toString().intern()) {
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId,userId);
}

// 创建锁对象
SimpleRedisLock lock = new SimpleRedisLock("order" + userId, stringRedisTemplate);
// 从锁对象获取锁
boolean isLock = lock.tryLock(1200);
if (!isLock){
    // 若获取锁失败，则返回错误或重试。这里直接返回错误（为了防止超卖问题）
    return Result.fail("不允许重复下单");
}
try{
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
    return proxy.createVoucherOrder(voucherId,userId);
}finally {
    // 释放锁
    lock.unlock();
}

package com.hmdp.utils;

import cn.hutool.core.lang.UUID;
import org.springframework.data.redis.core.StringRedisTemplate;

import java.util.concurrent.TimeUnit;

public class SimpleRedisLock implements ILock{

    // 可以把userId用来做保证唯一性的key
    private String name;
    private StringRedisTemplate stringRedisTemplate;

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate){
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    private static final String KEY_PREFIX = "lock:";
    private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";

    // 获取线程标识
    String threadId = ID_PREFIX + Thread.currentThread().getId();

    @Override
    public boolean tryLock(long timeoutSec) {
        // 获取锁
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);

        // 防止自动拆箱出现空指针
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {
        // 用key去redis数据库找value再和线程标识比对，若这两个相等则可以证明是自己的锁，可以释放，否则不应该释放
        String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
        if (threadId.equals(id)){
            stringRedisTemplate.delete(KEY_PREFIX + name);
        }
    }
}

redis.call('命令名称','key','其它参数')

redis.call('set','name','jack')

eval "return redis.call('set', 'name', 'jack')" 0

-- 获取锁中的线程标识 get key
local id = redis.call('get',KEYS[1])
-- 比较线程标识与锁中的标识是否一致
if(id == ARGV[1]) then
    -- 释放锁 del key
    return redis.call('del',KEYS[1])
end
return 0

package com.hmdp.utils;

import cn.hutool.core.lang.UUID;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;

import java.util.Collections;
import java.util.concurrent.TimeUnit;

public class SimpleRedisLock implements ILock{

    // 可以把userId用来做保证唯一性的key
    private String name;
    private StringRedisTemplate stringRedisTemplate;

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate){
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    private static final String KEY_PREFIX = "lock:";
    private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";
    // 作为Lua的执行媒介对象
    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
    static{
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
        UNLOCK_SCRIPT.setResultType(Long.class);
    }

    // 获取线程标识
    String threadId = ID_PREFIX + Thread.currentThread().getId();

    @Override
    public boolean tryLock(long timeoutSec) {
        // 获取锁
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
        // 防止自动拆箱出现空指针
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {
        // 调用lua脚本
        stringRedisTemplate.execute(
                UNLOCK_SCRIPT,
                Collections.singletonList(KEY_PREFIX + name),
                ID_PREFIX + Thread.currentThread().getId()
        );
    }
}