1. 程式人生 > >搶紅包案例分析以及程式碼實現(一) 侵立刪

搶紅包案例分析以及程式碼實現(一) 侵立刪

轉自:https://mp.weixin.qq.com/s/d3HyAtWua38TSpelF-v6nQ

 

概述

電商的秒殺、搶購,春運搶票,微信QQ搶紅包,從技術的角度來說,這對於Web 系統是一個很大的考驗. 高併發場景下,系統的優化和穩定是至關重要的.

網際網路的開發包括 Java 後臺、 NoSQL、資料庫、限流、CDN、負載均衡等內容, 目前並沒有權威性的技術和設計,有的只是長期經驗的總結,但是使用這些經驗可以有效優化系統,提高系統的併發能力.

我們接下來的幾篇博文主要討論 Java 後臺、 NoSQL ( Redis )和資料庫部分技術.


搶紅包案例

主要分以下幾大部分:

  1. 環境搭建

  2. 模擬超量傳送的場景-DataBase(MySql5.7)

  3. 悲觀鎖的實現版本-DataBase(MySql5.7)

  4. 樂觀鎖的實現版本-DataBase(MySql5.7)

  5. Redis實現搶紅包


案例關注點

模擬 20 萬元的紅包,共分為 2 萬個可搶的小紅包,有 3 萬人同時搶奪的場景 ,模擬出現超發和如何保證資料一致性的問題。

在高併發的場景下,除了資料的一致性外,還要關注效能的問題 , 因為一般而言 , 時間太長使用者體驗就會很差,所以要測試資料一致性和系統的效能 。


工程結構


庫表設計

MySql5.7

/*==============================================================*/
/* Table: 紅包表                                        */
/*==============================================================*/
create table T_RED_PACKET
(
  id                   int(12)                        not null auto_increment COMMENT '紅包編號',
  user_id              int(12)                        not null COMMENT '發紅包的使用者id',
  amount               decimal(16,2)                  not null COMMENT '紅包金額',
  send_date            timestamp                      not null DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '發紅包日期',
  total                int(12)                        not null COMMENT '紅包總數', 
  unit_amount          decimal(12)                    not null COMMENT '單個紅包的金額',
  stock                int(12)                        not null COMMENT '紅包剩餘個數',
  version              int(12) default 0              not null COMMENT '版本(為後續擴充套件用)',
  note                 varchar(256)                    null COMMENT '備註',,
  primary key clustered (id)
);

 

紅包表表示存放紅包的是一個大紅包的資訊,它會分為若干個小紅包,為了業務簡單,假設每一個紅包是等額的。而對於搶紅包而言,就是從大紅包中搶奪那些剩餘的小紅包,剩餘紅包數會被記錄在紅包表中。 兩個表有外來鍵關聯 T_RED_PACKET.id = T_USER_RED_PACKET.red_packet_id

/*==============================================================*/
/* Table: 使用者搶紅包表                                                */
/*==============================================================*/
create table T_USER_RED_PACKET 
(
  id                   int(12)                        not null auto_increment COMMENT '使用者搶到的紅包id',
  red_packet_id        int(12)                        not null COMMENT '紅包id',
  user_id              int(12)                        not null COMMENT '搶紅包使用者的id',
  amount               decimal(16,2)                  not null  COMMENT '搶到的紅包金額',
  grab_time            timestamp                      not null DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '搶紅包時間',
  note                 varchar(256)                   null COMMENT '備註',
   primary key clustered (id)
);

 

/**
* 插入一個20萬元金額,2萬個小紅包,每個10元的紅包資料
*/
insert into T_RED_PACKET(user_id, amount, send_date, total, unit_amount, stock, note)
values(1, 200000.00, now(), 20000, 10.00, 20000,'20萬元金額,2萬個小紅包,每個10元');
commit;

 

這樣就建好了兩個表,並且將一個 20 萬元金額,2 萬個小紅包,每個 10 元的紅包資訊插入到了紅包表中,用作模擬資料。


Domain

有了這兩個表,我們就可以為這兩個表建兩個 POJO 了,讓這兩個表和 POJO 對應起來,這兩個 POJO 為 RedPacket 和 UserRedPacket,實現類序列化介面。

紅包資訊

package com.artisan.redpacket.pojo;

import java.io.Serializable;
import java.sql.Timestamp;

/**
* 
* 
* @ClassName: RedPacket
* 
* @Description: 紅包表對應的實體類,可序列化
* 
* @author: Mr.Yang
* 
* @date: 2018年10月8日 下午3:42:58
*/
public class RedPacket implements Serializable {

 private static final long serialVersionUID = 9036484563091364939L;
 // 紅包編號
 private Long id;
 // 發紅包的使用者id
 private Long userId;
 // 紅包金額
 private Double amount;
 // 發紅包日期
 private Timestamp sendDate;
 // 紅包總數
 private Integer total;
 // 單個紅包的金額
 private Double unitAmount;
 // 紅包剩餘個數
 private Integer stock;
 // 版本(為後續擴充套件用)
 private Integer version;
 // 備註
 private String note;
 // 省略set/get
}

 

搶紅包資訊

package com.artisan.redpacket.pojo;

import java.io.Serializable;
import java.sql.Timestamp;

/**
* 
* 
* @ClassName: UserRedPacket
* 
* @Description: 使用者搶紅包表
* 
* @author: Mr.Yang
* 
* @date: 2018年10月8日 下午3:47:40
*/
public class UserRedPacket implements Serializable {

 private static final long serialVersionUID = 7049215937937620886L;

 // 使用者紅包id
 private Long id;
 // 紅包id
 private Long redPacketId;
 // 搶紅包的使用者的id
 private Long userId;
 // 搶紅包金額
 private Double amount;
 // 搶紅包時間
 private Timestamp grabTime;
 // 備註
 private String note;
 // 省略set/get
}

Dao層實現

MyBatis Dao介面類及對應的Mapper檔案

使用 MyBatis 開發,先來完成大紅包資訊的查詢先來定義一個 DAO 物件

package com.artisan.redpacket.dao;

import org.springframework.stereotype.Repository;

import com.artisan.redpacket.pojo.RedPacket;


@Repository
public interface RedPacketDao {
 
 /**
  * 獲取紅包資訊.
  * @param id --紅包id
  * @return 紅包具體資訊
  */
 public RedPacket getRedPacket(Long id);
 
 /**
  * 扣減搶紅包數.
  * @param id -- 紅包id
  * @return 更新記錄條數
  */
 public int decreaseRedPacket(Long id);
 
 
}

 

其中的兩個方法 , 一個是查詢紅包,另一個是扣減紅包庫存。

搶紅包的邏輯是,先查詢紅包的資訊,看其是否擁有存量可以扣減。如果有存量,那麼可以扣減它,否則就不扣減。

接著將對應的Mapper對映檔案編寫一下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.artisan.redpacket.dao.RedPacketDao">

 <!-- 查詢紅包具體資訊 -->
 <select id="getRedPacket" parameterType="long"
   resultType="com.artisan.redpacket.pojo.RedPacket">
   select id, user_id as userId, amount, send_date as
   sendDate, total,
   unit_amount as unitAmount, stock, version, note from
   T_RED_PACKET
   where id = #{id}
 </select>

 <!-- 扣減搶紅包庫存 -->
 <update id="decreaseRedPacket">
   update T_RED_PACKET set stock = stock - 1 where id =
   #{id}
 </update>


</mapper>

 

這裡getRedPacket並沒有加鎖這類動作,目的是為了演示超發紅包的情況。

然後是搶紅包的設計了 ,先來定義插入搶紅包的 DAO ,緊接著是Mapper對映檔案

package com.artisan.redpacket.dao;

import org.springframework.stereotype.Repository;

import com.artisan.redpacket.pojo.UserRedPacket;

@Repository
public interface UserRedPacketDao {

 /**
  * 插入搶紅包資訊.
  * @param userRedPacket ——搶紅包資訊
  * @return 影響記錄數.
  */
 public int grapRedPacket(UserRedPacket  userRedPacket);
}

 

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.artisan.redpacket.dao.UserRedPacketDao">
   <!-- 插入搶紅包資訊 -->
   <insert id="grapRedPacket" useGeneratedKeys="true" 
   keyProperty="id" parameterType="com.artisan.redpacket.pojo.UserRedPacket">
     insert into T_USER_RED_PACKET( red_packet_id, user_id, amount, grab_time, note)
     values (#{redPacketId}, #{userId}, #{amount}, now(), #{note}) 
   </insert>
</mapper>

 

這裡使用了 useGeneratedKeys 和 keyPrope町,這就意味著會返回資料庫生成的主鍵資訊,這樣就可以拿到插入記錄的主鍵了 , 關於 DAO 層就基本完成了。別忘了單元測試!!!


Service層實現

接下來定義兩個 Service 層介面,分別是 UserRedPacketService和RedPacketService

package com.artisan.redpacket.service;

import com.artisan.redpacket.pojo.RedPacket;


public interface RedPacketService {
 
 /**
  * 獲取紅包
  * @param id ——編號
  * @return 紅包資訊
  */
 public RedPacket getRedPacket(Long id);

 /**
  * 扣減紅包
  * @param id——編號
  * @return 影響條數.
  */
 public int decreaseRedPacket(Long id);
 
}

 

package com.artisan.redpacket.service;

public interface UserRedPacketService {
 
 /**
  * 儲存搶紅包資訊.
  * @param redPacketId 紅包編號
  * @param userId 搶紅包使用者編號
  * @return 影響記錄數.
  */
 public int grapRedPacket(Long redPacketId, Long userId);
 
}

 

實現類如下:

package com.artisan.redpacket.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.artisan.redpacket.dao.RedPacketDao;
import com.artisan.redpacket.pojo.RedPacket;
import com.artisan.redpacket.service.RedPacketService;

@Service
public class RedPacketServiceImpl implements RedPacketService {
 
 @Autowired
 private RedPacketDao redPacketDao;

 @Override
 @Transactional(isolation=Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
 public RedPacket getRedPacket(Long id) {
   return redPacketDao.getRedPacket(id);
 }

 @Override
 @Transactional(isolation=Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
 public int decreaseRedPacket(Long id) {
   return redPacketDao.decreaseRedPacket(id);
 }

}

 

配置了事務註解@Transactional , 讓程式能夠在事務中執行,以保證資料的一致性 , 這裡採用的是讀/寫提交的隔離級別 , 之所以不採用更高的級別, 主要是提高資料庫的併發能力,而對於傳播行為則採用 Propagation.REQUIRED,這樣呼叫這個方法的時候,如果沒有事務則會建立事務, 如果有事務則沿用當前事務。

實現 UserRedPacketService 介面的方法 grapRedPacket,它是核心的介面方法

package com.artisan.redpacket.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.artisan.redpacket.dao.RedPacketDao;
import com.artisan.redpacket.dao.UserRedPacketDao;
import com.artisan.redpacket.pojo.RedPacket;
import com.artisan.redpacket.pojo.UserRedPacket;
import com.artisan.redpacket.service.UserRedPacketService;

@Service
public class UserRedPacketServiceImpl implements UserRedPacketService {
 
 // private Logger logger =
 // LoggerFactory.getLogger(UserRedPacketServiceImpl.class);
 
 @Autowired
 private UserRedPacketDao userRedPacketDao;

 @Autowired
 private RedPacketDao redPacketDao;

 // 失敗
 private static final int FAILED = 0;

 @Override
 @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
 public int grapRedPacket(Long redPacketId, Long userId) {
   // 獲取紅包資訊
   RedPacket redPacket = redPacketDao.getRedPacket(redPacketId);
   int leftRedPacket = redPacket.getStock();
   // 當前小紅包庫存大於0
   if (leftRedPacket > 0) {
     redPacketDao.decreaseRedPacket(redPacketId);
     // logger.info("剩餘Stock數量:{}", leftRedPacket);
     // 生成搶紅包資訊
     UserRedPacket userRedPacket = new UserRedPacket();
     userRedPacket.setRedPacketId(redPacketId);
     userRedPacket.setUserId(userId);
     userRedPacket.setAmount(redPacket.getUnitAmount());
     userRedPacket.setNote("redpacket- " + redPacketId);
     // 插入搶紅包資訊
     int result = userRedPacketDao.grapRedPacket(userRedPacket);
     return result;
   }
   // logger.info("沒有紅包啦.....剩餘Stock數量:{}", leftRedPacket);
   // 失敗返回
   return FAILED;
 }


}

 

grapRedPacket 方法的邏輯是首先獲取紅包資訊,如果發現紅包庫存大於 0,則說明還有紅包可搶,搶奪紅包並生成搶紅包的資訊將其儲存到資料庫中。要注意的是,資料庫事務方面的設定,程式碼中使用註解@Transactional , 說明它會在一個事務中執行,這樣就能夠保證所有的操作都是在一個事務中完成的。在高併發中會發生超發的現象,後面會看到超發的實際測試。


使用全註解搭建SSM 開發環境

我們這裡將使用註解的方式來完成 SSM 開發的環境,可以通過繼承 AbstractAnnotationConfigDispatcherServletlnitfal izer 去配置其他內 容,因此首先來配置 WebApplnitialize

package com.artisan.redpacket.config;

import javax.servlet.MultipartConfigElement;
import javax.servlet.ServletRegistration.Dynamic;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

 // Spring IoC環境配置
 @Override
 protected Class<?>[] getRootConfigClasses() {
   // 配置Spring IoC資源
   return new Class<?>[] { RootConfig.class };
 }

 // DispatcherServlet環境配置
 @Override
 protected Class<?>[] getServletConfigClasses() {
   // 載入Java配置類
   return new Class<?>[] { WebConfig.class };
 }

 // DispatchServlet攔截請求配置
 @Override
 protected String[] getServletMappings() {
   return new String[] { "*.do" };
 }

 /**
  * @param dynamic
  *            Servlet上傳檔案配置.
  */
 @Override
 protected void customizeRegistration(Dynamic dynamic) {
   // 配置上傳檔案路徑
   String filepath = "D:/";
   // 5MB
   Long singleMax = (long) (5 * Math.pow(2, 20));
   // 10MB
   Long totalMax = (long) (10 * Math.pow(2, 20));
   // 設定上傳檔案配置
   dynamic.setMultipartConfig(new MultipartConfigElement(filepath, singleMax, totalMax, 0));
 }

}

 

WebAppInitializer繼承了 AbstractAnnotationConfigDispatcherServletlnitializer, 重寫了 3 個抽象方法 , 並且覆蓋了父類的 customizeRegistration 方法 , 作為上傳檔案的配置。

  • getRootConfigClasses 是一個配置 Spring IoC 容器的上下文配置 , 此配置在程式碼中將會由類 RootConfig 完成

  • getServletConfigClasses 配置 DispatcherServlet 上下文配置,將會由WebConfig完成

  • getServletMappings 配置 DispatcherServlet 攔截 內 容 , 這裡設定的是攔截所有以 .do 結尾的請求

通過這 3 個方法就可以配置 Web 工程中 的 Spring IoC 資源和 DispatcherServlet 的配置內容 , 首先是配置 Spring IoC 容器,配置類 RootConfig

package com.artisan.redpacket.config;

import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.TransactionManagementConfigurer;

@Configuration
//定義Spring 掃描的包
@ComponentScan(value= "com.*", includeFilters= {@Filter(type = FilterType.ANNOTATION, value ={Service.class})})
//使用事務驅動管理器
@EnableTransactionManagement
//實現介面TransactionManagementConfigurer,這樣可以配置註解驅動事務
public class RootConfig implements TransactionManagementConfigurer {
 
 private DataSource dataSource = null;
 
 /**
  * 配置資料庫.
  * @return 資料連線池
  */
 @Bean(name = "dataSource")
 public DataSource initDataSource() {
   if (dataSource != null) {
     return dataSource;
   }
   try {
     Properties props = new Properties();
     props.load(RootConfig.class.getClassLoader().getResourceAsStream("jdbc.properties"));
     props.setProperty("driverClassName", props.getProperty("jdbc.driver"));
     props.setProperty("url", props.getProperty("jdbc.url"));
     props.setProperty("username", props.getProperty("jdbc.username"));
     props.setProperty("password", props.getProperty("jdbc.password"));
     dataSource = BasicDataSourceFactory.createDataSource(props);
   } catch (Exception e) {
     e.printStackTrace();
   }
   return dataSource;
 }
 
 /***
  * 配置SqlSessionFactoryBean
  * @return SqlSessionFactoryBean
  */
 @Bean(name="sqlSessionFactory")
 public SqlSessionFactoryBean initSqlSessionFactory() {
   SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
   sqlSessionFactory.setDataSource(initDataSource());
   //配置MyBatis配置檔案
   Resource resource = new ClassPathResource("mybatis/mybatis-config.xml");
   sqlSessionFactory.setConfigLocation(resource);
   return sqlSessionFactory;
 }
 
 /***
  * 通過自動掃描,發現MyBatis Mapper介面
  * @return Mapper掃描器
  */
 @Bean 
 public MapperScannerConfigurer initMapperScannerConfigurer() {
   MapperScannerConfigurer msc = new MapperScannerConfigurer();
   msc.setBasePackage("com.*");
   msc.setSqlSessionFactoryBeanName("sqlSessionFactory");
   msc.setAnnotationClass(Repository.class);
   return msc;
 }
 
 
 /**
  * 實現介面方法,註冊註解事務,當@Transactional 使用的時候產生資料庫事務 
  */
 @Override
 @Bean(name="annotationDrivenTransactionManager")
 public PlatformTransactionManager annotationDrivenTransactionManager() {
   DataSourceTransactionManager transactionManager = 
          new DataSourceTransactionManager();
   transactionManager.setDataSource(initDataSource());
   return transactionManager;
 }
 
 

}

 

這個類和之前論述的有所不同 , 它標註了註解@EnableTransactionManagement , 實現了介面 TransactionManagementConfigurer, 這樣的配置是為了實現註解式的事務 , 將來可以通過註解@Transactional 配 置資料庫事務。

它有一 個方法annotationDrivenTransactionManager這需要將一個事務管理器返回給它就可以了

除了配置資料庫事務外 ,還配置了資料來源 SqISessionFactoryBean 和 MyBatis 的掃描類 , 並把 MyBatis的掃描類通過註解@Repository 和包名"com.*"限定。這樣 MyBatis 就會通過 Spring 的機制找到對應的接 口和配置 , Spring 會自動把對應的介面裝配到 IoC 容器中 。

有了 Spring IoC 容器後 , 還需要配置 DispatcherServlet 上下文

package com.artisan.redpacket.config;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executor;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.scheduling.annotation.AsyncConfigurerSupport;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.HandlerAdapter;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
//定義Spring MVC掃描的包
@ComponentScan(value="com.*", includeFilters= {@Filter(type = FilterType.ANNOTATION, value = Controller.class)})
//啟動Spring MVC配置
@EnableWebMvc
public class WebConfig{ 

 /***
  * 通過註解 @Bean 初始化檢視解析器
  * @return ViewResolver 檢視解析器
  */
 @Bean(name="internalResourceViewResolver")
 public ViewResolver initViewResolver() {
   InternalResourceViewResolver viewResolver =new InternalResourceViewResolver();
   viewResolver.setPrefix("/WEB-INF/jsp/");
   viewResolver.setSuffix(".jsp");
   return viewResolver;
 }
 
 /**
  * 初始化RequestMappingHandlerAdapter,並載入Http的Json轉換器
  * @return  RequestMappingHandlerAdapter 物件
  */
 @Bean(name="requestMappingHandlerAdapter") 
 public HandlerAdapter initRequestMappingHandlerAdapter() {
   //建立RequestMappingHandlerAdapter介面卡
   RequestMappingHandlerAdapter rmhd = new RequestMappingHandlerAdapter();
   //HTTP JSON轉換器
   MappingJackson2HttpMessageConverter  jsonConverter 
         = new MappingJackson2HttpMessageConverter();
   //MappingJackson2HttpMessageConverter接收JSON型別訊息的轉換
   MediaType mediaType = MediaType.APPLICATION_JSON_UTF8;
   List<MediaType> mediaTypes = new ArrayList<MediaType>();
   mediaTypes.add(mediaType);
   //加入轉換器的支援型別
   jsonConverter.setSupportedMediaTypes(mediaTypes);
   //往介面卡加入json轉換器
   rmhd.getMessageConverters().add(jsonConverter);
   return rmhd;
 }
}

 

這裡配置了一個檢視解析器 , 通過它找到對應 JSP 檔案,然後使用資料模型進行渲染,採用自定義 創 建 RequestMappingHandlerAdapter , 為了讓它能夠支援 JSON 格式(@ResponseBody ) 的轉換,所以需要建立一個關於物件和 JSON 的轉換訊息類MappingJackson2HttpMessageConverter

建立它之後,把它註冊給 RequestMappingHandlerAdapter物件 , 這樣當控制器遇到註解@ResponseBody 的時候就知道採用 JSON 訊息型別進行應答 , 那麼在控制器完成邏輯後 , 由處理器將其和訊息轉換型別做匹配,找到MappingJackson2HttpMessageConverter 類物件,從而轉變為 JSON 資料。

通過上面的 3 個類就搭建好了 Spring MVC 和 Spring 的開發環境,但是沒有完成對MyBatis 配置檔案. 從RootConfig#initSqlSessionFactory()方法中看到載入的MyBatis 的配置檔案為"mybatis/mybatis-config.xml",該配置檔案主要是載入mapper對映檔案

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
 PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
   <mappers>
       <mapper resource="mapper/UserRedPacket.xml"/>
       <mapper resource="mapper/RedPacket.xml"/>
   </mappers>
</configuration>

 

記得進行Service層的單元測試, 關於後臺的邏輯就已經完成 , 接下來繼續將Controller層實現,進行頁面測試吧。


Controller層

package com.artisan.redpacket.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.artisan.redpacket.service.UserRedPacketService;

@Controller
@RequestMapping("/userRedPacket")
public class UserRedPacketController {

 @Autowired
 private UserRedPacketService userRedPacketService;

 @RequestMapping(value = "/grapRedPacket")
 @ResponseBody
 public Map<String, Object> grapRedPacket(Long redPacketId, Long userId) {
   // 搶紅包
   int result = userRedPacketService.grapRedPacket(redPacketId, userId);
   Map<String, Object> retMap = new HashMap<String, Object>();
   boolean flag = result > 0;
   retMap.put("success", flag);
   retMap.put("message", flag ? "搶紅包成功" : "搶紅包失敗");
   return retMap;
 }  
}

 

對於控制器而言 , 它將搶奪一個紅包 , 並且將一個 Map返回,由於使用了註解@ResponseBody 標註方法,所以最後它會轉變為一個 JSON 返回給前端請求,編寫 JSP 對其進行測試


View層

grap.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
   <head>
       <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
       <title>引數</title>
       <!-- 載入Query檔案-->
       <script type="text/javascript" src="https://code.jquery.com/jquery-3.2.0.js">
       </script>
       <script type="text/javascript">
           $(document).ready(function () {
             //模擬30000個非同步請求,進行併發
             var max = 30000;
             for (var i = 1; i <= max; i++) {
                 //jQuery的post請求,請注意這是非同步請求
                 $.post({
                     //請求搶id為1的紅包
                     //根據自己請求修改對應的url和大紅包編號
                     url: "./userRedPacket/grapRedPacket.do?redPacketId=1&userId=" + i,
                     //成功後的方法
                     success: function (result) {
                     }
                 });
             }
         });
       </script>
   </head>
   <body>
   </body>
</html>

 

這裡我們使用了 JavaScript 去模擬 3 萬人同時搶紅包的場景 . 請使用 Firefox進行測試(Chrome老是丟失請求,IE慢)

JavaScript 的 post 請求是一個非同步請求,所以這是一個高併發的場景,它將搶奪 id 為1的紅包 , 依據之前 SQL 的插入 , 這是一個 20 萬元的紅包 , 一共有兩萬個,那麼在這樣高併發場景下會有什麼問題發生呢?

注意兩個點 : 一個是資料的一致性,另外一個是效能問題。


執行測試

啟動tomcat,前端訪問 http://localhost:8080/ssm_redpacket/grap.jsp

如果有日誌,記得調成error級別,或者不列印日誌。

我這裡的mysql是部署在虛擬機器中,CPU和記憶體的配置都不高。 記憶體1G。


超量傳送的BUG驗證

模擬高併發場景的搶紅包後,兩個維度進行統計

  • 1:資料一致性

  • 2: 效能

 

搶紅包一致性統計:

SELECT
 a.id,
 a.amount,
 a.stock
FROM
 T_RED_PACKET a
WHERE
 a.id = 1
UNION ALL
 SELECT
   max(b.user_id),
   sum(b.amount),
   count(*)
 FROM
   T_USER_RED_PACKET b
 WHERE
   b.red_packet_id = 1;

使用 SQL 去查詢紅包的庫存、發放紅包的總個數、總金額,我們發現了錯誤,紅包總額為 20 萬元,兩萬個小紅包,結果發放了 200020元的紅包, 20002 個紅包。現有庫存為-2,超出了之前的限定,這就是高併發的超發現象,這是一個錯誤的邏輯 。


搶紅包效能統計:

SELECT
 (
   UNIX_TIMESTAMP(max(a.grab_time)) - UNIX_TIMESTAMP(min(a.grab_time)) 
 )  AS lastTime
FROM
 T_USER_RED_PACKET a;

一共使用了 190 秒的時間,完成 20002 個紅包的搶奪,效能一般。。。但是邏輯上存在超發錯誤,還需要解決超發問題 。


超發問題解決思路

超發現象是由多執行緒下資料不一致造成的,對於此類問題,如果採用資料庫方案的話,主要通過悲觀鎖和樂觀鎖來處理,這兩種方法的效能是不一樣的。

接下來我們分別使用悲觀鎖、樂觀鎖、Redis+lua的方式來解決這個超發問題。


程式碼

https://github.com/yangshangwei/ssm_redpacket