SpringBoot秒杀系统demo

我们在平时的开发中经常会遇到秒杀，抢单的一些需求，这些系统开发时如果考虑不全面就可能会产生库存不准，以及数据库压力大等问题。

本文将以springboot为基础，结合Redis 和 RabbitMQ做一个秒杀系统的demo，主要展示Redis分布式锁以及消息队列的使用。

 

秒杀系统的主要基于以下的原则去实现

1. 系统初始化时，把商品存库数量加载到redis中
2. 当收到秒杀请求后，redis预减库存，库存不足则直接返回
3. 秒杀成功的请求入rabbitMQ，立即返回“正在抢购页面…”，当异步下单成功后才返回订单。
4. 客户端轮询是否秒杀成功，服务器请求出队，生成订单，减少库存。

 

1. 配置

 

   1.1 pom文件

 

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4     <modelVersion>4.0.0</modelVersion>
  5     <parent>
  6         <groupId>org.springframework.boot</groupId>
  7         <artifactId>spring-boot-starter-parent</artifactId>
  8         <version>2.2.5.RELEASE</version>
  9         <relativePath/> <!-- lookup parent from repository -->
 10     </parent>
 11     <groupId>com.devin</groupId>
 12     <artifactId>order_grabbing_demo</artifactId>
 13     <version>1.0.0</version>
 14     <name>order_grabbing_demo</name>
 15     <description>Demo project for Spring Boot</description>
 16 
 17     <properties>
 18         <java.version>1.8</java.version>
 19     </properties>
 20 
 21     <dependencies>
 22 
 23         <dependency>
 24             <groupId>org.springframework.boot</groupId>
 25             <artifactId>spring-boot-starter-web</artifactId>
 26         </dependency>
 27 
 28 
 29         <dependency>
 30             <groupId>tk.mybatis</groupId>
 31             <artifactId>mapper-spring-boot-starter</artifactId>
 32             <version>2.0.4</version>
 33         </dependency>
 34 
 35         <dependency>
 36             <groupId>org.springframework.boot</groupId>
 37             <artifactId>spring-boot-starter-jdbc</artifactId>
 38             <version>2.0.0.RELEASE</version>
 39         </dependency>
 40 
 41         <dependency>
 42             <groupId>org.mybatis.spring.boot</groupId>
 43             <artifactId>mybatis-spring-boot-starter</artifactId>
 44             <version>2.0.1</version>
 45         </dependency>
 46 
 47         <dependency>
 48             <groupId>mysql</groupId>
 49             <artifactId>mysql-connector-java</artifactId>
 50             <version>5.1.17</version>
 51         </dependency>
 52 
 53         <dependency>
 54             <groupId>com.alibaba</groupId>
 55             <artifactId>druid</artifactId>
 56             <version>1.1.1</version>
 57         </dependency>
 58 
 59         <dependency>
 60             <groupId>org.projectlombok</groupId>
 61             <artifactId>lombok</artifactId>
 62             <version>1.16.22</version>
 63         </dependency>
 64 
 65 
 66         <dependency>
 67             <groupId>org.springframework.boot</groupId>
 68             <artifactId>spring-boot-starter-amqp</artifactId>
 69             <version>2.1.8.RELEASE</version>
 70         </dependency>
 71 
 72         <dependency>
 73             <groupId>org.springframework.boot</groupId>
 74             <artifactId>spring-boot-test</artifactId>
 75             <version>2.2.6.RELEASE</version>
 76         </dependency>
 77         <dependency>
 78             <groupId>junit</groupId>
 79             <artifactId>junit</artifactId>
 80             <version>4.12</version>
 81         </dependency>
 82         <dependency>
 83             <groupId>org.springframework</groupId>
 84             <artifactId>spring-test</artifactId>
 85             <version>5.2.5.RELEASE</version>
 86         </dependency>
 87 
 88 
 89 
 90         <!--  springboot整合 redis -->
 91         <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
 92         <dependency>
 93             <groupId>org.springframework.boot</groupId>
 94             <artifactId>spring-boot-starter-data-redis</artifactId>
 95             <version>2.2.0.RELEASE</version>
 96             <exclusions>
 97                 <exclusion>
 98                     <groupId>io.lettuce</groupId>
 99                     <artifactId>lettuce-core</artifactId>
100                 </exclusion>
101             </exclusions>
102         </dependency>
103 
104         <dependency>
105             <groupId>redis.clients</groupId>
106             <artifactId>jedis</artifactId>
107         </dependency>
108 
109 
110         <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
111         <dependency>
112             <groupId>com.alibaba</groupId>
113             <artifactId>fastjson</artifactId>
114             <version>1.2.57</version>
115         </dependency>
116 
117 
118         <dependency>
119             <groupId>org.apache.commons</groupId>
120             <artifactId>commons-lang3</artifactId>
121             <version>3.5</version>
122         </dependency>
123 
124         <dependency>
125             <groupId>commons-codec</groupId>
126             <artifactId>commons-codec</artifactId>
127             <version>1.10</version>
128         </dependency>
129 
130     </dependencies>
131 
132     <build>
133         <plugins>
134             <plugin>
135                 <groupId>org.springframework.boot</groupId>
136                 <artifactId>spring-boot-maven-plugin</artifactId>
137             </plugin>
138         </plugins>
139     </build>
140 
141     <repositories>
142         <repository>
143             <id>maven-ali</id>
144             <url>http://maven.aliyun.com/nexus/content/groups/public//</url>
145             <releases>
146                 <enabled>true</enabled>
147             </releases>
148             <snapshots>
149                 <enabled>true</enabled>
150                 <updatePolicy>always</updatePolicy>
151                 <checksumPolicy>fail</checksumPolicy>
152             </snapshots>
153         </repository>
154     </repositories>
155 
156 
157 </project>

 

   1.2. application.yml 配置 

 

    主要配置了数据库，Redis，RabbitMQ的配置

     

 1 server:
 2   port: 7999
 3 spring:
 4   servlet:
 5     multipart:
 6       max-request-size: 100MB
 7       max-file-size: 20MB
 8   http:
 9     encoding:
10       charset: utf-8
11       force: true
12       enabled: true
13   datasource:
14     platform: mysql
15     type: com.alibaba.druid.pool.DruidDataSource
16     initialSize: 5
17     minIdle: 3
18     maxActive: 500
19     maxWait: 60000
20     timeBetweenEvictionRunsMillis: 60000
21     minEvictableIdleTimeMillis: 30000
22     validationQuery: select 1
23     testOnBorrow: true
24     poolPreparedStatements: true
25     maxPoolPreparedStatementPerConnectionSize: 20
26     driverClassName: com.mysql.jdbc.Driver
27     url: jdbc:mysql://192.168.0.91:3306/order_db?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=utf-8&useAffectedRows=true&rewriteBatchedStatements=true
28     username: root
29     password: root
30   rabbitmq:
31     host: localhost
32     port: 5672
33     username: guest
34     password: guest
35   redis:
36     host: 192.168.0.91
37     port: 6379
38     password: myredis
39     timeout: 2000
40     pool:
41       max-idle: 100
42       min-idle: 1
43       max-active: 1000
44       max-wait: -1

 

 2. 订单model以及对应的mybatis配置

   本文只是做一个订单的记录，所以表的字段比较简单

     

1 CREATE TABLE `order_t` (
2   `order_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键 订单ID',
3   `user_id` varchar(128) DEFAULT NULL COMMENT '用户Id',
4   `product_id` varchar(128) DEFAULT NULL COMMENT '产品Id',
5   `create_time` bigint(20) DEFAULT NULL COMMENT '时间',
6   PRIMARY KEY (`order_id`)
7 ) ENGINE=InnoDB AUTO_INCREMENT=36255 DEFAULT CHARSET=utf8mb4;

  

 1 package com.devin.order.model;
 2 
 3 import lombok.Data;
 4 
 5 import javax.persistence.*;
 6 import java.io.Serializable;
 7 
 8 /**
 9  * @author Devin Zhang
10  * @className Order
11  * @description TODO
12  * @date 2020/4/25 11:03
13  */
14 @Data
15 @Table(name = "order_t")
16 public class Order implements Serializable {
17 
18     @Id
19     @Column(name = "order_id")
20     @GeneratedValue(strategy= GenerationType.IDENTITY)
21     private Integer orderId;
22 
23     private String userId;
24     private String productId;
25     private Long createTime;
26 
27 }

  

  本项目中使用了mybatis的通用mapper tkmybatis，所以配置文件中都是空的

   

OrderMapper.java
 1 package com.devin.order.mapper;
 2 
 3 import com.devin.order.model.Order;
 4 import tk.mybatis.mapper.common.Mapper;
 5 import tk.mybatis.mapper.common.MySqlMapper;
 6 
 7 /**
 8  * @author Devin Zhang
 9  * @className OrderMapper
10  * @description TODO
11  * @date 2020/4/22 16:24
12  */
13 
14 public interface OrderMapper extends Mapper<Order>, MySqlMapper<Order> {
15 }

 OrderMapper.xml

1 <?xml version="1.0" encoding="UTF-8" ?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
3 <mapper namespace="com.devin.order.mapper.OrderMapper" >
4 
5 </mapper>

 

 

 3.  Redis工具类

   

  1 package com.devin.order.util;
  2 
  3 import lombok.extern.slf4j.Slf4j;
  4 import org.apache.commons.lang3.StringUtils;
  5 import org.springframework.data.redis.core.RedisTemplate;
  6 import org.springframework.data.redis.serializer.GenericToStringSerializer;
  7 import org.springframework.stereotype.Component;
  8 
  9 import javax.annotation.PostConstruct;
 10 import javax.annotation.Resource;
 11 
 12 /**
 13  * @author Devin Zhang
 14  * @className RedisClient
 15  * @description TODO
 16  * @date 2020/4/24 17:51
 17  */
 18 
 19 @Slf4j
 20 @Component
 21 public class RedisClient {
 22 
 23     @Resource
 24     private RedisTemplate<String, Object> redisTemplate;
 25 
 26     @PostConstruct
 27     public void init() {
 28         redisTemplate.setKeySerializer(new GenericToStringSerializer<>(String.class));
 29     }
 30 
 31 
 32     /**
 33      * redis存值
 34      *
 35      * @param key   键
 36      * @param value 值
 37      */
 38     public void set(String key, Object value) {
 39         redisTemplate.opsForValue().set(key, value);
 40     }
 41 
 42     /**
 43      * hash存
 44      *
 45      * @param key   键
 46      * @param hash  hash
 47      * @param value 值
 48      */
 49     public void set(String key, String hash, String value) {
 50         redisTemplate.opsForHash().put(key, hash, value);
 51     }
 52 
 53 
 54     /**
 55      * redis获取值
 56      *
 57      * @param key 键
 58      * @return 返回值
 59      */
 60     public Object get(String key) {
 61         return redisTemplate.opsForValue().get(key);
 62     }
 63 
 64     /**
 65      * hash取值
 66      *
 67      * @param key  键
 68      * @param hash hash
 69      * @return 返回redis存储的值
 70      */
 71     public String get(String key, String hash) {
 72         return (String) redisTemplate.opsForHash().get(key, hash);
 73     }
 74 
 75 
 76     /**
 77      * 获取redis的锁
 78      *
 79      * @param key   键
 80      * @param value 值为当前毫秒数+过期时间毫秒数
 81      * @return 返回true/false
 82      */
 83     public boolean lock(String key, String value) {
 84         if (redisTemplate.opsForValue().setIfAbsent(key, value)) {
 85             //加锁成功就返回true
 86             return true;
 87         }
 88         //不加下面这个可能出现死锁情况
 89         //value为当前时间+超时时间
 90         //获取上一个锁的时间,并判断是否小于当前时间,小于就下一步判断,就返回true加锁成功
 91         //currentValue=A 这两个线程的value都是B 其中一个线程拿到锁
 92         String currentValue = (String) redisTemplate.opsForValue().get(key);
 93         //如果锁过期
 94         if (!StringUtils.isEmpty(currentValue)
 95                 && Long.parseLong(currentValue) < System.currentTimeMillis()) {
 96             //存储时间要小于当前时间
 97             //出现死锁的另一种情况,当多个线程进来后都没有返回true,接着往下执行,执行代码有先后,而if判断里只有一个线程才能满足条件
 98             //oldValue=currentValue
 99             //多个线程进来后只有其中一个线程能拿到锁(即oldValue=currentValue),其他的返回false
100             //获取上一个锁的时间
101             String oldValue = (String) redisTemplate.opsForValue().getAndSet(key, value);
102             if (!StringUtils.isEmpty(oldValue) && oldValue.equals(currentValue)) {
103                 //上一个时间不为空,并且等于当前时间
104                 return true;
105             }
106 
107         }
108         return false;
109     }
110 
111 
112     /**
113      * redis释放锁
114      *
115      * @param key   键
116      * @param value 值
117      */
118     public void unlock(String key, String value) {
119         //执行删除可能出现异常需要捕获
120         try {
121             String currentValue = (String) redisTemplate.opsForValue().get(key);
122             if (!StringUtils.isEmpty(currentValue) && currentValue.equals(value)) {
123                 //如果不为空,就删除锁
124                 redisTemplate.opsForValue().getOperations().delete(key);
125             }
126         } catch (Exception e) {
127             log.error("[redis分布式锁] 解锁", e);
128         }
129     }
130 
131 }

 

 4.  RabbitMQ配置

   

      4.1 定义消息队列的一些常量

     

 1 package com.devin.order.config;
 2 
 3 /**
 4  * @author Devin Zhang
 5  * @className RabbitConstants
 6  * @description TODO
 7  * @date 2020/4/25 10:11
 8  */
 9 
10 public class RabbitConstants {
11 
12     /**
13      * 分列模式
14      */
15     public final static String FANOUT_MODE_QUEUE = "fanout.mode";
16 
17     /**
18      * 日志打印队列
19      */
20     public final static String QUEUE_LOG_PRINT = "queue.log.recode";
21 
22     /**
23      * 主题模式
24      */
25     public final static String TOPIC_MODE_QUEUE = "topic.mode";
26 
27     /**
28      * 主题模式
29      */
30     public final static String TOPIC_ROUTING_KEY = "topic.*";
31 
32 }

     4.2 消息队列配置类

      

 1 package com.devin.order.config;
 2 
 3 /**
 4  * @author Devin Zhang
 5  * @className RabbitMqConfig
 6  * @description TODO
 7  * @date 2020/4/25 10:12
 8  */
 9 
10 
11 import lombok.extern.slf4j.Slf4j;
12 import org.springframework.amqp.core.*;
13 import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
14 import org.springframework.amqp.rabbit.core.RabbitTemplate;
15 import org.springframework.context.annotation.Bean;
16 import org.springframework.context.annotation.Configuration;
17 
18 @Slf4j
19 @Configuration
20 public class RabbitMqConfig {
21 
22     @Bean
23     public RabbitTemplate rabbitTemplate(CachingConnectionFactory connectionFactory) {
24         connectionFactory.setPublisherConfirms(true);
25         connectionFactory.setPublisherReturns(true);
26         RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
27         rabbitTemplate.setMandatory(true);
28         rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> log.info("消息发送成功:correlationData[{}],ack[{}],cause[{}]", correlationData, ack, cause));
29         rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> log.info("消息丢失:exchange[{}],route[{}],replyCode[{}],replyText[{}],message:{}", exchange, routingKey, replyCode, replyText, message));
30         return rabbitTemplate;
31     }
32 
33     /**
34      * 日志打印队列
35      */
36     @Bean
37     public Queue logPrintQueue() {
38         return new Queue(RabbitConstants.QUEUE_LOG_PRINT);
39     }
40 
41     /**
42      * 分列模式队列
43      */
44     @Bean
45     public FanoutExchange fanoutExchange() {
46         return new FanoutExchange(RabbitConstants.FANOUT_MODE_QUEUE);
47     }
48 
49     /**
50      * 分列模式绑定队列
51      *
52      * @param logPrintQueue  绑定队列
53      * @param fanoutExchange 分列模式交换器
54      */
55     @Bean
56     public Binding fanoutBinding(Queue logPrintQueue, FanoutExchange fanoutExchange) {
57         return BindingBuilder.bind(logPrintQueue).to(fanoutExchange);
58     }
59 
60     /**
61      * 主题队列
62      */
63     @Bean
64     public Queue topicQueue() {
65         return new Queue(RabbitConstants.TOPIC_ROUTING_KEY);
66     }
67 
68     /**
69      * 主题模式队列
70      * <li>路由格式必须以 . 分隔，比如 user.email 或者 user.aaa.email</li>
71      * <li>通配符 * ，代表一个占位符，或者说一个单词，比如路由为 user.*，那么 user.email 可以匹配，但是 user.aaa.email 就匹配不了</li>
72      * <li>通配符 # ，代表一个或多个占位符，或者说一个或多个单词，比如路由为 user.#，那么 user.email 可以匹配，user.aaa.email 也可以匹配</li>
73      */
74     @Bean
75     public TopicExchange topicExchange() {
76         return new TopicExchange(RabbitConstants.TOPIC_MODE_QUEUE);
77     }
78 
79     /**
80      * 主题模式绑定队列2
81      *
82      * @param topicQueue    主题队列
83      * @param topicExchange 主题模式交换器
84      */
85     @Bean
86     public Binding topicBinding(Queue topicQueue, TopicExchange topicExchange) {
87         return BindingBuilder.bind(topicQueue).to(topicExchange).with(RabbitConstants.TOPIC_ROUTING_KEY);
88     }
89 
90 }

 

 5.  抢单逻辑service

    5.1  OrderService

      

 1 package com.devin.order.Service;
 2 
 3 import com.devin.order.config.RabbitConstants;
 4 import com.devin.order.mapper.OrderMapper;
 5 import com.devin.order.model.Order;
 6 import com.devin.order.util.RedisClient;
 7 import org.springframework.amqp.rabbit.core.RabbitTemplate;
 8 import org.springframework.stereotype.Component;
 9 
10 import javax.annotation.PostConstruct;
11 import javax.annotation.Resource;
12 
13 /**
14  * @author Devin Zhang
15  * @className OrderService
16  * @description TODO
17  * @date 2020/4/25 11:14
18  */
19 
20 @Component
21 public class OrderService {
22 
23     public static final String PRODUCT_ID_KEY = "PID001_";
24     private static final Integer PRODUCT_COUNT = 5000;
25 
26     private static final String HAS_BUY_USER_KEY = "HAS_BUY_USER_KEY_";
27 
28     private static final String LOCK_KEY = "LOCK_KEY_";
29 
30 
31     private static final String FAIL_BUYED = "已经买过了";
32     private static final String BUYE_SUCCESS = "抢到了，订单生成中";
33     private static final String FAIL_SOLD_OUT = "没货了";
34     private static final String FAIL_BUSY = "排队中，请重试！";
35 
36     @Resource
37     private RedisClient redisClient;
38 
39     @Resource
40     private OrderMapper orderMapper;
41 
42     @Resource
43     private RabbitTemplate rabbitTemplate;
44 
45 
46     @PostConstruct
47     public void initOrder() {
48         redisClient.set(PRODUCT_ID_KEY, PRODUCT_COUNT);
49         System.out.println("商品已经初始化完成：数量：" + PRODUCT_COUNT);
50     }
51 
52     /**
53      * 下单
54      *
55      * @param userId
56      */
57     public String insertOrder(String userId) {
58 
59         //判断用户是否已买
60         Object hasBuy = redisClient.get(HAS_BUY_USER_KEY, userId);
61         if (hasBuy != null) {
62             return FAIL_BUYED;
63         }
64 
65         //10s自动过期
66         int redisExpireTime = 10 * 1000;
67         long lockValue = System.currentTimeMillis() + redisExpireTime;
68         //后去redis锁，只有获取成功才能继续操作
69         boolean getLock = redisClient.lock(LOCK_KEY, String.valueOf(lockValue));
70         System.out.println(userId + " getLock:" + getLock);
71         if (getLock) {
72             Integer productCount = (Integer) redisClient.get(PRODUCT_ID_KEY);
73             System.out.println("productCount:" + productCount);
74             //库存大于0才能继续下单
75             if (productCount > 0) {
76 
77                 rabbitTemplate.convertAndSend(RabbitConstants.TOPIC_MODE_QUEUE, "topic.queue", userId);
78 
79                 //减库存
80                 redisClient.set(PRODUCT_ID_KEY, (productCount - 1));
81                 //记录用户已买
82                 redisClient.set(HAS_BUY_USER_KEY, userId, "1");
83                 //手动释放锁
84                 redisClient.unlock(LOCK_KEY, String.valueOf(lockValue));
85                 return BUYE_SUCCESS;
86             } else {
87                 System.out.println("亲，" + FAIL_SOLD_OUT);
88                 //手动释放锁
89                 redisClient.unlock(LOCK_KEY, String.valueOf(lockValue));
90                 return FAIL_SOLD_OUT;
91             }
92         } else {
93             return FAIL_BUSY;
94         }
95     }
96 
97 
98 }

 

    5.2  消息队列处理订单入库

       

 1 package com.devin.order.Service;
 2 
 3 /**
 4  * 【消息队列处理器】
 5  *
 6  * @author Devin Zhang
 7  * @className RabbitMqHandler
 8  * @description TODO
 9  * @date 2020/4/25 10:54
10  */
11 
12 
13 import com.devin.order.config.RabbitConstants;
14 import com.devin.order.mapper.OrderMapper;
15 import com.devin.order.model.Order;
16 import com.devin.order.util.RedisClient;
17 import lombok.extern.slf4j.Slf4j;
18 import org.springframework.amqp.rabbit.annotation.RabbitListener;
19 import org.springframework.stereotype.Component;
20 
21 import javax.annotation.Resource;
22 
23 
24 @Slf4j
25 @Component
26 public class RabbitMqHandler {
27 
28     @Resource
29     private RedisClient redisClient;
30 
31     @Resource
32     private OrderMapper orderMapper;
33 
34     /**
35      * 日志打印处理handler
36      *
37      * @param message 待处理的消息体
38      */
39     @RabbitListener(queues = RabbitConstants.QUEUE_LOG_PRINT)
40     public void queueLogPrintHandler(String message) {
41         log.info("接收到操作日志记录消息：[{}]", message);
42     }
43 
44     /**
45      * 主题模式处理handler
46      *
47      * @param message 待处理的消息体
48      */
49     @RabbitListener(queues = RabbitConstants.TOPIC_ROUTING_KEY)
50     public void queueTopicHandler(String message) {
51         log.info("主题模式处理器，接收消息：[{}]", message);
52 
53         //todo
54 
55         String userId = message;
56 
57         //产生订单
58         System.out.println("userId:" + userId);
59         Order order = new Order();
60         order.setProductId(OrderService.PRODUCT_ID_KEY);
61         order.setUserId(userId);
62         order.setCreateTime(System.currentTimeMillis());
63         orderMapper.insert(order);
64 
65 
66         System.out.println("用户:" + userId + "下单成功");
67 
68     }
69 
70 }

 

   6. 启动类和Controller

      6.1 启动类

      

 1 package com.devin.order;
 2 
 3 import org.springframework.boot.SpringApplication;
 4 import org.springframework.boot.autoconfigure.SpringBootApplication;
 5 import tk.mybatis.spring.annotation.MapperScan;
 6 
 7 
 8 @MapperScan("com.devin.Order.mapper")
 9 @SpringBootApplication
10 public class OrderGrabbingApplication {
11 
12     public static void main(String[] args) {
13         SpringApplication.run(OrderGrabbingApplication.class, args);
14     }
15 
16 }

   6.2  抢单Controller

      OrderController

      

package com.devin.order.controller;

import com.devin.order.Service.OrderService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author Devin Zhang
 * @className JobController
 * @description TODO
 * @date 2020/4/22 16:36
 */
@RestController
@RequestMapping("/order")
public class OrderController {

    @Resource
    private OrderService orderService;

    @GetMapping("/addOrder")
    public String addOrder(String userId) {
        return orderService.insertOrder(userId);
    }

}

 后续只需要在controller中添加方法用于查询用户对应订单，前台定时轮询即可

     7. 测试

 

     写一个多线程程序进行测试，可以看到最后的数据完全正确

      

 1 import java.io.BufferedReader;
 2 import java.io.IOException;
 3 import java.io.InputStreamReader;
 4 import java.net.HttpURLConnection;
 5 import java.net.URL;
 6 import java.util.UUID;
 7 import java.util.concurrent.ExecutorService;
 8 import java.util.concurrent.Executors;
 9 
10 /**
11  * @author Devin Zhang
12  * @className Mythread
13  * @description TODO
14  * @date 2020/4/20 14:02
15  */
16 
17 public class OrderThreadTest implements Runnable {
18     @Override
19     public void run() {
20         try {
21             httpURLGETCase();
22         } catch (Exception e) {
23             e.printStackTrace();
24         }
25 
26     }
27 
28     private void httpURLGETCase() {
29         String userId = UUID.randomUUID().toString().replaceAll("-", "");
30         String methodUrl = "http://192.168.0.91:7999/order/addOrder?userId=" + userId;
31 
32         System.out.println("开始访问:" + methodUrl);
33 
34         HttpURLConnection connection = null;
35         BufferedReader reader = null;
36         String line = null;
37         try {
38             URL url = new URL(methodUrl);
39             connection = (HttpURLConnection) url.openConnection();
40             // 根据URL生成HttpURLConnection
41             connection.setRequestMethod("GET");
42             // 默认GET请求
43             connection.connect();
44             // 建立TCP连接
45             if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
46                 reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
47                 // 发送http请求
48                 StringBuilder result = new StringBuilder();
49                 // 循环读取流
50                 while ((line = reader.readLine()) != null) {
51                     result.append(line).append(System.getProperty("line.separator"));
52                     // "\n"
53                 }
54                 System.out.println("结果" + result.toString());
55                 if (result.toString().contains("没货了")) {
56                     long endTine = System.currentTimeMillis();
57                     long useTime = endTine - beginTime;
58                     //共耗时:102041毫秒
59                     //共耗时:82159毫秒
60                     System.out.println("共耗时:" + useTime + "毫秒");
61                     System.exit(0);
62                 }
63             }
64         } catch (IOException e) {
65             e.printStackTrace();
66         } finally {
67             try {
68                 reader.close();
69             } catch (IOException e) {
70                 e.printStackTrace();
71             }
72             connection.disconnect();
73         }
74     }
75 
76     static long beginTime;
77 
78     public static void main(String[] args) {
79 
80         beginTime = System.currentTimeMillis();
81 
82         ExecutorService es = Executors.newFixedThreadPool(10000);
83         OrderThreadTest mythread = new OrderThreadTest();
84         Thread thread = new Thread(mythread);
85         for (int i = 0; i < 1000001; i++) {
86             es.execute(thread);
87         }
88     }
89 }

 

 

  git地址 https://github.com/devinzhang0209/order_grabbing_demo.git

 

posted @ 2020-04-28 18:19  devin_w_zhang  阅读(1198)  评论(0)  编辑  收藏  举报