秒杀项目练习2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Override
    public ResponseBean login(LoginVo loginVo) {
        String mobile = loginVo.getMobile();
        String password = loginVo.getPassword();
        // 判空
        if (!StringUtils.hasText(mobile) || !StringUtils.hasText(password)) {
            return ResponseBean.error(ResponseBeanEnum.LOGIN_ERROR);
        }
        // 手机号码格式
        if (!ValidatorUtil.isMobile(mobile)) {
            return ResponseBean.error(ResponseBeanEnum.MOBILE_ERROR);
        }
        // 查询数据库
        User user = userMapper.selectById(mobile);
        if (null == user) {// user not exist
            return ResponseBean.error(ResponseBeanEnum.MOBILE_NOT_EXIST);
        }
        // 校验密码, LoginVo这里拿到的密码是mid密码, 客户端已经第一次加盐了
        String salt2 = user.getSalt();
        String dbPass = MD5Util.midPassToDBPass(password, salt2);
        if (!dbPass.equals(user.getPassword())) {
            return ResponseBean.error(ResponseBeanEnum.LOGIN_ERROR);
        }
        return ResponseBean.success();
    }

1
2
3
4
5
@Data
public class LoginVo {
    private String mobile;
    private String password;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE})
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = {IsMobileValidator.class})
public @interface IsMobile {
    String message() default "手机号码格式错误";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

    boolean required() default true;
}

1
2
3
4
5
6
7
8
9
10
11
// 使用注解
@Data
public class LoginVo {
    @IsMobile(message = "你很伟大~")
    @NotNull
    private String mobile;

    @NotNull
    @Length(min = 32)
    private String password;
}

1
2
3
4
5
6
7
@RequestMapping("/doLogin")
@ResponseBody
// 必须加@Validated
public ResponseBean doLogin(@Validated LoginVo loginVo) {
  log.info("登录入参: loginVo={}", loginVo);
  return userService.login(loginVo);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 改进后的service
@Override
public ResponseBean login(LoginVo loginVo) {
  String mobile = loginVo.getMobile();
  String password = loginVo.getPassword();
  // 查询数据库
  User user = userMapper.selectById(mobile);
  if (null == user) {// user not exist
    throw new GlobalException(ResponseBeanEnum.MOBILE_NOT_EXIST);
  }
  // 校验密码, LoginVo这里拿到的密码是mid密码, 客户端已经第一次加盐了
  String salt2 = user.getSalt();
  String dbPass = MD5Util.midPassToDBPass(password, salt2);
  if (!dbPass.equals(user.getPassword())) {
    throw new GlobalException(ResponseBeanEnum.LOGIN_ERROR);
  }
  return ResponseBean.success();
}

1
2
3
4
5
6
7
// 全局异常类
@Data
@AllArgsConstructor
public class GlobalException extends RuntimeException{
    private ResponseBeanEnum responseBeanEnum;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 全局异常处理类
@RestControllerAdvice
public class GlobalExceptionHandler {
    // 处理所有的异常
    @ExceptionHandler(Exception.class)
    public ResponseBean ExceptionHandler(Exception e) {
        // 如果是全局异常，正常处理
        if (e instanceof GlobalException) {
            GlobalException ex = (GlobalException) e;
            return ResponseBean.error(ex.getResponseBeanEnum());
        } else if (e instanceof BindException) {
            // 如果是绑定异常 :由于我们自定义的注解只会在控制台打印错误信息，想让该信息传给前端。
            // 需要获取改异常 BindException中注解定义消息，返回给前端
            BindException ex = (BindException) e;
            ResponseBean respBean = ResponseBean.error(ResponseBeanEnum.BING_ERROR);
            // respBean.setMessage("参数校验异异常");
            String defaultMessage = ex.getBindingResult().getAllErrors().get(0).getDefaultMessage();
            respBean.setMessage(defaultMessage);
            return respBean;
        }
        // 兜底异常
        return ResponseBean.error(ResponseBeanEnum.ERROR);
    }
}

1
2
3
4
5
6
7
// 用户登录成功
// 给每一个用户生成一个ticket-唯一的标识一个用户
String ticket = UUIDUtil.uuid();
// 将用户登录信息保存到session中
request.getSession().setAttribute(ticket, user);
// 设置cookie
CookieUtil.setCookie(request, response, "userTicket", ticket);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 商品页面会对登录进行校验
@RequestMapping("/toList")
public String toList(HttpSession session, Model model,
                     @CookieValue(value = "userTicket", required = false) String userTicket) {
  User user = (org.xxx.seckill.pojo.User) session.getAttribute(userTicket);
  if (!StringUtils.hasText(userTicket)) {
    return "login";
  }
  if (null == user) { // 用户没有成功登录,或者userTicket不正确
    return "login";
  }
  // 将用户信息放入到model中, 给模板使用
  model.addAttribute("user", user);
  return "goodsList";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 设置相应 key 的序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // value 序列化
        // redis 默认是 jdk 的序列化是二进制,这里使用的是通用的 json 数据,不用传具体的序列化的对象
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // 设置相应的 hash 序列化
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer()); // 注入连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }

1
2
3
4
5
6
7
8
// 用户登录成功
// 给每一个用户生成一个ticket-唯一的标识一个用户
String ticket = UUIDUtil.uuid();
// 将用户登录信息保存到session中
// request.getSession().setAttribute(ticket, user);
redisTemplate.opsForValue().set("user:" + ticket, user);
CookieUtil.setCookie(request, response, "userTicket", ticket);
return ResponseBean.success();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 根据cookie从redis中获取用户
 * @param userTicket 登录后给用户分配标志
 * @return user
 */
@Override
public User getUserByCookie(String userTicket,HttpServletRequest request, HttpServletResponse response) {
  if (!StringUtils.hasText(userTicket)) {
    return null;
  }
  User user = (User) redisTemplate.opsForValue().get("user:" + userTicket);
  if (user != null) {
    // 如果user不为null, 刷新cookie的存活时间
    CookieUtil.setCookie(request, response, "userTicket", userTicket);
  }
  return user;
}

1
 User user = userService.getUserByCookie(userTicket, request, response);

1
2
3
@RequestMapping("/toList")
public String toList(HttpSession session, Model model, HttpServletRequest request, HttpServletResponse response,
                     @CookieValue(value = "userTicket", required = false) String userTicket) {}

1
2
@RequestMapping("/toList")
public String toList(Model model, User user) 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@Component
public class UserArgumentResolver implements HandlerMethodArgumentResolver {
    @Autowired
    private UserService userService;

    //如果这个方法返回 true 才会执行下面的 resolveArgument 方法
    // 返回 false 不执行下面的方法
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        Class<?> parameterType = parameter.getParameterType();
        return User.class == parameterType;
    }

    // * 这个方法，类似拦截器，将传入的参数，取出 cookie 值，然后获取对应的 User 对象
    // * 并把这个 User 对象作为参数继续传递.
    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
        HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
        String userTicket = CookieUtil.getCookieValue(request, "userTicket");
        if (!StringUtils.hasText(userTicket)) {
            return null;
        }
        //根据 cookie-ticket 到 Redis 获取 User
        User user = userService.getUserByCookie(userTicket, request, response);
        return user;
    }
}

1
2
3
4
5
6
7
8
9
10
11
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private UserArgumentResolver userArgumentResolver;
    // 自定义参数解析
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(userArgumentResolver);
    }
}

1
2
3
4
5
6
7
8
9
@RequestMapping("/toList")
public String toList(Model model, User user) {
    if (null == user) { // 用户没有成功登录,或者userTicket不正确
        return "login";
    }
    // 将用户信息放入到model中, 给模板使用
    model.addAttribute("user", user);
    return "goodsList";
}

1
2
3
4
5
6
7
8
9
@Data
@AllArgsConstructor
@NoArgsConstructor
public class GoodsVo extends Goods {
    private BigDecimal seckillPrice;
    private Integer stockCount;
    private Date startDate;
    private Date endDate;
}

1
2
3
4
5
6
7
8
9
10
11
12
// 商品详情页
@RequestMapping("/toDetail/{goodsId}")
public String toGoodsDetail(@PathVariable("goodsId") Long goodsId,
                            Model model, User user) {
    if (null == user) {
        return "login";
    }
    GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);
    model.addAttribute("goods", goodsVo);
    model.addAttribute("user", user);
    return "goodsDetail";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 商品详情页
@RequestMapping("/toDetail/{goodsId}")
public String toGoodsDetail(@PathVariable("goodsId") Long goodsId,
                            Model model, User user) {
    if (null == user) {
        return "login";
    }
    GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);
    
    Date startTime = goodsVo.getStartDate();
    Date endTime = goodsVo.getEndDate();
    Date now = new Date();
    // 秒杀状态 0: 未开始, 1:进行中 2:结束
    Integer status = 0;
    // 还剩多久秒杀开始
    Long remainSeconds = 0L;
    if (now.before(startTime)) {
        status = 0;
        remainSeconds = (startTime.getTime() - now.getTime()) / 1000;
    } else if (now.after(startTime) && now.before(endTime)) {
        remainSeconds = 0L;
        status = 1;
    } else if (now.after(endTime)) {
        status = 2;
        remainSeconds = -1L;
    }
    model.addAttribute("secKillStatus", status);
    model.addAttribute("remainSeconds", remainSeconds);
    model.addAttribute("goods", goodsVo);
    model.addAttribute("user", user);
    return "goodsDetail";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 需要考虑事务, 高并发
@Override
public Order seckill(User user, GoodsVo goodsVo) {
    Assert.notNull(user, "用户没有登录");
    Long userId = user.getId();
    Assert.notNull(goodsVo, "秒杀商品goods不能为空");
    // 查询秒杀商品的库存-扣减库存
    SeckillGoods seckillGoods = new LambdaQueryChainWrapper<>(seckillGoodsMapper)
            .eq(SeckillGoods::getGoodsId, goodsVo.getId()).one();
    seckillGoods.setStockCount(seckillGoods.getStockCount() - 1);
    int update = seckillGoodsMapper.updateById(seckillGoods);
    // 生成普通订单
    Order order = new Order();
    order.setUserId(userId);
    order.setGoodsId(goodsVo.getId());
    order.setDeliveryAddrId(0L); // 设置一个默认值
    order.setGoodsName(goodsVo.getGoodsName());
    order.setGoodsCount(1);
    order.setGoodsPrice(seckillGoods.getSeckillPrice());
    order.setOrderChannel((byte) 1);
    order.setStatus((byte) 0);
    order.setCreateDate(new Date());
    this.save(order);
    // 生成秒杀商品订单
    SeckillOrder seckillOrder = new SeckillOrder();
    seckillOrder.setOrderId(order.getId());
    seckillOrder.setUserId(userId);
    seckillOrder.setGoodsId(goodsVo.getId());
    seckillOrderMapper.insert(seckillOrder);
    // 返回order用来回显订单信息
    return order;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 处理用户抢购请求
@RequestMapping("/doSeckill")
public String doSeckill(User user, Model model, Long goodsId) {
    if (null == user) {
        return "login";
    }
    GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);
    // 判断是否有库存
    if (goodsVo.getStockCount() < 1) {// 无库存
        model.addAttribute("errmsg", ResponseBeanEnum.INSUFFICIENT_INVENTORY.getMessage());
        return "secKillFail";
    }
    // 判断用户是否重复购买
    SeckillOrder seckillOrder = seckillOrderService.getOne(
            new LambdaQueryWrapper<SeckillOrder>()
                    .eq(SeckillOrder::getGoodsId, goodsId)
                    .eq(SeckillOrder::getUserId, user.getId())
    );
    if (null != seckillOrder) {
        model.addAttribute("errmsg", ResponseBeanEnum.LIMIT_BUY_ONE);
        return "secKillFail";
    }
    // 生成订单
    Order order = orderService.seckill(user, goodsVo);
    if (null == order) {
        model.addAttribute("errmsg", "秒杀失败, 其他原因");
        return "secKillFail";
    }
    // 秒杀成功进入订单页面
    model.addAttribute("order", order);
    return "orderDetail";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
/**
 * @author zangxin
 * @version 1.0
 * @date 2025/4/11
 * 生成用户工具类
 * 创建用户，并且去登录得到 userticket，
 * 得到的 userTicket 写入到 config.txt 文件内
 */
public class UserUtil {
    public static void create(int count) throws Exception {
        List<User> users = new ArrayList<>(count);
        for (int i = 0; i < count; i++) {
            // 用户数据表的 slat,由程序员设置
            //?是用户原始密码,比如 12345 , hello 等
            User user = new User();
            user.setId(13300000100L + i);
            user.setNickname("user" + i);
            user.setSalt("P5XT7DiE");
            user.setPassword(MD5Util.inputPassToDBPass("12345", user.getSalt()));
            users.add(user);
        }
        System.out.println("create user");
        // 插入数据库
        Connection connection = getConn();
        String sql = "insert into seckill_user(nickname,salt,password,id) values(?,?,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        for (int i = 0; i < users.size(); i++) {
            User user = users.get(i);
            preparedStatement.setString(1, user.getNickname());
            preparedStatement.setString(2, user.getSalt());
            preparedStatement.setString(3, user.getPassword());
            preparedStatement.setLong(4, user.getId());
            preparedStatement.addBatch();
        }
        preparedStatement.executeBatch();
        // 关闭 connection.close();
        preparedStatement.clearParameters();
        System.out.println("insert to do");
        // 登录拿到 userTicket
        String urlStr = "http://localhost:80/login/doLogin";
        File file = new File("/Users/qingsongcai/devtools/apache-jmeter-5.6.3/jmeter_data_zangxin/config.txt");
        if (file.exists()) {
            file.delete();
        }
        RandomAccessFile raf = new RandomAccessFile(file, "rw");
        raf.seek(0);
        for (int i = 0; i < users.size(); i++) {
            User user = users.get(i);
            // 请求
            URL url = new URL(urlStr);
            HttpURLConnection co = (HttpURLConnection) url.openConnection();
            co.setRequestMethod("POST");
            // 设置输入网页密码(相当于输出到页面)
            co.setDoOutput(true);
            OutputStream outputStream = co.getOutputStream();
            String params = "mobile=" + user.getId() + "&password=" +
                    MD5Util.inputPassToMidPass("12345");
            outputStream.write(params.getBytes());
            outputStream.flush();
            // 获取网页输出 ，( 得 到 输 入 流 ， 把 结 果 得 到 ， 再 输 出 到 ByteArrayOutputStream 内)
            InputStream inputStream = co.getInputStream();
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            byte[] bytes = new byte[1024];
            int len = 0;
            while ((len = inputStream.read(bytes)) >= 0) {
                bout.write(bytes, 0, len);
            }
            inputStream.close();
            bout.close();
            // 把 ByteArrayOutputStream 内的东西转换为 respBean 对象
            String response = new String(bout.toByteArray());
            ObjectMapper mapper = new ObjectMapper();
            ResponseBean respBean = mapper.readValue(response, ResponseBean.class);
            // 得到 userTicket, 需要在/login/doLogin返回数据中设置userTicket
            String userTicket = (String) respBean.getObj();
            System.out.println("create userTicket" + userTicket);
            String row = user.getId() + "," + userTicket;
            // 写入指定文件
            raf.seek(raf.length());
            raf.write(row.getBytes());
            raf.write("\r\n".getBytes());
            System.out.println("write to file:" + user.getId());
        }
        raf.close();
        System.out.println("over");
    }

    private static Connection getConn() throws Exception {
        String url = "jdbc:mysql://localhost:3306/seckill?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai";
        String username = "root";
        String password = "root";
        String driver = "com.mysql.cj.jdbc.Driver";
        Class.forName(driver);
        return DriverManager.getConnection(url, username, password);
    }

    public static void main(String[] args) throws Exception {
        create(2000);
    }
}

1
2
3
4
5
6
7
8
13300000100,2067c2b47ce940a79c7d2b813d41d2e1
13300000101,b2c11ecb06ad4687adcde69eb7adc08e
13300000102,145b5a2c18fb4de3b0bd95c2de7ae08f
13300000103,1b1886f43c24436294b39f6c1befc59c
13300000104,71b31979ca084df2bf29de245d273461
13300000105,58ee08f2cccf43cb8965226cd8e358ce
13300000106,418b46741c7b47ab8b43545c342020c9
...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 手动渲染模板要使用
@Autowired
private ThymeleafViewResolver thymeleafViewResolver;

// 使用了 redis 缓存页面优化
@RequestMapping(value = "/toList", produces = "text/html;charset=utf-8")
@ResponseBody
public String toList_v2(Model model, User user, HttpServletRequest request, HttpServletResponse response) {
  // 先从redis中拿,没有再从db中拿
  String html = (String) redisTemplate.opsForValue().get("goodsList");
  if (StringUtils.hasText(html)) {
    return html;
  }

  if (null == user) { // 用户没有成功登录,或者userTicket不正确
    return "login";
  }
  // 将用户信息放入到model中, 给模板使用
  model.addAttribute("user", user);
  // 从DB中拿数据
  List<GoodsVo> goodsVoList = goodsService.findGoodsVo();
  model.addAttribute("goodsList", goodsVoList);
  // 手动渲染Template模板
  WebContext webContext = new WebContext(request, response, request.getServletContext(), request.getLocale(), model.asMap());
  html = thymeleafViewResolver.getTemplateEngine().process("goodsList", webContext);
  if (StringUtils.hasText(html)) {
    // 每 60s 更新一次redis页面缓存, 即60s后, 该页面缓存失效, Redis 会清除该缓存
    redisTemplate.opsForValue().set("goodsList", html, 60, TimeUnit.SECONDS);
  }
  return html;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// 商品详情页-redis缓存优化
@RequestMapping(value = "/toDetail/{goodsId}", produces = "text/html;charset=utf-8")
@ResponseBody
public String toGoodsDetail_v2(@PathVariable("goodsId") Long goodsId,
       HttpServletRequest request, HttpServletResponse response,
       Model model, User user) {
    // 先从redis中拿,没有再从db中拿
    String html = (String) redisTemplate.opsForValue().get("goodsDetail:" + goodsId);
    if (StringUtils.hasText(html)) {
        return html;
    }
    if (null == user) {
        return "login";
    }
    GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);

    Date startTime = goodsVo.getStartDate();
    Date endTime = goodsVo.getEndDate();
    Date now = new Date();
    // 秒杀状态 0: 未开始, 1:进行中 2:结束
    Integer status = 0;
    // 还剩多久秒杀开始
    Long remainSeconds = 0L;
    if (now.before(startTime)) {
        status = 0;
        remainSeconds = (startTime.getTime() - now.getTime()) / 1000;
    } else if (now.after(startTime) && now.before(endTime)) {
        remainSeconds = 0L;
        status = 1;
    } else if (now.after(endTime)) {
        status = 2;
        remainSeconds = -1L;
    }
    model.addAttribute("secKillStatus", status);
    model.addAttribute("remainSeconds", remainSeconds);
    model.addAttribute("goods", goodsVo);
    model.addAttribute("user", user);

    // 手动渲染Template模板
    WebContext webContext = new WebContext(request, response, request.getServletContext(), request.getLocale(), model.asMap());
    html = thymeleafViewResolver.getTemplateEngine().process("goodsDetail", webContext);
    if (StringUtils.hasText(html)) {
        // 每 60s 更新一次redis页面缓存, 即60s后, 该页面缓存失效, Redis 会清除该缓存
        redisTemplate.opsForValue().set("goodsDetail:" + goodsId, html, 60, TimeUnit.SECONDS);
    }
    return html;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    // 更新密码
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseBean updatePassword(User user, String password, HttpServletRequest request,
                                       HttpServletResponse response) {
        User userDb = userMapper.selectById(user.getId());
        // 修改密码
        String dbPass = MD5Util.inputPassToDBPass(password, userDb.getSalt());
        userDb.setPassword(dbPass);
        int update = userMapper.updateById(userDb);
        if (update > 0) {
            // 先拿到redis中userTicket作为redis的key,再删除redis中的缓存, 让用户下次重新登录
            String userTicket = CookieUtil.getCookieValue(request, "userTicket");
            redisTemplate.delete("user:" + userTicket);
            return ResponseBean.success();
        }
        return ResponseBean.error(ResponseBeanEnum.UPDATE_PASSWORD_ERROR);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 *
 * @param user
 * @param newPassword 为了简单,直接调用的api接口, 密码不是前端加密过一次的, 而是明文
 * @param request
 * @param response
 * @return
 */
// http://127.0.0.1/user/updatePassword?newPassword=1234
@RequestMapping("/updatePassword")
@ResponseBody
public ResponseBean updatePassword(User user, String newPassword, HttpServletRequest request, HttpServletResponse response) {
    return userService.updatePassword(user, newPassword, request, response);
}

1
2
3
4
// 查询秒杀商品的库存-扣减库存
SeckillGoods seckillGoods = seckillGoodsMapper.selectById(goodsVo.getId());
seckillGoods.setStockCount(seckillGoods.getStockCount() - 1);
int update = seckillGoodsMapper.updateById(seckillGoods);

1
2
3
4
5
6
7
8
9
10
11
12
// 优化版本的扣减库存
// mysql在默认的事务隔离级别(可重复读),update语句会在事务中锁定要更新的行 (row lock)
// 带where条件是行锁, 不带where条件是表锁(性能大幅度降低)
// 防止奇台会话在同一行执行update或者delete操作
//sql: update t_seckill_goods set stock_count = stock_count - 1 where goods_id = ? and stock_count > 0
int update = seckillGoodsMapper.update(null, new UpdateWrapper<SeckillGoods>()
        .setSql("stock_count = stock_count - 1")
        .eq("goods_id", goodsVo.getId())
        .gt("stock_count", 0));
if (!(update > 0)) { // 库存不足
    throw new GlobalException(ResponseBeanEnum.INSUFFICIENT_INVENTORY);
}

1
2
// 将生成秒杀的订单放入的redis中, 提高复购判断时的查询效率 key=order:userId:googsId
redisTemplate.opsForValue().set("order:" + userId + ":" + goodsVo.getId(), order);

1
2
3
4
5
6
SeckillOrder seckillOrder = (SeckillOrder) redisTemplate.opsForValue()
  .get("order:" + user.getId() + ":" + goodsVo.getId());
if (null != seckillOrder) {
  model.addAttribute("errmsg", ResponseBeanEnum.LIMIT_BUY_ONE.getMessage());
  return "secKillFail";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// 需要考虑事务, 高并发
@Override
@Transactional(rollbackFor = Exception.class)
public Order seckill(User user, GoodsVo goodsVo) {
    Assert.notNull(user, "用户没有登录");
    Long userId = user.getId();
    Assert.notNull(goodsVo, "秒杀商品goods不能为空");
    // 查询秒杀商品的库存-扣减库存
    // 优化版本的扣减库存-v2.0
    // mysql在默认的事务隔离级别(可重复读),update语句会在事务中锁定要更新的行 (row lock)
    // 防止奇台会话在同一行执行update或者delete操作
    // update t_seckill_goods set stock_count = stock_count - 1 where goods_id = ? and stock_count > 0
    int update = seckillGoodsMapper.update(null, new UpdateWrapper<SeckillGoods>()
            .setSql("stock_count = stock_count - 1")
            .eq("goods_id", goodsVo.getId())
            .gt("stock_count", 0));
    if (!(update > 0)) { // 库存不足
        throw new GlobalException(ResponseBeanEnum.INSUFFICIENT_INVENTORY);
    }
    // 生成普通订单
    Order order = new Order();
    order.setUserId(userId);
    order.setGoodsId(goodsVo.getId());
    order.setDeliveryAddrId(0L); // 设置一个默认值
    order.setGoodsName(goodsVo.getGoodsName());
    order.setGoodsCount(1);
    order.setGoodsPrice(goodsVo.getSeckillPrice());
    order.setOrderChannel((byte) 1);
    order.setStatus((byte) 0);
    order.setCreateDate(new Date());
    this.save(order);
    // 生成秒杀商品订单
    SeckillOrder seckillOrder = new SeckillOrder();
    seckillOrder.setOrderId(order.getId());
    seckillOrder.setUserId(userId);
    seckillOrder.setGoodsId(goodsVo.getId());
    seckillOrderMapper.insert(seckillOrder);
    // 将生成秒杀的订单放入的redis中, 提高复购判断时的查询效率 key=order:userId:googsId
    redisTemplate.opsForValue().set("order:" + userId + ":" + goodsVo.getId(), seckillOrder);
    // 返回order用来回显订单信息
    return order;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 处理用户抢购请求
@RequestMapping("/doSeckill")
public String doSeckill(User user, Model model, Long goodsId) {
  if (null == user) {
    return "login";
  }
  GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);
  // 判断是否有库存
  if (goodsVo.getStockCount() < 1) {// 无库存
    model.addAttribute("errmsg", ResponseBeanEnum.INSUFFICIENT_INVENTORY.getMessage());
    return "secKillFail";
  }
  // 判断用户是否重复购买 redis中获取-v2.0
  SeckillOrder seckillOrder = (SeckillOrder) redisTemplate.opsForValue()
    .get("order:" + user.getId() + ":" + goodsVo.getId());
  if (null != seckillOrder) {
    model.addAttribute("errmsg", ResponseBeanEnum.LIMIT_BUY_ONE.getMessage());
    return "secKillFail";
  }
  // 生成订单
  Order order = orderService.seckill(user, goodsVo);
  if (null == order) {
    model.addAttribute("errmsg", "秒杀失败, 其他原因");
    return "secKillFail";
  }
  // 秒杀成功进入订单页面
  model.addAttribute("order", order);
  model.addAttribute("user", user);
  model.addAttribute("goods", goodsVo);
  return "orderDetail";
}

1
2
3
4
5
6
GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);
// 判断是否有库存
if (goodsVo.getStockCount() < 1) {// 无库存
  model.addAttribute("errmsg", ResponseBeanEnum.INSUFFICIENT_INVENTORY.getMessage());
  return "secKillFail";
}

1
2
3
4
5
6
7
8
9
10
// mysql在默认的事务隔离级别(可重复读),update语句会在事务中锁定要更新的行 (row lock)
// 防止奇台会话在同一行执行update或者delete操作
// update t_seckill_goods set stock_count = stock_count - 1 where goods_id = ? and stock_count > 0
int update = seckillGoodsMapper.update(null, new UpdateWrapper<SeckillGoods>()
                                       .setSql("stock_count = stock_count - 1")
                                       .eq("goods_id", goodsVo.getId())
                                       .gt("stock_count", 0));
if (!(update > 0)) { // 库存不足
  throw new GlobalException(ResponseBeanEnum.INSUFFICIENT_INVENTORY);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// init()方法,在属性初始化完成后调用, 在这里初始化库存(测试方便,不要到生产中使用,因为生成环境可能有多个buy服务集群)
@Override
public void afterPropertiesSet() throws Exception {
  // 查询所有秒杀商品
  List<GoodsVo> list = goodsService.findGoodsVo();
  // 变量商品,将上线活动的商品库存放入到redis
  if (CollectionUtils.isEmpty(list)) {
    return;
  }
  list.forEach(goodsVo -> {
    Long goodsId = goodsVo.getId();
    Integer stockCount = goodsVo.getStockCount();
    // 商品库存key=seckillGoods:goodsId, value=库存量
    redisTemplate.opsForValue().set("seckillGoods:" + goodsId, stockCount);
    // todo 需要搞个定时任务同步redis库存到数据库
  });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// 处理用户抢购请求 v3
@RequestMapping("/doSeckill")
public String doSeckill_v3(User user, Model model, Long goodsId) {
  if (null == user) {
    return "login";
  }
  GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);
  // 判断是否有库存
  // 既然取出了 goodsVo, 就判断一下 DB 是否还有库存, 但该方法 在大并发下, 不能确保不超卖(方法不具原子性)
  if (goodsVo.getStockCount() < 1) {
    model.addAttribute("errmsg", ResponseBeanEnum.INSUFFICIENT_INVENTORY.getMessage());
    return "secKillFail";
  }

  // 是否重复购买
  // 这个判断要在预减库存 前面, 否则如果一个用户购买成功 再次秒杀，就会预减 Redis 库存,
  // 就会造成了 Redis 库存少了，但是实际 DB 库存还有剩余, 出现秒杀商品剩余的问题
  SeckillOrder seckillOrder = (SeckillOrder) redisTemplate.opsForValue()
    .get("order:" + user.getId() + ":" + goodsVo.getId());
  if (null != seckillOrder) {
    model.addAttribute("errmsg", ResponseBeanEnum.LIMIT_BUY_ONE.getMessage());
    return "secKillFail";
  }

  // 库存预减,如果在redis没有库存了,直接返回,不往下走了,减少执行查询数据库[优化]
  Long decrement = redisTemplate.opsForValue().decrement("seckillGoods:" + goodsId);
  if (decrement < 0) { // 说明商品已经没有库存了
    // 恢复库存为0
    redisTemplate.opsForValue().set("seckillGoods:" + goodsId, 0);
    model.addAttribute("errmsg", ResponseBeanEnum.INSUFFICIENT_INVENTORY.getMessage());
    return "secKillFail";
  }

  // 生成订单
  Order order = orderService.seckill(user, goodsVo);
  if (null == order) {
    model.addAttribute("errmsg", "秒杀失败, 其他原因");
    return "secKillFail";
  }
  // 秒杀成功进入订单页面
  model.addAttribute("order", order);
  model.addAttribute("user", user);
  model.addAttribute("goods", goodsVo);
  return "orderDetail";
}

1
2
3
4
5
6
7
8
// 库存预减,如果在redis没有库存了,直接返回,不往下走了,减少执行查询数据库[优化]
Long decrement = redisTemplate.opsForValue().decrement("seckillGoods:" + goodsId);
if (decrement < 0) { // 说明商品已经没有库存了
  // 恢复库存为0
  redisTemplate.opsForValue().set("seckillGoods:" + goodsId, 0);
  model.addAttribute("errmsg", ResponseBeanEnum.INSUFFICIENT_INVENTORY.getMessage());
  return "secKillFail";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 存放商品库存状态, key=goodsId, value: true有库存, false无库存
private ConcurrentHashMap<Long, Boolean> goodsStausMap = new ConcurrentHashMap<>();

@Override
public void afterPropertiesSet() throws Exception {
  // 查询所有秒杀商品
  List<GoodsVo> list = goodsService.findGoodsVo();
  // 变量商品,将上线活动的商品库存放入到redis
  if (CollectionUtils.isEmpty(list)) {
    return;
  }
  list.forEach(goodsVo -> {
    Long goodsId = goodsVo.getId();
    Integer stockCount = goodsVo.getStockCount();
    // 商品库存key=seckillGoods:goodsId, value=库存量
    redisTemplate.opsForValue().set("seckillGoods:" + goodsId, stockCount);
    // 初始化库存状态
    goodsStausMap.put(goodsId, stockCount > 0);
    // todo 需要搞个定时任务同步redis库存到数据库
  });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// 处理用户抢购请求 v4 内存标记优化(v4)
@RequestMapping("/doSeckill")
public String doSeckill_v4(User user, Model model, Long goodsId) {
  if (null == user) {
    return "login";
  }
  GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);

  // 判断是否有库存
  if (goodsVo.getStockCount() < 1) {
    model.addAttribute("errmsg", ResponseBeanEnum.INSUFFICIENT_INVENTORY.getMessage());
    return "secKillFail";
  }

  // 是否重复购买 这个判断要在预减库存 前面,
  SeckillOrder seckillOrder = (SeckillOrder) redisTemplate.opsForValue()
    .get("order:" + user.getId() + ":" + goodsVo.getId());
  if (null != seckillOrder) {
    model.addAttribute("errmsg", ResponseBeanEnum.LIMIT_BUY_ONE.getMessage());
    return "secKillFail";
  }

  // 先在本地判断, 如果没有库存直接返回,不用走后面流程了
  if (goodsStausMap.get(goodsId) != null && !goodsStausMap.get(goodsId)) {
    model.addAttribute("errmsg", ResponseBeanEnum.INSUFFICIENT_INVENTORY.getMessage());
    return "secKillFail";
  }

  // 库存预减,如果在redis没有库存了,直接返回,不往下走了,减少执行查询数据库[优化]
  Long decrement = redisTemplate.opsForValue().decrement("seckillGoods:" + goodsId);
  if (decrement < 0) { // 说明商品已经没有库存了
    // 更新本地库存状态
    goodsStausMap.put(goodsId, false);
    // 恢复库存为0
    redisTemplate.opsForValue().set("seckillGoods:" + goodsId, 0);
    model.addAttribute("errmsg", ResponseBeanEnum.INSUFFICIENT_INVENTORY.getMessage());
    return "secKillFail";
  }

  // 生成订单
  Order order = orderService.seckill(user, goodsVo);
  if (null == order) {
    model.addAttribute("errmsg", "秒杀失败, 其他原因");
    return "secKillFail";
  }
  // 秒杀成功进入订单页面
  model.addAttribute("order", order);
  model.addAttribute("user", user);
  model.addAttribute("goods", goodsVo);

  return "orderDetail";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public class TestAuto {
    public static void main(String[] args) throws Exception {

        Connection connection = getConn();
        String sql1 = "delete from t_order where 1=1";
        String sql2 = "delete from t_seckill_order where 1=1";
        String sql3 = "update t_seckill_goods set stock_count = 10";
        PreparedStatement ps1 = connection.prepareStatement(sql1);
        ps1.executeUpdate();
        PreparedStatement ps2 = connection.prepareStatement(sql2);
        ps2.executeUpdate();
        PreparedStatement ps3 = connection.prepareStatement(sql3);
        ps3.executeUpdate();
        System.out.println("清理数据库完成");


        Jedis jedis = connectRedis();
        jedis.set("seckillGoods:1", "10");
        Set<String> keys = jedis.keys("order:*");
        if (!CollectionUtils.isEmpty(keys)) {
            jedis.del(keys.toArray(new String[0]));
        }

        System.out.println("清理redis完成");

        // 重置库存状态map
        // seckill/resetStockStatus
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
        HttpGet httpGet = new HttpGet("http://localhost/seckill/resetStockStatus");
        // 设置请求头：内容类型
        httpGet.setHeader("Content-Type", "application/json;charset=UTF-8");
        CloseableHttpResponse httpResponse = httpClientBuilder.build().execute(httpGet);
        System.out.println("重置库存状态map完成");
        // release
        ps1.close();
        ps2.close();
        ps3.close();
        jedis.close();
        httpResponse.close();
        System.out.println("现在可以在jmeter上压测了");
    }


    private static Jedis connectRedis() throws Exception {
        // 连接redis
        Jedis jedis = new Jedis("192.168.2.85", 6379);
        return jedis;
    }

    private static Connection getConn() throws Exception {
        String url = "jdbc:mysql://localhost:3306/seckill?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai";
        String username = "root";
        String password = "root";
        String driver = "com.mysql.cj.jdbc.Driver";
        Class.forName(driver);
        return DriverManager.getConnection(url, username, password);
    }
}

1
2
3
4
5
6
7
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SeckillMessage implements Serializable {
    private User user;
    private Long goodsId;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 秒杀rabbitmq
private static final String SECKILL_QUEUE = "seckillQueue";
private static final String SECKILL_EXCHANGE = "seckillExchange";
private static final String SECKILL_ROUTING_KEY = "seckill.#";

@Bean
public Queue queue_seckill() {
  return new Queue(SECKILL_QUEUE);
}

@Bean
public TopicExchange seckill_exchange() {
  return new TopicExchange(SECKILL_EXCHANGE);
}

@Bean
public Binding binding_seckill() {
  return BindingBuilder.bind(queue_seckill()).to(seckill_exchange()).with(SECKILL_ROUTING_KEY);
}

1
2
3
4
5
6
@SneakyThrows
public void sendSeckillOrder(SeckillMessage msg) {
  log.info("发送秒杀消息:{}", msg);
  String msgStr = new ObjectMapper().writeValueAsString(msg);
  rabbitTemplate.convertAndSend("seckillExchange", "seckill.order", msgStr);
}

1
2
3
4
5
6
7
8
9
10
11
12
// 接收秒杀消息
@RabbitListener(queues = {"seckillQueue"})
public void recevieSeckillOrderMessage(String msg) throws JsonProcessingException {
  log.info("[秒杀订单]接收到消息: {}", msg);
  ObjectMapper objectMapper = new ObjectMapper();
  SeckillMessage seckillMessage = objectMapper.readValue(msg, SeckillMessage.class);
  // 消费消息--保存订单
  User user = seckillMessage.getUser();
  Long goodsId = seckillMessage.getGoodsId();
  GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);
  orderService.seckill(user, goodsVo);
}

1
2
3
// 生成订单-发送mq消息
SeckillMessage seckillMessage = new SeckillMessage(user,goodsId);
mqSender.sendSeckillOrder(seckillMessage);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// 处理用户抢购请求 v5 消息队列
@RequestMapping("/doSeckill")
public String doSeckill_v5(User user, Model model, Long goodsId) {
  if (null == user) {
    return "login";
  }
  GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);

  // 判断是否有库存
  if (goodsVo.getStockCount() < 1) {
    model.addAttribute("errmsg", ResponseBeanEnum.INSUFFICIENT_INVENTORY.getMessage());
    return "secKillFail";
  }

  // 是否重复购买 这个判断要在预减库存 前面,
  SeckillOrder seckillOrder = (SeckillOrder) redisTemplate.opsForValue()
    .get("order:" + user.getId() + ":" + goodsVo.getId());
  if (null != seckillOrder) {
    model.addAttribute("errmsg", ResponseBeanEnum.LIMIT_BUY_ONE.getMessage());
    return "secKillFail";
  }

  // 先在本地判断, 如果没有库存直接返回,不用走后面流程了
  if (goodsStausMap.get(goodsId) != null && !goodsStausMap.get(goodsId)) {
    model.addAttribute("errmsg", ResponseBeanEnum.INSUFFICIENT_INVENTORY.getMessage());
    return "secKillFail";
  }

  // 库存预减,如果在redis没有库存了,直接返回,不往下走了,减少执行查询数据库[优化]
  Long decrement = redisTemplate.opsForValue().decrement("seckillGoods:" + goodsId);
  if (decrement < 0) { // 说明商品已经没有库存了
    // 更新本地库存状态
    goodsStausMap.put(goodsId, false);
    // 恢复库存为0
    redisTemplate.opsForValue().set("seckillGoods:" + goodsId, 0);
    model.addAttribute("errmsg", ResponseBeanEnum.INSUFFICIENT_INVENTORY.getMessage());
    return "secKillFail";
  }
  // 生成订单-发送mq消息
  SeckillMessage seckillMessage = new SeckillMessage(user,goodsId);
  mqSender.sendSeckillOrder(seckillMessage);

  model.addAttribute("errmsg", "排队中...");
  return "secKillFail";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 生成唯一秒杀路径,每个用户都不一样
@Override
public String createPath(User user, Long goodsId) {
  // 生成一个秒杀路径
  String path = MD5Util.md5(UUIDUtil.uuid());
  // key=seckillPath:userId:goodsId, value=path 过期时间60s
  redisTemplate.opsForValue().set("seckillPath:" + user.getId() + ":" + goodsId, path, 60, TimeUnit.SECONDS);
  return path;
}

 // 校验秒杀路径
@Override
public boolean checkPath(User user, Long goodsId, String path) {
  if (user == null || goodsId < 0 || !StringUtils.hasText(path)) {
    return false;
  }
  // 校验路径
  String redisPath = (String) redisTemplate.opsForValue().get("seckillPath:" + user.getId() + ":" + goodsId);
  return path.equals(redisPath);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// 处理用户抢购请求 v6  增加秒杀安全机制, 返回json数据, 不跳转页面了
@RequestMapping("/{path}/doSeckill")
@ResponseBody
public ResponseBean doSeckill_v6(@PathVariable("path") String path, User user, Long goodsId) {
  if (null == user) {
    return ResponseBean.error(ResponseBeanEnum.SESSION_ERROR);
  }
  // 校验路径是否合法
  boolean isPathOk = orderService.checkPath(user, goodsId, path);
  if (!isPathOk) {
    return ResponseBean.error(ResponseBeanEnum.REQUEST_ILLEGAL);
  }

  GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);
  // 判断是否有库存
  if (goodsVo.getStockCount() < 1) {
    return ResponseBean.error(ResponseBeanEnum.INSUFFICIENT_INVENTORY);
  }

  // 是否重复购买 这个判断要在预减库存 前面,
  SeckillOrder seckillOrder = (SeckillOrder) redisTemplate.opsForValue()
    .get("order:" + user.getId() + ":" + goodsVo.getId());
  if (null != seckillOrder) {
    return ResponseBean.error(ResponseBeanEnum.LIMIT_BUY_ONE);
  }

  // 先在本地判断, 如果没有库存直接返回,不用走后面流程了
  if (goodsStausMap.get(goodsId) != null && !goodsStausMap.get(goodsId)) {
    return ResponseBean.error(ResponseBeanEnum.INSUFFICIENT_INVENTORY);
  }

  // 库存预减,如果在redis没有库存了,直接返回,不往下走了,减少执行查询数据库[优化]
  Long decrement = redisTemplate.opsForValue().decrement("seckillGoods:" + goodsId);
  if (decrement < 0) { // 说明商品已经没有库存了
    // 更新本地库存状态
    goodsStausMap.put(goodsId, false);
    // 恢复库存为0
    redisTemplate.opsForValue().set("seckillGoods:" + goodsId, 0);
    return ResponseBean.error(ResponseBeanEnum.INSUFFICIENT_INVENTORY);
  }

  // 生成订单-发送mq消息
  SeckillMessage seckillMessage = new SeckillMessage(user, goodsId);
  mqSender.sendSeckillOrder(seckillMessage);

  return ResponseBean.success(ResponseBeanEnum.SECKILL_QUEUE);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 生成验证码,并放到redis中
@RequestMapping("/captcha")
public void happyCaptcha(HttpServletRequest request, HttpServletResponse response, User user, Long goodsId) {
  // 生成验证码并返回, 验证码默认就保存在session中, sessionKey: happy-captcha
  HappyCaptcha.require(request, response)
    .style(CaptchaStyle.ANIM)            // 设置展现样式为动画
    .type(CaptchaType.NUMBER)            // 设置验证码内容为数字
    .length(6)                            // 设置字符长度为6
    .width(220)                            // 设置动画宽度为220
    .height(80)                            // 设置动画高度为80
    .font(Fonts.getInstance().zhFont())    // 设置汉字的字体
    .build().finish();                // 生成并输出验证码
  // 验证码保存在redis中, 时间为5min, key: captcha:userId:goodsId
  redisTemplate.opsForValue().set("captcha:" + user.getId() + ":" + goodsId,
                                  request.getSession().getAttribute("happy-captcha"), 300, TimeUnit.SECONDS);
}

1
2
3
4
5
6
7
8
@Override
public boolean checkCode(User user, Long goodsId, String code) {
  if (user == null || goodsId < 0 || !StringUtils.hasText(code)) {
    return false;
  }
  String redisCode = (String) redisTemplate.opsForValue().get("captcha:" + user.getId() + ":" + goodsId);
  return code.equals(redisCode);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 秒杀安全-获取秒杀路径
@RequestMapping("/path")
@ResponseBody
public ResponseBean getPath(User user, Long goodsId, String captcha) {
  if (user == null || goodsId == null || goodsId < 0) {
    return ResponseBean.error(ResponseBeanEnum.SESSION_ERROR);
  }
  // 校验验证码
  boolean isCodeOK = orderService.checkCode(user, goodsId, captcha);
  if (!isCodeOK) {
    return ResponseBean.error(ResponseBeanEnum.CODE_ERROR);
  }
  String path = orderService.createPath(user, goodsId);
  return ResponseBean.success(path);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 秒杀安全-获取秒杀路径-v7
@RequestMapping("/path")
@ResponseBody
public ResponseBean getPath(User user, Long goodsId, String captcha, HttpServletRequest request) {
  if (user == null || goodsId == null || goodsId < 0) {
    return ResponseBean.error(ResponseBeanEnum.SESSION_ERROR);
  }

  // v8秒杀计数器,防止用户刷接口, 5s内超过5次就认为是刷接口
  String uri = request.getRequestURI();
  Integer count = (Integer) redisTemplate.opsForValue().get(uri + ":" + user.getId());
  if (count == null) { // 说明是第一次访问
    redisTemplate.opsForValue().set(uri + ":" + user.getId(), 1, 5, TimeUnit.SECONDS);
  } else if (count != null && count < 5) {
    redisTemplate.opsForValue().increment(uri + ":" + user.getId());
  } else if (count != null && count >= 5) {
    return ResponseBean.error(ResponseBeanEnum.LIMIT_ACCESS);
  }

  // 校验验证码 -v7
  boolean isCodeOK = orderService.checkCode(user, goodsId, captcha);
  if (!isCodeOK) {
    return ResponseBean.error(ResponseBeanEnum.CODE_ERROR);
  }
  String path = orderService.createPath(user, goodsId);
  return ResponseBean.success(path);
}

1
2
3
4
5
6
7
8
9
10
11
// 在统计时间长度内,达到最大访问次数,就会限制访问
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AccessRateLimiter {
    // 统计时间长度
    int second();
    // 最大访问次数
    int maxCount();
    // 是否需要登录,默认需要登录
    boolean needLogin() default true;
}

1
2
3
4
5
6
7
8
9
10
11
12
public class UserContext {
    // 每个线程都有自己的ThreadLocal, 把共享数据放在ThreadLocal,保证线程安全
    private static ThreadLocal<User> userHolder = new ThreadLocal<>();

    public static void setUser(User user) {
        userHolder.set(user);
    }

    public static User getUser(User user) {
        return userHolder.get();
    }
}