上一篇教大家用spring-data-redis來實現redis的訊息佇列：

https://blog.csdn.net/u011870280/article/details/80012732

現在接著來做一個測試，試試redis佇列在併發場景下的效能。

首先來一個沒佇列的場景，比如團購秒殺大家來搶一雙鞋子

在上篇專案的基礎上引入資料庫相關依賴：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
 
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
 
</dependency>

然後配置mysql

spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://192.168.1.22:3306/test?characterEncoding=utf8&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456

建立一個實體-庫存類

package com.xzg.redis.entity;
import javax.persistence.Entity;
import 
 
javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Stock {
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Long id;
    private String name;
    private Long count;
    public Long getId() {
        return id;
}

    public void setId(Long id) {
        this.id = id;
}

    public String getName() {
        return name;
}

    public void setName(String name) {
        this.name = name;
}

    public Long getCount() {
        return count;
}

    public void setCount(Long count) {
        this.count = count;
}
}

然後來個操作介面，實現買商品減庫存操作

package com.xzg.redis.repository;
import com.xzg.redis.entity.Stock;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;
public interface StockRepository extends CrudRepository<Stock, Long>{
    @Transactional
    @Modifying(clearAutomatically = true)
    @Query("update Stock stock set stock.count =stock.count-1 where stock.id =:stockId")
    void buy(@Param("stockId") Long stockId);
}

最後編寫Controller，暴露入口，完成，執行專案。

package com.xzg.redis.controller;
import com.xzg.redis.repository.StockRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
@Controller
public class ShopController {
    @Autowired
private StockRepository stockRepository;
@GetMapping(path="/buy/{stockId}")
    public @ResponseBody String buy (@PathVariable("stockId") Long stockId) {
        stockRepository.buy(stockId);
        return "OK";
}
}

可以測試了，這時候我們先來插入一條庫存資訊

insert into stock(id,name,count) values(1,'shoes',100000);

開啟Jmeter，模擬100000次請求

配置http請求

測試結果

TPS

響應時間

沒有發生錯誤，平均響應時間是0.3秒，因為是同步處理，所以TPS=throughput= 1400,還不錯。

資料庫100000的庫存也清空了

可是這十萬的請求花了一分鐘才處理完，也就是說如果有十萬個連線同時過來搶購，有些人可能要1分鐘後才收到結果，很可能超過30秒連線就超時斷開了，更有可能的是伺服器處理不過來，響應更慢，照成服務不可用甚至宕機。

接下來試試常規的處理方法，把請求塞入佇列，然後馬上返回客戶端已提交or排隊中。

就用上一篇的redis佇列，修改下Controller程式碼：

package com.xzg.redis.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
@Controller
public class ShopController {
    @Autowired
StringRedisTemplate template;
@GetMapping(path="/buy/{stockId}")
    public @ResponseBody String buy (@PathVariable("stockId") Long stockId) {
        template.convertAndSend("shop", stockId.toString());
        return "OK";
}
}

Reciver程式碼

package com.xzg.redis.message;
import com.xzg.redis.repository.StockRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class Receiver {
    private static final Logger LOGGER = LoggerFactory.getLogger(Receiver.class);
@Autowired
StockRepository stockRepository;
    public void receiveMessage(String message) {
        stockRepository.buy(Long.valueOf(message));
}
}

Application程式碼：

package com.xzg.redis;
import com.xzg.redis.message.Receiver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
@SpringBootApplication
public class Application {
    private static final Logger LOGGER = LoggerFactory.getLogger(Application.class);
@Bean
RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
MessageListenerAdapter listenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
container.setConnectionFactory(connectionFactory);
container.addMessageListener(listenerAdapter, new PatternTopic("shop"));
        return container;
}
    @Bean
MessageListenerAdapter listenerAdapter(Receiver receiver) {
        return new MessageListenerAdapter(receiver, "receiveMessage");
}
    @Bean
StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
        return new StringRedisTemplate(connectionFactory);
}
    public static void main(String[] args) throws InterruptedException {
        ApplicationContext ctx = SpringApplication.run(Application.class, args);
LOGGER.info("app started");
}
}

好，再來測試一遍！

響應時間

TPS，這一塊可能有點問題。因為我實際測試的時候比上個快多了。

總覽

用了佇列的好處很明顯，平均響應時間0.09秒，快了3倍多，而且吞吐量也上去了，接近5000！，也就是10W請求4秒就響應完了。這是很恐怖的，實際應用因為業務比較多，一般達到1000也就不錯了。

當然這是並不代表處理完成了，只能說伺服器已經接受你的請求正在處理，受限於資料庫的瓶頸，TPS還是1400，我測試報告生成了資料庫還在慢慢減庫存。

但是起碼使用者體驗好了，伺服器也可用，沒有宕機的風險。