高併發-「搶紅包案例」之一:SSM環境搭建及復現紅包超發問題

時間 2019-11-17

標籤併發紅包案例之一 ssm 環境搭建復現發問简体版

原文原文鏈接

文章目錄javascript

概述
搶紅包案例
案例關注點
工程結構
庫表設計
Domain
Dao層實現
Service層實現
使用全註解搭建SSM 開發環境
Controller層
View層
運行測試
超量發送的BUG驗證
超發問題解決思路

概述

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

互聯網的開發包括 Java 後臺、 NoSQL、數據庫、限流、CDN、負載均衡等內容, 目前並無權威性的技術和設計，有的只是長期經驗的總結，可是使用這些經驗能夠有效優化系統，提升系統的併發能力.前端

咱們接下來的幾篇博文主要討論 Java 後臺、 NoSQL ( Redis ）和數據庫部分技術.java

搶紅包案例

主要分如下幾大部分：mysql

環境搭建
模擬超量發送的場景-DataBase（MySql5.7）
悲觀鎖的實現版本-DataBase（MySql5.7）
樂觀鎖的實現版本-DataBase（MySql5.7）
Redis實現搶紅包

案例關注點jquery

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

在高併發的場景下，除了數據的一致性外，還要關注性能的問題，由於通常而言，時間太長用戶體驗就會不好，因此要測試數據一致性和系統的性能 。面試

工程結構spring

庫表設計sql

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

工做一到五年的java 開發工程師朋友能夠加入咱們Java架構交流羣：760940986 羣內提供高可用，高併發，spring源碼，mybatis源碼，JVM，大數據，Netty等多個技術知識的架構視頻資料還有大把大牛在羣內交流以及解答面試指導，問題答疑~~要進來和大牛交流學習提高提高本身嗎~~~~

進羣能夠獲取大牛講解的高併發搶紅包視頻

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 extends AsyncConfigurerSupport { 
	/***
	 * 經過註解 @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;
	}
	
	
	@Override
	public Executor getAsyncExecutor() {
		ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
		taskExecutor.setCorePoolSize(5);
		taskExecutor.setMaxPoolSize(10);
		taskExecutor.setQueueCapacity(200);
		taskExecutor.initialize();
		return taskExecutor;
	}
}複製代碼

這裏配置了一個視圖解析器，經過它找到對應 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的方式來解決這個超發問題。

進羣能夠獲取大牛講解的高併發搶紅包視頻

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。