springboot實現商品秒殺功能

秒殺系統的實現主要有兩步：
1.分佈式限流：使用消息隊列的方式，來實現削峯
2.分佈式鎖

分佈式鎖的實現方式

1.基於數據庫來實現分佈式鎖
2.基於redis中的實現分佈式鎖
3.基於zookeeper實現分佈式鎖

這裏以redis實現分佈式鎖舉例
有以下幾個操作：
1.加鎖
加鎖實際上就是在redis中，給Key鍵設置一個值，爲避免死鎖，並給定一個過期時間。

SET lock_key random_value NX PX 5000

值得注意的是：
random_value 是客戶端生成的唯一的字符串。
NX 代表只在鍵不存在時，纔對鍵進行設置操作。
PX 5000 設置鍵的過期時間爲5000毫秒。
這樣，如果上面的命令執行成功，則證明客戶端獲取到了鎖。

2.解鎖
解鎖的過程就是將Key鍵刪除。但也不能亂刪，不能說客戶端1的請求將客戶端2的鎖給刪除掉。這時候random_value的作用就體現出來。
爲了保證解鎖操作的原子性，我們用LUA腳本完成這一操作。先判斷當前鎖的字符串是否與傳入的值相等，是的話就刪除Key，解鎖成功。

if redis.call('get',KEYS[1]) == ARGV[1] then
   return redis.call('del',KEYS[1])
else
   return 0
end

3.鎖過期
爲了避免發生死鎖，設置過期時間。

springboot+rabbitmq+redis實現商品秒殺功能

依賴

<!--rabbitmq消息隊列-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

<!--redis-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>2.9.0</version>
</dependency>

<!--fastjson-->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>1.1.43</version>
</dependency>

application.properties

#Redis服務器地址
spring.redis.host=127.0.0.1
#Redis服務器連接端口
spring.redis.port=6379
#Redis數據庫索引（默認爲0）
spring.redis.database=0  
#連接池最大連接數（使用負值表示沒有限制）
spring.redis.jedis.pool.max-active=50
#連接池中的最大空閒連接
spring.redis.jedis.pool.max-idle=20
#連接池中的最小空閒連接
spring.redis.jedis.pool.min-idle=2

##配置rabbitmq
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
#自定義參數：併發消費者的初始化值
spring.rabbitmq.listener.concurrency=10
#自定義參數：併發消費者的最大值
spring.rabbitmq.listener.max-concurrency=20
#自定義參數：每個消費者每次監聽時可拉取處理的消息數量
spring.rabbitmq.listener.prefetch=5

#用於處理訂單的消息隊列
order.queue.name=order.queue.name
order.exchange.name =order.exchange.name
order.routing.key.name=order.routing.key.name

RabbitmqConfig：rabbitmq配置類

/**
* rabbitmq配置類
*/
@Configuration
public class RabbitmqConfig {

    @Autowired
    private Environment env;


    @Autowired
    private CachingConnectionFactory connectionFactory;


    @Autowired
    private SimpleRabbitListenerContainerFactoryConfigurer factoryConfigurer;


    //日誌記錄器
    private static Logger logger = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);


    /**
     * 單一消費者，即爲隊列消息
     * @return
     */
    @Bean(name = "singleListenerContainer")
    public SimpleRabbitListenerContainerFactory listenerContainer(){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        factory.setConcurrentConsumers(1);
        factory.setMaxConcurrentConsumers(1);
        factory.setPrefetchCount(1);
        factory.setTxSize(1);
        factory.setAcknowledgeMode(AcknowledgeMode.AUTO);
        return factory;
    }


    /**
     * 多個消費者，即主題消息
     * @return
     */
    @Bean(name = "multiListenerContainer")
    public SimpleRabbitListenerContainerFactory multiListenerContainer(){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factoryConfigurer.configure(factory,connectionFactory);
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        factory.setAcknowledgeMode(AcknowledgeMode.NONE);


        //關於併發配置
        factory.setConcurrentConsumers(env.getProperty("spring.rabbitmq.listener.concurrency",int.class));
        factory.setMaxConcurrentConsumers(env.getProperty("spring.rabbitmq.listener.max-concurrency",int.class));
        factory.setPrefetchCount(env.getProperty("spring.rabbitmq.listener.prefetch",int.class));
        return factory;
    }


    /**
     *RabbitTemplate工具類
     * @return
     */
    @Bean
    public RabbitTemplate rabbitTemplate(){
        connectionFactory.setPublisherConfirms(true);
        connectionFactory.setPublisherReturns(true);
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMandatory(true);
        //默認是開啓應答成功後的回調函數
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                logger.info("消息發送成功:correlationData({}),ack({}),cause({})",correlationData,ack,cause);
            }
        });
        // 消息是否從Exchange路由到Queue, 注意: 這是一個失敗回調, 只有消息從Exchange路由到Queue失敗纔會回調這個方法
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                logger.info("消息丟失:exchange({}),route({}),replyCode({}),replyText({}),message:{}",exchange,routingKey,replyCode,replyText,message);
            }
        });
        return rabbitTemplate;
    }


    /**生成rabbitmq組件
     * 隊列：用來存儲消息的數據結構，位於硬盤或內存中。
     * 交換機：接收發送到RabbitMQ中的消息並決定把他們投遞到那個隊列的組件；
     * 綁定：一套規則，用於告訴交換器消息應該被存儲到哪個隊列。
     *
     * **/
   /**處理訂單的消息隊列**/
   //定義隊列
   @Bean(name ="orderQueue")
   public Queue orderQueue(){
       return new Queue(env.getProperty("order.queue.name"),true);
   }
    //定義交換機 TopicExchange爲主題消息交換器
    @Bean
    public DirectExchange orderExchange(){
        return new DirectExchange(env.getProperty("order.exchange.name"),true,false);
    }
    //定義綁定
    @Bean
    public Binding orderBinging(){
        return BindingBuilder.bind(orderQueue()).to(orderExchange()).with( env.getProperty("order.routing.key.name"));
    }


}

RedisLock：redis實現分佈式鎖工具類

/**
* redis實現分佈式鎖機制
*/
@Component
public class RedisLock {
    //日誌記錄器
    private static Logger logger = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 加鎖
     * @param key
     * @param value 當前事件+超時事件
     * @return
     */
    public boolean lock(String key,String value){
        //加鎖成功
        if (redisTemplate.opsForValue().setIfAbsent(key,value)){
            return true;
        }
        //假如currentValue=A先佔用了鎖  其他兩個線程的value都是B,保證其中一個線程拿到鎖
        String currentValue = redisTemplate.opsForValue().get(key);
        //鎖過期  防止出現死鎖
        if (!StringUtils.isEmpty(currentValue) &&
                Long.parseLong(currentValue) < System.currentTimeMillis()){
            //獲取上一步鎖的時間
            String oldValue = redisTemplate.opsForValue().getAndSet(key, value);
            if (!StringUtils.isEmpty(oldValue) &&
                    oldValue.equals(currentValue)){
                return true;
            }
        }
        return false;
    }

    /**
     * 解鎖
     * @param key
     * @param value
     */
    public void unlock(String key,String value){
        try {
            String currentValue = redisTemplate.opsForValue().get(key);
            if (!StringUtils.isEmpty(currentValue) &&
                    currentValue.equals(value)){
                redisTemplate.opsForValue().getOperations().delete(key);
            }
        }catch (Exception e){
            logger.error("【redis分佈式鎖】 解鎖異常，{}",e);
        }
    }
}

CommodityController：生產者

/**
* 這是用戶模塊的Controller
*/
@RestController
@RequestMapping("/attendance/commodity")
@Api(value = "商品模塊")
public class CommodityController {

    @Autowired
    CommodityService commodityService;


    @Autowired
    RabbitTemplate rabbitTemplate;


    @Autowired
    RedisTemplate redisTemplate;


    @Autowired
    private Environment env;


    //日誌記錄器
    private static Logger logger = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);


    /**
     * 新建商品秒殺
     */
    @PostMapping("/createSeckill")
    @ApiOperation(value = "新建商品秒殺")
    public ResponseResult createSeckill(HttpServletRequest request) {
        logger.info("start UserController.createSeckill");
        CommodityPojo commodityPojo=new CommodityPojo();
        commodityPojo.setCommodityAllNum(1000);
        commodityPojo.setCommodityName("測試商品一");
        commodityService.createSeckill(commodityPojo);
        logger.info("end UserController.createSeckill");
        return ResponseResult.success(ConstantsUtil.OPERATE_SUCCESS);
    }


    /**
     * 進行商品秒殺
     */
    @PostMapping("/seckill")
    @ApiOperation(value = "進行商品秒殺")
    public ResponseResult seckill(HttpServletRequest request) {
        logger.info("start UserController.seckill");
        String productId ="43486796d2871dfbec0f62951750ea4c";
        String user ="admin";
        OrderPojo orderPojo =new OrderPojo();
        orderPojo.setUserId(user);
        orderPojo.setProductId(productId);
        orderPojo.setOrderPrice(100L);
        orderPojo.setTempId(CommonUtil.getUUID());
        rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
        rabbitTemplate.setExchange(env.getProperty("order.exchange.name"));
        rabbitTemplate.setRoutingKey(env.getProperty("order.routing.key.name"));
        try {
            Message message = MessageBuilder.withBody(JacksonUtils.toJson(orderPojo).getBytes("UTF-8")).build();
            //設置請求編碼格式
            message.getMessageProperties().setHeader(AbstractJavaTypeMapper.DEFAULT_CONTENT_CLASSID_FIELD_NAME, MessageProperties.CONTENT_TYPE_JSON);
            rabbitTemplate.convertAndSend(message);
        }catch (Exception e){
            logger.error("訂單消息生產者發送消息失敗"+e.getMessage(),e);
            return ResponseResult.error(ConstantsUtil.OPERATE_ERROR);
        }
        logger.info("end UserController.seckill");
        return ResponseResult.success(orderPojo.getTempId(),ConstantsUtil.OPERATE_SUCCESS);
    }




    /**
     * 獲取進行商品秒殺的結果
     */
    @PostMapping("/getSeckillResultMent")
    @ApiOperation(value = "獲取進行商品秒殺的結果")
    public ResponseResult getSeckillResultMent(HttpServletRequest request, @RequestBody JSONObject jsonObject) {
        logger.info("start UserController.getSeckillResultMent");
        ResponseResult responseResult=null;
        String id=jsonObject.get("id").toString();
        Object o = redisTemplate.opsForValue().get("seckill_rep_"+id);
        if(o !=null){
            String tmp =o.toString();
            try {
                responseResult=JacksonUtils.toEntity(tmp,ResponseResult.class);
            }catch (Exception e){
                logger.error("獲取進行商品秒殺的結果異常"+e.getStackTrace(),e);
            }
        }else {
            responseResult =ResponseResult.error(ConstantsUtil.QUERY_ERROR);
        }
        logger.info("end UserController.getSeckillResultMent");
        return responseResult;
    }
}

CommonMqListener：消費者

/**
* 這裏是消息隊列的消費者
*/

@Component
public class CommonMqListener {


    @Autowired
    OrderService orderService;


    @Autowired
    RedisTemplate redisTemplate;


    private static ObjectMapper objectMapper = new ObjectMapper();


    //日誌記錄器
    private static Logger logger = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);
    /**
     * 監聽消費訂單消息消息
     * @param message
     */
    @RabbitListener(queues = "${order.queue.name}",containerFactory = "singleListenerContainer")
    public void consumeOrderQueue(@Payload byte[] message) {
        try {
            OrderPojo orderPojo = objectMapper.readValue(message,OrderPojo.class);
            ResponseResult responseResult= orderService.seckillNewOrder(orderPojo);
            //將結果存放在redis中 10s
            redisTemplate.opsForValue().set("seckill_rep_"+orderPojo.getTempId(), JacksonUtils.toJson(responseResult),10, TimeUnit.SECONDS);
            logger.info("監聽消費 監聽到消息： {} ,響應結果：{}", orderPojo.toString(),responseResult.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

OrderService：消費者中的訂單操作

@Service
@Transactional
public class OrderService   extends ServiceImpl<OrderPojoMapper, OrderPojo> implements IOrderService {


    @Autowired
    OrderPojoMapper orderPojoMapper;


    /** 超時時間 */
    private static final int TIMEOUT = 5000;


    @Autowired
    RedisLock redisLock;


    @Autowired
    RedisTemplate redisTemplate;


    //日誌記錄器
    private static Logger logger = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);

    /**
     * 秒殺中訂單
     * @param orderPojo
     * @return
     */
    @Override
    public ResponseResult seckillNewOrder(OrderPojo orderPojo) {
        String msg="";
        String productId=orderPojo.getProductId();
        long time = System.currentTimeMillis() + TIMEOUT;
        //加鎖
        String lockKey = "seckill:"+productId;
        if (!redisLock.lock(lockKey,String.valueOf(time))){
            return ResponseResult.error(ConstantsUtil.seckill_fail);
        }
        //進行商品搶購（商品數減一）
        int stockNum = 0;
        Object tmp =redisTemplate.opsForValue().get("seckill_"+productId);
        if(tmp!=null){
            String stockNumStr =tmp.toString();
            if(StringUtils.isNotBlank(stockNumStr)){
                stockNum = Integer.valueOf(stockNumStr);
            }
            if (stockNum == 0) {
                //庫存不足
                return ResponseResult.error(ConstantsUtil.seckill_fail2);
            } else {
                    redisTemplate.opsForValue().set("seckill_"+productId,String.valueOf(stockNum-1));
                    msg="恭喜你搶到商品，剩餘商品數量爲"+(stockNum-1);
                    //創建訂單
                    orderPojoMapper.insert(orderPojo);
            }
        }else {
            return ResponseResult.error(ConstantsUtil.seckill_fail3);
        }
        //解鎖
        redisLock.unlock(lockKey, String.valueOf(time));
        return ResponseResult.success(msg);
    }
}

驗證：

使用jmeter模擬高併發訪問：

針對一次請求獲取具體的結果

springboot實現商品秒殺功能

分佈式鎖的實現方式

springboot+rabbitmq+redis實現商品秒殺功能

application.properties

RabbitmqConfig：rabbitmq配置類

RedisLock：redis實現分佈式鎖工具類

CommodityController：生產者

CommonMqListener：消費者

OrderService：消費者中的訂單操作

驗證：

使用c#強大的表達式樹實現對象的深克隆之解決循環引用的問題

痞子衡嵌入式：恩智浦i.MX RT1xxx系列MCU啓動那些事（12.A）- uSDHC eMMC啓動時間(RT1170)

本地SSL證書過期輸入命令在IIS自動生成

java中分佈式鎖的實現方式

基於場景的JVM調優

java中的sychronized與鎖

mysql同步失敗

消息隊列發佈端性能優化

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結