seckill

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    //对redis进行相应的配置,使得redis存储时可以直观显示
    //key序列化
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    //value序列化
    redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    //hash类型key序列化
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    //hash类型value序列化
    redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
    //注入连接工厂
    redisTemplate.setConnectionFactory(redisConnectionFactory);
    return  redisTemplate;
}

@Autowired
RedisTemplate redisTemplate;
。。。
。。。
//set操作
redisTemplate.opsForValue().set("user:" + ticket, sysUser, 60 * 60 * 12, TimeUnit.SECONDS);

 //每秒放行100个请求
    RateLimiter rateLimiter = RateLimiter.create(100);

    @PostMapping("/create")
    @Operation(summary = "用户下单")
    public TOrderRecord createWrongOrder(String dataid) throws Exception {
        //非阻塞式获取令牌：请求进来后，若令牌桶里没有足够的令牌，会尝试等待设置好的时间（这里写了1000ms），其会自动判断在1000ms后，
        //这个请求能不能拿到令牌，如果不能拿到，直接返回抢购失败。如果timeout设置为0，则等于阻塞时获取令牌。
        if (!rateLimiter.tryAcquire(1000, TimeUnit.MILLISECONDS))
            throw new RuntimeException("抢购失败，限流");
        TOrderRecord tOrderRecord = tOrderRecordService.createOrder(dataid);
        return tOrderRecord;
    }

 // 盐+用户id+商品id生成hash进行第一次MD5加密，用于临时订单接口生成真正的校验码
String verify = CacheKey.SALT_KEY.getKey() + user.getUserId() + dataId;
String verifyHash = DigestUtils.md5DigestAsHex(verify.getBytes());

//第二次加密，用于真正下单支付时校验
String verify2 = CacheKey.SEC_SALT_KEY.getKey() + verifyHash;
String verifyHash2 = DigestUtils.md5DigestAsHex(verify2.getBytes());

// 将第二次加密后的存入redis
String hashKey = CacheKey.VERIFY_KEY.getKey() + "_" + user.getUserId() + "_" + dataId;
redisTemplate.opsForValue().set(hashKey, verifyHash2, 600, TimeUnit.SECONDS);

//返回第一次加密的verifyHash
return verifyHash;

//将临时VerifyHash再进行MD5加密生成真正的校验码作为订单号填入用于支付时校验
String verify = CacheKey.SEC_SALT_KEY.getKey() + params.getVerifyHash();
String verifyHash = DigestUtils.md5DigestAsHex(verify.getBytes());
order.setOrderId(verifyHash);

@Bean(name = "IpCountRedisTemplate")
RedisTemplate<String,Object> IpCountRedisTemplate(){
    RedisStandaloneConfiguration server = new RedisStandaloneConfiguration();
    server.setHostName("150.158.28.238"); // 指定地址
    server.setDatabase(x); // 指定数据库
    server.setPort(xxxx); //指定端口
    LettuceConnectionFactory factory = new LettuceConnectionFactory(server);
    factory.afterPropertiesSet(); //刷新配置

    RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(factory);
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setValueSerializer(new FastJsonRedisSerializer<>(Object.class));
    return redisTemplate;
}

//通过这种方式注入，因为之前已经有一个RedisTemplate类型的bean了，所以要byname注入
@Resource(name = "IpCountRedisTemplate")
RedisTemplate ipCountRedisTemplate;//专门用于统计IP访问次数的redis

/**
* 功能描述:
* ip访问接口次数加1
*
* @param request
* @return int
* @author yt
* @date 2022/1/17 18:40
*/
public int addIpCount(HttpServletRequest request) throws Exception {
    String ipAddress = IpUtil.getIpAddr(request);
    String limitKey = CacheKey.LIMIT_KEY.getKey() + "_" + ipAddress;
    String limitNum = (String) ipCountRedisTemplate.opsForValue().get(limitKey);
    int limit = -1;
    if (limitNum == null) {
        ipCountRedisTemplate.opsForValue().set(limitKey, "0", 600, TimeUnit.SECONDS);
    } else {
        limit = Integer.parseInt(limitNum) + 1;
        ipCountRedisTemplate.opsForValue().set(limitKey, String.valueOf(limit), 600, TimeUnit.SECONDS);
    }
    return limit;
}

/**
* 功能描述:
* 检查IP访问接口次数
*
* @param request
* @return void
* @author yt
* @date 2022/1/17 18:40
*/
public void CheckIpIsBanned(HttpServletRequest request) {
    String ipAddress = IpUtil.getIpAddr(request);
    String limitKey = CacheKey.LIMIT_KEY.getKey() + "_" + ipAddress;
    String limitNum = (String) ipCountRedisTemplate.opsForValue().get(limitKey);
    if(null == limitNum) return;
    if (Integer.parseInt(limitNum) >= ALLOW_COUNT)
        throw new RuntimeException("禁止频繁访问，请十分钟后再试");
}

 public static void checkPage(Map params) {
     if(null==params.get("pageNum"))
     params.put("pageNum",0);
     if(null==params.get("pageSize"))
     params.put("pageSize",10);
 }

public TGoods detail(String dataId) {
        QueryWrapper<TGoods> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("data_id",dataId);
        TGoods tGoods = tGoodsMapper.selectOne(queryWrapper);
        if(null==tGoods)
            throw new RuntimeException("商品不存在");
        //从头里或请求里拿到token得到用户信息
        String token  = TokenUtil.getRequestToken(request);
        //根据token获取用户信息
        if(null==token)
            throw new RuntimeException("token为空，请重新登录");
        SysUser sysUser = (SysUser) redisTemplate.opsForValue().get(token);
        //查询准入规则
        TGoodsRule tGoodsRule = tGoodsRuleService.detail(dataId);
        //新增申请记录
        TApplyRecord tApplyRecord = new TApplyRecord();
        tApplyRecord.setUserId(sysUser.getUserId());
        tApplyRecord.setUserName(sysUser.getName());
        tApplyRecord.setGoodsId(tGoods.getDataId());
        tApplyRecord.setGoodsName(tGoods.getGoodsName());
        tApplyRecord.setApplyTime(new Date());
        //根据用户查询是否有参与活动的资格
        try {
            sysUserService.checkUserQualify(sysUser,tGoodsRule);
        }catch (Exception e){
            //结果不通过
            tApplyRecord.setApplyResult(1);
            tApplyRecordService.insertRecord(tApplyRecord);
            throw e;
        }
        //结果通过
        tApplyRecord.setApplyResult(0);
        tApplyRecordService.insertRecord(tApplyRecord);
        return tGoods;
    }