黑马点评项目笔记

@Slf4j
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
    @Override
    public Result sendcode(String phone, HttpSession session){
        //1.校验手机号,utils的工具包
        if(RegexUtils.isPhoneInvalid(phone)){
            //2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误！");
        }

        //3.符合，生成验证码,一个java的工具包
        String code = RandomUtil.randomNumbers(6);

        //4.保存验证码道session
        session.setAttribute("code",code);

        //5.发送验证码,需要调用第三方的短信平台，比如说阿里云
        //TODO
        log.debug("发送短信验证码成功，验证码：{}",code);

        //返回ok
        return Result.ok(code);
    }
}

@Override
public Result login(LoginFormDTO loginForm, HttpSession session){
    //1.校验手机号
    String phone = loginForm.getPhone();
    if(RegexUtils.isPhoneInvalid(phone)){
        return Result.fail("手机号格式错误！");
    }

    //2.校验验证码
    Object cacheCode = session.getAttribute("code");
    String code = loginForm.getCode();
    if(cacheCode==null || !cacheCode.toString().equals(code)){
        //3.不一致报错
        return Result.fail("验证码错误");
    }

    //4.一致，根据手机号查询用户,select * from tb_user where phone = ?
    User user = query().eq("phone", phone).one();

    //5.判断用户是否存在
    if(user==null){
        //6.不存在，创建用户并保存,只需要填充phone和nickname字段即可
        user = createUserWithPhone(String phone);
    }

    //7.保存用户信息到session中
    session.setAttribute("user",user);
    
    return Result.ok();
}
private  User createUserWithPhone(String phone){
    //1.创建用户
    User user = new User();
    user.setPhone(phone);
    user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));

    //2.保存用户
    save(user);
    return user;
}

/*
	在utils中添加LoginInterceptor.java作为拦截器
*/
public class LoginInterceptor implements HandlerInterceptor {
    //预拦截
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.获取session
        HttpSession session = request.getSession();
        //2.获取session中的user
        Object user = session.getAttribute("user");
        //3.判断用户是否在存在
        if(user==null){
            //4.不存在，返回401状态码
            response.setStatus(401);
            return false;
        }
        //5.存在，保存用户信息到ThreadLocal
        UserHolder.saveUser((UserDTO) user);
        //6.放行
        return true;
    }

    //渲染之前的拦截
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //移除用户
        UserHolder.removeUser();
    }
}


/*
	在config中添加MvcConfig.java
*/
@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .excludePathPatterns(
                        "/user/code"
                        , "/user/login"
                        , "/blog/hot"
                        , "/shop/**"
                        , "/shop-type/**"
                        , "/upload/**"
                        , "/voucher/**"
                );
    }
}

/*
	controller拿到用户登录的信息，通过这个ThreadLocal	
*/
@GetMapping("/me")
public Result me(){
    // 获取当前登录的用户并返回
    UserDTO user = UserHolder.getUser();
    return Result.ok(user);
}

/*
	1.需要在登录的时候，将传入session的user更改成userDTO
	2.更改UserHolder中的所有的相关信息和拦截器调用信息为userDTO
	3.更改me接口，return一个UserDTO信息
*/
//登录时保存用户信息到session中
session.setAttribute("user", BeanUtil.copyProperties(user, UserDTO.class));

 @Resource
private StringRedisTemplate stringRedisTemplate;

@Override
public Result sendcode(String phone, HttpSession session){
    //1.校验手机号,utils的工具包
    if(RegexUtils.isPhoneInvalid(phone)){
        //2.如果不符合，返回错误信息
        return Result.fail("手机号格式错误！");
    }

    //3.符合，生成验证码,一个java的工具包
    String code = RandomUtil.randomNumbers(6);

    //4.保存验证码到redis
    stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY+phone,code,LOGIN_CODE_TTL, TimeUnit.MINUTES);

    //5.发送验证码,需要调用第三方的短信平台，比如说阿里云
    log.debug("发送短信验证码成功，验证码：{}",code);

    //返回ok
    return Result.ok(code);
}

@Override
public Result login(LoginFormDTO loginForm, HttpSession session){
    //1.校验手机号
    String phone = loginForm.getPhone();
    if(RegexUtils.isPhoneInvalid(phone)){
        return Result.fail("手机号格式错误！");
    }

    //2.从redis中获取验证码并进行校验
    String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY+phone);
    String code = loginForm.getCode();
    if(cacheCode==null || !cacheCode.equals(code)){
        //3.不一致报错
        return Result.fail("验证码错误");
    }

    //4.一致，根据手机号查询用户,select * from tb_user where phone = ?
    User user = query().eq("phone", phone).one();

    //5.判断用户是否存在
    if(user==null){
        //6.不存在，创建用户并保存,只需要填充phone和nickname字段即可
        user = createUserWithPhone(phone);
    }

    //7.保存用户信息到redis
    //7.1随机生成token,作为登录令牌
    String token = UUID.randomUUID().toString();
    //7.2将user对象转为hash存储
    UserDTO userDTO = BeanUtil.copyProperties(user,UserDTO.class);
    Map<String, Object> userMap = BeanUtil.beanToMap(userDTO,new HashMap<>(),
                //解决id字段是整型而不是字符串类型
                CopyOptions.create().setIgnoreNullValue(true).setFieldValueEditor((fieldName,fieldValue)->fieldValue.toString())
        );
    //7.3存储
    String tokenKey = LOGIN_USER_KEY+token;
    stringRedisTemplate.opsForHash().putAll(tokenKey,userMap);   //添加hash对象
    stringRedisTemplate.expire(tokenKey,LOGIN_USER_TTL, TimeUnit.MINUTES);

    //8.返回token
    return Result.ok(token);

private StringRedisTemplate stringRedisTemplate;

public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {
    this.stringRedisTemplate = stringRedisTemplate;
}

//预拦截
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    //1.获取请求头中的token
    String token = request.getHeader("authorization");
    if(StrUtil.isBlank(token)){
        response.setStatus(401);
        return false;
    }

    //2.基于token获取redis中的用户
    String key = RedisConstants.LOGIN_USER_KEY + token;
    Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);

    //3.判断用户是否在存在
    if(userMap.isEmpty()){
        //4.不存在，返回401状态码
        response.setStatus(401);
        return false;
    }
    //5.将查询到的hash数据转为UserDTO对象
    UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap,new UserDTO(),false);

    //6.存在，保存用户信息到ThreadLocal
    UserHolder.saveUser(userDTO);

    //7.刷新token的有效期
    stringRedisTemplate.expire(key,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);

    //8.放行
    return true;
}


/*
	此时的MVCCONFIG需要更新
*/
@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor(stringRedisTemplate))
                .excludePathPatterns(
                        "/user/code"
                        , "/user/login"
                        , "/blog/hot"
                        , "/shop/**"
                        , "/shop-type/**"
                        , "/upload/**"
                        , "/voucher/**"
                );
    }
}

//具体做法：拷贝一份新的RefreshTokenInterceptor，并重写一下LoginInterceptor

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    //1.判断是否需要进行拦截（ThreadLocal中是否有用户）
    if(UserHolder.getUser() == null){
        //没有，需要进行拦截
        response.setStatus(401);
        //拦截
        return false;
    }
    //有用户，进行放行操作
    return true;
}


//需要更新一下MvcConfig
@Configuration
public class MvcConfig implements WebMvcConfigurer {
@Resource
private StringRedisTemplate stringRedisTemplate;

@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(new LoginInterceptor())
            .excludePathPatterns(
                    "/user/code"
                    , "/user/login"
                    , "/blog/hot"
                    , "/shop/**"
                    , "/shop-type/**"
                    , "/upload/**"
                    , "/voucher/**"
            ).order(1);
    registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
}
}	

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        String key = RedisConstants.CACHE_SHOP_KEY +id;
        //1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
            //3.存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson,Shop.class);
            return Result.ok(shop);
        }
        //4.不存在，根据id查询数据库
        Shop shop = getById(id);
        //5.数据库不存在，返回错误
        if(shop==null){
            return Result.fail("店铺不存在");
        }
        //6.存在，将查询结果写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop));

        //7.返回数据
        return Result.ok(shop);
    }
}

@Service
public class ShopTypeServiceImpl extends ServiceImpl<ShopTypeMapper, ShopType> implements IShopTypeService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryTypeList() {
        String typeKey= RedisConstants.CACHE_TYPE_KEY;
        //1.从redis中查询
        Long typeListSize = stringRedisTemplate.opsForList().size(typeKey);
        //2.redis存在数据
        if (typeListSize!=null&&typeListSize!=0){
            List<String> typeJsonList = stringRedisTemplate.opsForList().range(typeKey, 0, typeListSize-1);
            List<ShopType> typeList=new ArrayList<>();
            for (String typeJson : typeJsonList) {
                typeList.add(JSONUtil.toBean(typeJson,ShopType.class));
            }
            return Result.ok(typeList);
        }
        //3.redis不存在数据 查询数据库
        List<ShopType> typeList = query().orderByAsc("sort").list();
        //4.数据库中不存在相关数据
        if (typeList==null){
            //数据库不存在数据
            return Result.fail("发生错误");
        }
        //转换
        List<String> typeJsonList=new ArrayList<>();
        for (ShopType shopType : typeList) {
            typeJsonList.add(JSONUtil.toJsonStr(shopType));
        }
        //5.数据库存在数据 写入redis
        stringRedisTemplate.opsForList().rightPushAll(typeKey,typeJsonList);
        //6.返回数据
        return Result.ok(typeList);
    }
}

@Override
@Transactional
public Result update(Shop shop) {
    Long id = shop.getId();
    if(id==null){
        return Result.fail("店铺id不能为空");
    }
    //1.更新数据库
    updateById(shop);
    //2.删除缓存
    stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY+shop.getId());
    return Result.ok();
} 

public Shop queryWithPassThrough(Long id){
    String key = RedisConstants.CACHE_SHOP_KEY +id;
    //1.从redis查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    //2.判断是否存在
    if(StrUtil.isNotBlank(shopJson)){
        //3.存在，直接返回
        Shop shop = JSONUtil.toBean(shopJson,Shop.class);
        return Result.ok(shop);
    }
    //判断是否为空值，如果是“”，就不用返回数据库的查询了，如果是null,就需要进行数据库的查询（因为数据库没有查到会默认传一个“”，省略了查数据库的这一步）
    if(shopJson != null){
        return Result.fail("店铺信息不存在！");
    }

    //4.不存在，根据id查询数据库
    Shop shop = getById(id);
    //5.数据库不存在，返回错误
    if(shop==null){
        //将空值写入redis
        stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
        return Result.fail("店铺不存在");
    }
    //6.存在，将查询结果写入redis
    stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);

    //7.返回数据
    return Result.ok(shop);
}

@Override
public Result queryById(Long id) {
    //缓存穿透
    Shop shop = queryWithPassThrough(id);
    if(shop == null){
        return Result.fail("店铺查询失败");
    }
    //返回数据
    return Result.ok(shop);
}

//封装缓存穿透的代码——基于锁机制
public Shop queryWithPassThrough(Long id) {
    String key = RedisConstants.CACHE_SHOP_KEY +id;
    //1.从redis查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    //2.判断是否存在，isNotBlank方法会剔除掉null,""的情况
    if(StrUtil.isNotBlank(shopJson)){
        //3.存在，直接返回
        return JSONUtil.toBean(shopJson,Shop.class);
    }
    //4.实现缓存重建
    //4.1 获取互斥锁
    String lockKey = RedisConstants.LOCK_SHOP_KEY+id;
    Shop shop = null;
    try {
        boolean isLock = tryLock(lockKey);
        //4.2 判断是否获取成功
        if(!isLock){
            //4.3 获取失败，休眠
            Thread.sleep(50);
            return queryWithPassThrough(id);  //递归处理
        }
        //4.4 成功，进行数据库的查询和缓存重建
        shop = getById(id);
        //模拟重建的超时
        Thread.sleep(200);

        //5.数据库不存在，返回错误
        if(shop==null){
            //将空值写入redis
            stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
            return null;
        }
        //6.存在，将查询结果写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }finally {
        //7.释放互斥锁
        unlock(lockKey);
    }

    //8.返回数据
    return shop;
}

//获取锁
private boolean tryLock(String key){
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key,"1",RedisConstants.LOCK_SHOP_TTL,TimeUnit.SECONDS);
    //如果flag的值为null，自动进行拆箱将包装类转换为基本数据类型时会抛出NullPointerException
    return BooleanUtil.isTrue(flag);
}
//删除锁
private boolean unlock(String key){
    return stringRedisTemplate.delete(key);
}

private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

//封装缓存穿透的代码——基于逻辑过期
public Shop queryWithLogicalExpire(Long id) {
    String key = RedisConstants.CACHE_SHOP_KEY +id;
    //1.从redis查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    //2.判断是否存在
    if(StrUtil.isBlank(shopJson)){
        //3.不存在，直接返回null
        return null;
    }
    //4.命中，需要把这个json对象反序列化
    RedisData redisDate = JSONUtil.toBean(shopJson, RedisData.class);
    Shop shop = JSONUtil.toBean((JSONObject) redisDate.getData();, Shop.class);
    LocalDateTime expireTime = redisDate.getExpireTime();

    //5，判断是否过期
    if (expireTime.isAfter(LocalDateTime.now())) {
        //5.1 未过期，直接返回店铺信息
        return shop;
    }
    //5.2 已过期，需要缓存重建
    //6.缓存重建
    //6.1 获取互斥锁
    String localKey = RedisConstants.LOCK_SHOP_KEY + id;
    boolean isLock = tryLock(localKey);
    //6.2 判断是否获取锁成功
    if(isLock){
        //6.3 成功，开启独立线程，实现缓存重建
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            try {
                //重建缓存
                this.saveShopToRedis(id,20L);
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                //释放锁
                unlock(localKey);
            }
        });
    }
    //6.4 返回过期的商铺信息
    return shop;
}

public void saveShopToRedis(Long id,Long expireSeconds){
    //1.查询店铺数据
    Shop shop = getById(id);
    Thread.sleep(200);
    //2.封装逻辑过期时间
    RedisData redisData = new RedisData();
    redisData.setData(shop);
    redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
    //3.写入Redis
    stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(redisData));
}

@Slf4j
@Component
public class CacheClient {
    private final StringRedisTemplate stringRedisTemplate;

    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    public void set(String key, Object value, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
    }

    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit){
        RedisData redisData = new RedisData();
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        redisData.setData(value);
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    public <R,ID> R queryWithPassThrough(
            String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback, Long time, TimeUnit unit){
        String key = keyPrefix +id;
        //1.从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        //2.判断是否存在
        if(StrUtil.isNotBlank(json)){
            //3.存在，直接返回
            return JSONUtil.toBean(json,type);
        }
        //判断是否为空值，如果是“”，就不用返回数据库的查询了，如果是null,就需要进行数据库的查询（因为数据库没有查到会默认传一个“”，省略了查数据库的这一步）
        if(json != null){
            return null;
        }

        //4.不存在，根据id查询数据库
        R r =  dbFallback.apply(id);
        //5.数据库不存在，返回错误
        if(r==null){
            //将空值写入redis
            stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
            return null;
        }
        //6.存在，将查询结果写入redis
        this.stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(r),time,unit);

        //7.返回数据
        return r;
    }

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    //封装缓存穿透的代码——基于逻辑过期
    public <R,ID> R queryWithLogicalExpire(
            String prefix, ID id, Class<R> type, Function<ID,R> dbFallback, Long time, TimeUnit unit) {
        String key = prefix +id;
        //1.从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        //2.判断是否存在
        if(StrUtil.isBlank(json)){
            //3.不存在，直接返回null
            return null;
        }
        //4.命中，需要把这个json对象反序列化
        RedisData redisDate = JSONUtil.toBean(json, RedisData.class);
        R r = JSONUtil.toBean((JSONObject) redisDate.getData(), type);
        LocalDateTime expireTime = redisDate.getExpireTime();

        //5，判断是否过期
        if (expireTime.isAfter(LocalDateTime.now())) {
            //5.1 未过期，直接返回店铺信息
            return r;
        }
        //5.2 已过期，需要缓存重建
        //6.缓存重建
        //6.1 获取互斥锁
        String localKey = RedisConstants.LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(localKey);
        //6.2 判断是否获取锁成功
        if(isLock){
            //6.3 成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    //查询数据库
                    R r1 = dbFallback.apply(id);
                    //写入redis
                    this.setWithLogicalExpire(key,r1,time,unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    //释放锁
                    unlock(localKey);
                }
            });
        }
        //6.4 返回过期的商铺信息
        return r;
    }

    //获取锁
    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key,"1",RedisConstants.LOCK_SHOP_TTL,TimeUnit.SECONDS);
        //如果flag的值为null，自动进行拆箱将包装类转换为基本数据类型时会抛出NullPointerException
        return BooleanUtil.isTrue(flag);
    }
    //删除锁
    private boolean unlock(String key){
        return stringRedisTemplate.delete(key);
    }
}

//缓存穿透
        //Shop shop = cacheClient.
        //queryWithPassThrough(RedisConstants.CACHE_SHOP_KEY,id,Shop.class,this::getById, RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);

        //逻辑过期解决缓存击穿
        Shop shop = cacheClient.
                queryWithLogicalExpire(RedisConstants.CACHE_SHOP_KEY,id,Shop.class,this::getById,20L,TimeUnit.SECONDS);

private static final long BEGIN_TIMESTAMP = 1735689600;
//序列号位数
private static final int COUNT_BITS = 32;

@Resource
private StringRedisTemplate stringRedisTemplate;

public long nextId(String keyPrefix){

    //1.生成时间戳,当前时间-初始时间
    LocalDateTime now = LocalDateTime.now();
    long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
    long timeStamp = nowSecond-BEGIN_TIMESTAMP;

    //2.生成序列号,为了防止序列号进行超标，所以引入了时间key
    String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
    Long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);

    //3.借助位运算拼接并返回
    return timeStamp << COUNT_BITS | count;
}

@Test
void testIdWorker() throws InterruptedException {

    // CountDownLatch：并发控制工具，这里初始计数为 300（对应 300 个并发任务）
    CountDownLatch latch = new CountDownLatch(300);

    // 定义一个并发任务 Runnable
    Runnable task = () -> {
        // 每个线程循环生成 100 个 ID
        for(int i=0;i<100;i++){
            // 调用 RedisIdWorker 生成分布式唯一 ID，"order" 是业务前缀
            long id = redisIdWorker.nextId("order");
            // 打印生成的 ID，方便观察是否有重复
            System.out.println("id = "+id);
        }
        //把 CountDownLatch 的计数器减 1
        latch.countDown();
    };

    // 记录开始时间，用于统计生成 ID 的耗时
    long begin = System.currentTimeMillis();

    // 向线程池提交 300 个并发任务
    for(int i=0;i<300;i++){
        executorService.execute(task);
    }
    // 主线程阻塞，等待所有任务执行完成
    latch.await();
    // 记录结束时间
    long end = System.currentTimeMillis();

    // 输出从提交任务到当前时刻的耗时
    System.out.println("time:"+(end-begin));
}

@Override
@Transactional
public void addSeckillVoucher(Voucher voucher) {
    // 保存优惠券
    save(voucher);
    // 保存秒杀信息
    SeckillVoucher seckillVoucher = new SeckillVoucher();
    seckillVoucher.setVoucherId(voucher.getId());
    seckillVoucher.setStock(voucher.getStock());
    seckillVoucher.setBeginTime(voucher.getBeginTime());
    seckillVoucher.setEndTime(voucher.getEndTime());
    seckillVoucherService.save(seckillVoucher);
}

{
  "shopId": 1,
  "title": "100元代金券",
  "subTitle": "新用户专享",
  "rules": "仅限堂食使用，不可叠加其他优惠",
  "payValue": 7000,
  "actualValue": 10000,
  "type": 1,
  "stock": 100,
  "beginTime": "2025-01-01T10:00:00",
  "endTime": "2030-01-07T23:59:59"
}

@Resource
private ISeckillVoucherService seckillVoucherService;

@Resource
private RedisIdWorker redisIdWorker;

@Override
@Transactional
public Result seckillVoucher(Long voucherId) {
    //1.查询优惠券
    SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
    //2.判断秒杀是否开始
    if(voucher.getBeginTime().isAfter(LocalDateTime.now())){
        //尚未开始
        return Result.fail("秒杀尚未开始");
    }
    //3.判断秒杀是否已经结束
    if(voucher.getEndTime().isBefore(LocalDateTime.now())){
        //已经结束
        return Result.fail("秒杀已经结束");
    }
    //4.判断库存是否充足
    if(voucher.getStock() < 1){
        //库存不足
        return Result.fail("库存不足！");
    }
    //5.扣减库存
    boolean success = seckillVoucherService.update()
            .setSql("stock = stock - 1")
            .eq("voucher_id", voucherId).update();
    if(!success){
        return Result.fail("库存不足！");
    }
    //6.创建订单
    VoucherOrder voucherOrder = new VoucherOrder();
    //6.1生成全局唯一的订单Id
    Long orderId = redisIdWorker.nextId("order");
    voucherOrder.setId(orderId);
    //6.2设置当前线程内的用户id
    voucherOrder.setUserId(UserHolder.getUser().getId());
    //6.3设置代金券id
    voucherOrder.setVoucherId(voucherId);
    //6.4保存到数据库
    save(voucherOrder);

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