JAVA高并发秒杀API项目的学习笔记

一步一步的搭建JAVA WEB项目，采用Maven构建，基于MYBatis+Spring+Spring MVC+Bootstrap技术的秒杀项目
学习的视频：http://www.imooc.com/learn/587

创建Maven项目

创建目录，执行Maven命令

mvn archetype:generate -DgroupId=org.seckill -DartifactId=seckill -DarchetypeArtifactId=maven-archetype-webapp -DarchetypeCatalog=local

问题：Maven命令执行到Generating Project in Batch mode 卡住，参考链接

将项目导入到IDEA工具中

修改项目配置

修改web.xml中的servlet版本，默认是2.3，其不支持JSP的EL表达式。从Tomcat中的示例的web.xml中拷贝3.0的版本配置到项目中

补全目录。项目的main目录下创建java目录，在src目录下创建test目录，test目录下创建java和sources目录

打开pom.xml，进行依赖的配置

单元测试依赖：Junit4

日志依赖：slf4j+logback。(lf4j是规范/接口，log4j,common-logging,logback是日志的实现)

数据库依赖：mysql-connector-java、c3p0

DAO框架：mybatis依赖:mybatis

Servlet web相关依赖：standard、jstl、jackson-databind、servlet-api

Spring依赖:spring-core、spring-beans、spring-context、spring-jdbc、spring-tx、spring-web、spring-webmvc、spring-test

<dependencies>
<!---3.0使用编程方式，4.0使用注解方式-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.12</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-core</artifactId>
<version>1.1.1</version>
</dependency>
<!--实现slf4j接口并进行整合-->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.1.1</version>
</dependency>
<!--数据库相关依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.35</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<!--DAO框架：mybatis依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.3.0</version>
</dependency>
<!--mybatis自身实现的spring的整合依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.2.3</version>
</dependency>
<!--servlet web相关依赖-->
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>1.1.2</version>
</dependency>
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.5.4</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>

<!--Spring依赖-->
<!--spring核心-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>
<!--spring的DAO层依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>
<!--spring的WEB层依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>
<!--spring的单元测试依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>
</dependencies>

数据库的设计

在项目main目录下创建sql目录，新建 schema.sql，作为数据库的创建脚本

脚本代码如下：
```
-- 数据库初始化脚本

-- 创建数据库
CREATE DATABASE seckill;

-- 使用数据库
use seckill;

-- 创建秒杀库存表：使用InnoDB引擎，其支持事务。主键自增设置为从1000开始，字符格式设置为UTF8
CREATE TABLE seckill(
seckill_id bigint NOT NULL AUTO_INCREMENT COMMENT '商品库存id',
name varchar(120) NOT NULL COMMENT '商品名称',
number int NOT NULL COMMENT '库存数量',
start_time timestamp NOT NULL COMMENT '秒杀开启时间',
end_time timestamp NOT NULL COMMENT '秒杀结束时间',
create_time timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',

PRIMARY KEY (seckill_id),

KEY idx_start_time(start_time),
KEY idx_end_time(end_time),
KEY idx_create_time(create_time)
)ENGINE=InnoDB AUTO_INCREMENT=1000 DEFAULT CHARSET=utf8 COMMENT='秒杀库存表';

-- 秒杀成功明细表
CREATE TABLE success_killed(
seckill_id bigint NOT NULL COMMENT '秒杀商品id',
user_phone int NOT NULL COMMENT '用户手机号',
state tinyint NOT NULL COMMENT '状态标示：-1指无效，0指成功，1指已付款',
create_time timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (seckill_id,user_phone),
KEY idx_create_time(create_time)
)ENGINE=InnoDB AUTO_INCREMENT=1000 DEFAULT CHARSET=utf8 COMMENT='秒杀成功明细表';

-- 初始化数据
INSERT INTO seckill(name,number,start_time,end_time)
VALUES
('1000元秒杀iphone6',100,'2016-06-28 00:00:00','2016-06-29 00:00:00'),
('500元秒杀iphone5',200,'2016-06-28 00:00:00','2016-06-29 00:00:00'),
('200元秒杀小米4',300,'2016-06-28 00:00:00','2016-06-29 00:00:00'),
('100元秒杀红米note',400,'2016-06-28 00:00:00','2016-06-29 00:00:00');

-- show create table seckill;
-- 为什么手写DDL，记录每次上线的DDL修改
```

DAO实体和接口

创建实体包org.seckill.entity

创建DAO包org.seckill.dao

创建SecKill实体类，生成getter和setter,重写toString

private long secKillId;
private String name;
private int number;
private Date startTime;
private Date endTime;
private Date createTime;

创建SuccessKilled实体类，生成getter和setter，重写toString

private long secKillId;
private long userPhone;
private short state;
private Date createTime;

创建DAO接口SecKillDao,添加减库存，根据ID查询秒杀对象，查询秒杀商品列表方法

/**
* 减库存
* @param secKillId
* @param killTime
* @return如果影响行数大于1，表示更新的记录行数
*/
int reduceNumber(long secKillId,Date killTime);

/**
* 根据id查询秒杀对象
* @param secKillId
* @return
*/
SecKill queryById(long secKillId);

/**
* 根据偏移量查询秒杀商品列表
* @param offset
* @param limit
* @return
*/
List<SecKill> queryAll(int offset,int limit);

创建DAO接口SuccessKilledDao,添加插入购买明细，根据ID查询购买明细实体的方法

/**
* 插入购买明细，可过滤重复
* @param secKillId
* @param userPhone
* @return插入的行数
*/
int inertSuccessKilled(long secKillId,long userPhone);

/**
*根据ID查询SuccessKilled并携带秒杀产品对象实体
* @param secKillId
* @return
*/
SuccessKilled queryByIdWithSecKill(long secKillId);

基于MyBaits实现DAO接口

创建mybatis-config.xml全局配置文件

<?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>
<!--配置全局属性-->
<settings>
<!--使用jdbc的getGeneratedKeys获取数据库自增主键值-->
<setting name="useGenerateKeys" value="true"/>

<!--使用列别名替换列名 默认为true-->
<setting name="useColumnLabel" value="true"/>

<!--开启驼峰命名转换-->
<setting name="mapUnderscoreCamelCase" value="true"
</settings>
</configuration>

创建mapper文件夹，用于存储mybatis映射文件

创建SecKilledDao.xml映射文件

<?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="org.seckill.dao.SecKillDao">
<!--为DAO接口方法提供sql语句配置-->
<update id="reduceNumber">
<!--具体的sql-->
update
seckill
set
number = number -1
where seckill_id = #{secKillId}
and start_time <![CDATA[ <= ]]> #{killTime}
and end_time >= #{killTime}
and number > 0;
</update>

<select id="queryById" resultType="SecKill" parameterType="long">
select seckill_id,name,number,start_time,end_time,create_time
from seckill
where seckill_id = #{secKillId}
</select>

<select id="queryAll" resultType="SecKill">
select seckill_id,name,number,start_time,end_time,create_time
from seckill
order by create_time desc
limit #{offset},#{limit}
</select>
</mapper>

创建SuccessKilledDao.xml映射文件

<?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="org.seckill.dao.SuccessKilledDao">
<!--为DAO接口方法提供sql语句配置-->
<insert id="insertSuccessKilled">
<!--ignore忽略主键冲突-->
insert ignore into success_killed(seckill_id,user_phone)
values (#{secKilled},#{userPhone})
</insert>

<select id="queryByIdWithSecKill" resultType="SuccessKilled">
<!--根据id查询seccessKilled并携带seckill实体 如何告诉mybatis把结果映射到successkilled同时映射到seckill属性 mybatis可以自由控制sql-->
select
sk.seckill_id,
sk.user_phone,
sk.create_time,
sk.state,
s.seckill_id "seckill.seckill_id",
s.name "seckill.name",
s.number "seckill.number",
s.start_time "seckill.start_time",
s.end_time "seckill.end_time",
s.create_time "seckill.crate_time"
from success_killed sk
inner join seckill s on sk.seckill_id = s.seckill_id
where sk.seckill_id = #{secKillId}
</select>
</mapper>

mybatis整合spring

创建spring文件，用于存储spring配置文件

创建spring-dao.xml配置文件

创建jdbc.properties配置文件，用于存储数据库相关信息

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/seckill?useUnicode=true&characterEncoding=utf-8
username=root
password=purple

在spring-dao.xml配置文件中进行四个步骤的配置

配置数据库相关参数

配置数据库连接池

配置sqlSessionFactory对象

配置扫描dao接口包，动态实现 dao接口，并注入到spring容器中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <!--配置整合mybatis过程-->
<!--配置数据库相关参数-->
<context:property-placeholder location="classpath:jdbc.properties"/>

<!--数据库连接池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${driver" />
<property name="jdbcUrl" value="${url}"/>
<property name="user" value="${username}"/>
<property name="password" value="${password}"/>

<property name="maxPoolSize" value="30"/>
<property name="minPoolSize" value="10"/>
<!--关闭连接后不自动commit-->
<property name="autoCommitOnClose" value="false"/>
<!--获取连接超时的时间-->
<property name="checkoutTimeout" value="1000"/>
<!--获取连接失败的重试次数-->
<property name="acquireRetryAttempts"   value="2"/>
</bean>

<!--配置sqlSessionFactory对象-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--注入数据库连接池-->
<property name="dataSource" value="dataSource"/>
<!--配置mybatis全局配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<!--扫描entity包，使用别名-->
<property name="typeAliasesPackage" value="org.seckill.entity"/>
<!--扫描sql配置文件-->
<property name="mapperLocations" value="mapper/*.xml"/>
</bean>

<!--配置扫描dao接口包，动态实现 dao接口，并注入到spring容器中-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--注入sqlSessionFactory对象-->
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<!--给出扫描Dao接口包-->
<property name="basePackage" value="org.seckill.dao"/>
</bean>
</beans>

Junit4与Spring进行整合，进行Junit4单元测试

创建SecKillDao的单元测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring/spring-dao.xml")
public class SecKillDaoTest {
//注入DAO实现类依赖
@Resource
private SecKillDao secKillDao;

@Test
public void testReduceNumber() throws Exception {
Date killTime = new Date();
int result = secKillDao.reduceNumber(1000L,killTime);
System.out.println(result);

}

@Test
public void testQueryById() throws Exception {
long id = 1000;
SecKill secKill = secKillDao.queryById(id);
System.out.println(secKill.getName());
}

@Test
public void testQueryAll() throws Exception {
List<SecKill> secKillList = secKillDao.queryAll(0,1000);

for(SecKill row : secKillList){
System.out.println(row.toString());
}
}
}

创建SuccessKilledDao的单元测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring/spring-dao.xml")
public class SuccessKilledDaoTest {
@Resource
private SuccessKilledDao successKilledDao;

@Test
public void testInertSuccessKilled() throws Exception {
int result = successKilledDao.insertSuccessKilled(1000L,28059830451L);
System.out.println(result);

}

@Test
public void testQueryByIdWithSecKill() throws Exception {
SuccessKilled successKilled = successKilledDao.queryByIdWithSecKill(1000L,2147483647L);
System.out.println(successKilled.toString());
}
}

学习点

单元测试类可以利用IDEA的快捷键，直接在要测试的类中进行代码的生成

mybatis的传参，需要在DAO接口方法的形参中使用@Param注解进行指明

业务层设计

秒杀业务接口设计

创建业务包service

创建数据传输实体包dto

创建异常包exception

创建dto实体

创建暴露秒杀地址DTO：Exposer

public class Exposer {
/**
* 是否开启秒杀
*/
private boolean exposed;

/**
* 秒杀ID
*/
private long secKillId;

/**
* 一种加密措施
*/
private String md5;

/**
*系统当前时间（毫秒值）
*/
private long now;

private long start;

private long end;

public Exposer(boolean exposed, String md5, long secKillId) {
this.exposed = exposed;
this.md5 = md5;
this.secKillId = secKillId;
}

public Exposer(boolean exposed, long now, long start, long end) {
this.exposed = exposed;
this.now = now;
this.start = start;
this.end = end;
}

public Exposer(boolean exposed, long secKillId) {
this.exposed = exposed;
this.secKillId = secKillId;
}

public boolean isExposed() {
return exposed;
}

public void setExposed(boolean exposed) {
this.exposed = exposed;
}

public long getSecKillId() {
return secKillId;
}

public void setSecKillId(long secKillId) {
this.secKillId = secKillId;
this.secKillId = secKillId;
}

public String getMd5() {
return md5;
}

public void setMd5(String md5) {
this.md5 = md5;
}

public long getNow() {
return now;
}

public void setNow(long now) {
this.now = now;
}

public long getStart() {
return start;
}

public void setStart(long start) {
this.start = start;
}

public long getEnd() {
return end;
}

public void setEnd(long end) {
this.end = end;
}
}

创建封装秒杀执行后结果DTO:SecKillExecution

public class SecKillExecution {

private long secKillId;

/**
* 秒杀执行结果状态
*/
private int state;

/**
* 状态表示
*/
private String stateInfo;

private SuccessKilled successKilled;

public SecKillExecution(long secKillId, int state, String stateInfo, SuccessKilled successKilled) {
this.secKillId = secKillId;
this.state = state;
this.stateInfo = stateInfo;
this.successKilled = successKilled;
}

public SecKillExecution(long secKillId, int state, String stateInfo) {
this.secKillId = secKillId;
this.state = state;
this.stateInfo = stateInfo;
}

public long getSecKillId() {
return secKillId;
}

public void setSecKillId(long secKillId) {
this.secKillId = secKillId;
}

public int getState() {
return state;
}

public void setState(int state) {
this.state = state;
}

public String getStateInfo() {
return stateInfo;
}

public void setStateInfo(String stateInfo) {
this.stateInfo = stateInfo;
}

public SuccessKilled getSuccessKilled() {
return successKilled;
}

public void setSuccessKilled(SuccessKilled successKilled) {
this.successKilled = successKilled;
}
}

创建异常类

创建业务相关异常:SecKillException

public class SecKillException extends RuntimeException{
public SecKillException(String message) {
super(message);
}

public SecKillException(String message, Throwable cause) {
super(message, cause);
}
}

创建重复秒杀异常类：RepeatKillException

public class RepeatKillException extends SecKillException{
public RepeatKillException(String message, Throwable cause) {
super(message, cause);
}

public RepeatKillException(String message) {
super(message);
}
}

创建秒杀关闭异常类：SecKillCloseExce
ption

public class SecKillCloseException extends SecKillException{
public SecKillCloseException(String message) {
super(message);
}

public SecKillCloseException(String message, Throwable cause) {
super(message, cause);
}
}

创建SecKillService业务接口:SecKillService

创建查询所有的秒杀记录方法：getSecKillList

创建查询单个秒杀记录方法:getById

创建秒杀开启时输出秒杀接口地址方法:exportSecKillUrl

创建执行秒杀操作方法:executeSecKill

public interface SecKillService {
/**
* 查询所有的秒杀记录
* @return
*/
List<SecKill> getSecKillList();

/**
* 查询单个秒杀记录
* @param secKillId
* @return
*/
SecKill getById(long secKillId);

/**
* 秒杀开启时输出秒杀接口地址
* 否则输出系统时间和秒杀时间
* 防止用户猜测出秒杀地址的规律
* @param secKillId
*/
Exposer exportSecKillUrl(long secKillId);

/**
*执行秒杀操作
* @param secKillId
* @param userPhone
* @param md5
*/
SecKillExecution executeSecKill(long secKillId,long userPhone,String md5) throws SecKillException,RepeatKillException,SecKillCloseException;
}

业务接口设计的学习点

站在使用者的角度进行设计接口，不要冗余设计

方法定义粒度，目的明确。非常友好的让使用者调用接口

参数要简炼

返回类型要清晰

秒杀业务接口实现

新建enums枚举包，将数据字典放到枚举中

在枚举包下创建秒杀状态枚举：SecKillStatEnum

public enum SecKillStatEnum {
SUCCESS(1,"秒杀成功"),
END(0,"秒杀结束"),
REPEAT(-1,"重复秒杀"),
INNER_ERROR(-2,"系统异常"),
DATA_REWRITE(-3,"数据篡改");

private int state;
private String stateInfo;

SecKillStatEnum(int state, String stateInfo) {
this.state = state;
this.stateInfo = stateInfo;
}

public int getState() {
return state;
}

public String getStateInfo() {
return stateInfo;
}

public static SecKillStatEnum stateOf(int index){
for(SecKillStatEnum state : values()) {
if(state.getState() == index){
return state;
}
}

return null;

}
}

在service包下新建impl包

创建SecKillServiceImpl实现类，实现SecKillService接口方法

public class SecKillServiceImpl implements SecKillService{
private Logger logger = LoggerFactory.getLogger(SecKillService.class);

private SecKillDao secKillDao;
private SuccessKilledDao successKilledDao;

//混淆字符，用于混淆MD5
private final String salt = "sdlkjs#$#$dfowierlkjafdmv232k3j@@##$";

@Override
public List<SecKill> getSecKillList() {
return secKillDao.queryAll(0,4);
}

@Override
public SecKill getById(long secKillId) {
return secKillDao.queryById(secKillId);
}

@Override
public Exposer exportSecKillUrl(long secKillId) {
SecKill secKill = secKillDao.queryById(secKillId);

if(null == secKill){
return  new Exposer(false,secKillId);
}

Date startTime = secKill.getStartTime();
Date endTime = secKill.getEndTime();
Date nowTime = new Date();

if(nowTime.getTime() < startTime.getTime()
|| nowTime.getTime() > endTime.getTime()){
return new Exposer(false,secKillId,nowTime.getTime(),startTime.getTime(),endTime.getTime());
}

//转化特定字符串的过程，不可逆
String md5 = getMD5(secKillId);

return new Exposer(true,md5,secKillId);

}

@Override
public SecKillExecution executeSecKill(long secKillId, long userPhone, String md5)
throws SecKillException, RepeatKillException, SecKillCloseException {
if(null == md5 || md5.equals(getMD5(secKillId))){
throw new SecKillException("seckill datarewirte");
}

try{
//执行秒杀逻辑，减库存，记录购买行为
Date nowTime = new Date();
//减库存
int updateCount = secKillDao.reduceNumber(secKillId,nowTime);

if(updateCount <= 0){
//没有更新到记录，秒杀结束
throw new SecKillCloseException("seckill is Closed");
}else{
//记录购买行为
int insertCount = successKilledDao.insertSuccessKilled(secKillId,userPhone);

//唯一：secKillId,userPhone
if(insertCount <= 0){
//重复秒杀
throw new RepeatKillException("seckill repeated");
}else{
//秒杀成功
SuccessKilled successKilled = successKilledDao.queryByIdWithSecKill(secKillId,userPhone);

return new SecKillExecution(secKillId, SecKillStatEnum.SUCCESS,successKilled);
}
}
}catch(SecKillCloseException e1){
throw e1;
}catch(RepeatKillException e2){
throw e2;
}catch (Exception e){
logger.error(e.getMessage(),e);
//所有编译期异常，转化为运行期异常
throw new SecKillException("seckill inner error:" + e.getMessage());
}
}

/**
* 生成MD5
* @param secKillId
* @return
*/
private String getMD5(long secKillId){
String base = secKillId + "/" + salt;
String md5 = DigestUtils.md5DigestAsHex(base.getBytes());
return md5;
}
}

基于Spring托管Service实现类

创建Spring的service配置spring-service.xml，进行service包下的注解类型的扫描配置

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <!--扫描service包下所有注解的类型-->
<context:component-scan base-package="org.seckill.service"/>

</beans>

在service实现类中添加上@Service的注解，在类中的dao对象添加上@Autowired的注解

配置并使用Spring声明式事务

在spring-service.xml中添加上配置事务管理器

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--注入数据库连接池-->
<property name="dataSource" ref="dataSource"/>
</bean>

在spring-service.xml中添加上配置基于注解的声明式事务

<tx:annotation-driven transaction-manager="transactionManager"/>

在业务类的executeSecKill方法中添加上@Transactional事务注解

学习点：使用注解控制事务方法的优点

开发团队达到一致约定，明确标注事务方法的编程风格

保证事务方法的执行时间尽可能短，不要穿插其他网络操作RPC/HTTP请求，或者剥离到事务方法外部

不是所有的方法都需要事务，如只有一条修改操作，只读操作就不需要事务控制

Service集成测试

添加上logback的日志配置文件logback.xml

<?xml version="1.0" encoding="UTF-8"?>

<configuration debug="true">
<!-- ch.qos.logback.core.ConsoleAppender 控制台输出 -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>[%-5level] %d{HH:mm:ss.SSS} [%thread] %logger{36} - %msg%n</pattern>
</encoder>

</appender>

<!-- 日志级别 -->
<root>
<level value="debug" />
<appender-ref ref="STDOUT" />
</root>

</configuration>

使用IDEA为SecKillService业务接口创建单元测试类SecKillServiceTest

编写单元测试方法

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:spring/spring-dao.xml","classpath:spring/spring-service.xml"})
public class SecKillServiceTest {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
@Autowired
private SecKillService secKillService;
@Test
public void testGetSecKillList() throws Exception {
List<SecKill> list = secKillService.getSecKillList();
logger.info("list={}",list);
}

@Test
public void testGetById() throws Exception {
SecKill secKill = secKillService.getById(1000L);
logger.info("secKill:{}",secKill);

}

/**
* 测试完整业务，注意集成测试代码完整逻辑，注意可重复执行
* @throws Exception
*/
@Test
public void testSecKillLogic() throws Exception {
long id = 1000L;
Exposer exposer = secKillService.exportSecKillUrl(id);

if(exposer.isExposed()){
logger.info("exposer={}",exposer);
long phone = 18059830432L;
SecKillExecution secKillExecution = secKillService.executeSecKill(id,phone,exposer.getMd5());
logger.info("secKillExecution:{}",secKillExecution);
}else{
//秒杀未开始
logger.warn("exposer={}",exposer);
}
}

@Test
public void testExportSecKillUrl() throws Exception {
long id = 1000L;
Exposer exposer = secKillService.exportSecKillUrl(id);
logger.info("exposer={}",exposer);

}

@Test
public void testExecuteSecKill() throws Exception {
long id = 1000L;
long phone = 18059830452L;
String md5 = "f1974250b060f51c4a8e48df67232d53";

SecKillExecution secKillExecution = secKillService.executeSecKill(id,phone,md5);

logger.info("secKillExecution:{}",secKillExecution);

}
}

单元测试的学习点

集成测试的业务逻辑的完整性

注意测试的可重复执行

WEB层设计

设计Restful接口

SpringMVC整合Spring

在web.xml中配置DispatcherServlet

创建web包

创建spring-web.xml配置文件

在spring-web.xml进行SpringMVC的配置

开启SpringMVC注解模式

servlet-mapping映射路径

配置jsp显示viewResolver

扫描web相关的bean

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:conext="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!--配置Spring MVC-->
<!--开启SpringMVC注解模式-->
<!--简化配置
1、自动注册DefaultAnnotationHandlerMapping,AnnotationMethodHandlerAdapter
2、提供一系列功能：数据绑定，数字和日期的转化@NumberFormat,@DataTimeFormat
xml,json默认读写支持
-->
<mvc:annotation-driven/>

<!--servlet-mapping映射路径-->
<!--静态资源默认servlet配置
1、加入对静态资源的处理：js，css，img
2、允许使用/做整体映射
-->
<mvc:default-servlet-handler/>

<!--配置jsp显示viewResolver-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
<property name="prefix" value="/WEB-INF/jsp"/>
<property name="suffix" value=".jsp"/>
</bean>

<!--扫描web相关的bean-->
<conext:component-scan base-package="org.seckill.web"/>

</beans>

实现秒杀相关的Restful接口

创建控制类SecKillController，实现获取列表，获取单条数据，获取系统时间，获取秒杀地址，秒杀的方法

@Controller
@RequestMapping("/seckill/")//模块/资源
public class SecKillController {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
@Autowired
private SecKillService secKillService;

@RequestMapping(name="/list",method= RequestMethod.GET)
public String list(Model model){
List<SecKill> list = secKillService.getSecKillList();
model.addAttribute("list",list);
return "list";
}

@RequestMapping(value="/{secKillId}/detail",method=RequestMethod.GET)
public String detail(@PathVariable("secKillId") Long secKillId,Model model){
if(secKillId == null){
return "redirect:/seckill/list";
}

SecKill secKill = secKillService.getById(secKillId);

if(secKill == null){
return "redirect:/seckill/list";
}

model.addAttribute("secKill",secKill);
return "detail";
}

@RequestMapping(value="/{secKillId}/exposer",method = RequestMethod.POST,
produces = {"application/json;charset=utf-8"})
@ResponseBody
public SecKillResult<Exposer> exposer(@PathVariable("secKillId") Long secKillId){
SecKillResult<Exposer> result = null;

try{
Exposer exposer = secKillService.exportSecKillUrl(secKillId);
result = new SecKillResult<Exposer>(true,exposer);

}catch(Exception e){
logger.error(e.getMessage(),e);
result = new SecKillResult<Exposer>(false,e.getMessage());
}

return result;
}

@RequestMapping(value="/{secKillId}/{md5}/execution",
method = RequestMethod.POST,
produces = {"application/json;charset=utf-8"})
public SecKillResult<SecKillExecution> excute(@PathVariable("secKillId") Long secKillId,
@PathVariable("md5") String md5,
@CookieValue(value="killPhone",required = false) Long userPhone){
//springmvc valid
if(userPhone == null){
return new SecKillResult<SecKillExecution>(false,"未注册");
}

SecKillResult<SecKillExecution> result = null;

try{
SecKillExecution secKillExecution = secKillService.executeSecKill(secKillId,userPhone,md5);
result = new SecKillResult<SecKillExecution>(true,secKillExecution);

}catch(RepeatKillException e){
SecKillExecution secKillExecution = new SecKillExecution(secKillId, SecKillStatEnum.REPEAT);
result = new SecKillResult<SecKillExecution>(false,secKillExecution);

}catch(SecKillCloseException e){
SecKillExecution secKillExecution = new SecKillExecution(secKillId, SecKillStatEnum.END);
result = new SecKillResult<SecKillExecution>(false,secKillExecution);

}catch(Exception e){
logger.error(e.getMessage(),e);
SecKillExecution secKillExecution = new SecKillExecution(secKillId, SecKillStatEnum.INNER_ERROR);
result = new SecKillResult<SecKillExecution>(false,secKillExecution);
}

return result;
}

@RequestMapping(value="/time/now",method=RequestMethod.GET)
public SecKillResult<Long> time(){
Date now = new Date();
return new SecKillResult<Long>(true,now.getTime());

}
}

基于Bootstrap开发页面结构

创建jsp文件夹，创建common/header.jsp,common/tag.jsp,list.jsp,detail.jsp，并引入bootstrap框架，jquery、cookie、countdown插件，可以从百度和bootcss的CDN中引入插件。

链接：http://www.bootcdn.cn/

创建js文件seckill.js，进行登录、计时的交互逻辑的编码,并在详细页面中引入
```
var seckill = {
//封装秒杀相关ajax的url
URL: {

now: function(){
return '/seckill/time/now';
},
exposer: function(id){
return '/seckill/' + id + '/exposer';
},
execution : function(id,md5){
return '/seckill/' + id + '/' + md5 + '/execution';
}

},
//处理秒杀逻辑
handleSecKillKill: function(secKillId,node){

node.hide().html('<button class="btn btn-primary btn-lg" id="killBtn">开始秒杀</button>');

$.post(seckill.URL.exposer(secKillId),{},function(result){
if(result && result.success){
var exposer = result.data;

if(exposer.exposed){
//开启秒杀
//获取秒杀地址
var killUrl =  seckill.URL.execution(secKillId,exposer.md5);
console.log('killUrl:',killUrl);
//绑定一次点击事件
$('#killBtn').one('click',function(){
//执行秒杀请求
$(this).addClass('disabled');
$.post(killUrl,{},function(result){
if(result && result.success){
var killResult = result.data;
var state = killResult.state;
var stateInfo = killResult.stateInfo;

node.html('<span class="label label-success">'+stateInfo+'</span>');
}
});
});

node.show();
}else{
//未开启秒杀
//重新计算计时逻辑
seckill.countdown(secKillId,exposer.now,exposer.start,exposer.end);
}

}else{
console.error('result:',result);
}
});

},
//计时
countdown: function(secKillId,nowTime,startTime,endTime){

var $secKillBox = $('#seckill-box');

if(nowTime > endTime){
$secKillBox.html('秒杀结束');
}else if(nowTime < startTime){
$secKillBox.html('秒杀未开始');
var killTime = new Date(startTime + 1000);

$secKillBox.countdown(killTime,function(event){
var format = event.strftime('秒杀倒计时：%D天 %H时 %M分 %S秒');
$secKillBox.html(format);
}).on('finish.countdown',function(){
//获取秒杀地址，控制实现逻辑，执行秒杀
seckill.handleSecKillKill(secKillId,$secKillBox);
});
}else{
//秒杀开始
seckill.handleSecKillKill(secKillId,$secKillBox);
}

},
//验证手机号
validatePhone: function(phone){
if(phone && phone.length == 11 && !isNaN(phone)){
return true;
}else{
return false;
}
},
//详情页秒杀逻辑
detail: {
//详情页初始化
init: function(params){
//用户手机验证和登录，计时交互
//规划交互流程
//在cookie中查找手机号
var killPhone = $.cookie('killPhone'),
startTime = params.startTime,
endTime = params.endTime,
secKillId = params.secKillId;

//验证手机号
if(!seckill.validatePhone(killPhone)){
var killPhoneModal = $('#killPhoneModal');

killPhoneModal.modal({
show: true,
backdrop: 'static',//禁止位置关闭
keyboard: false//关闭键盘事件
});

$('#killPhoneBtn').click(function(){
var inputPhone = $('#killPhoneKey').val();
if(seckill.validatePhone(inputPhone)){
//电话写入cookie
$.cookie('killPhone',inputPhone,{expires:7,path: '/seckill'})
window.location.reload();

}else{
//正常下会有一个前端字典
$('#killPhoneMessage').hide().html('<label class="label label-danger">手机号码错误</label>').show(300);
}
});
}

//用户已经登录
//计时交互
$.get(seckill.URL.now(),function(result){
if(result && result.success){
var nowTime = result.data;
seckill.countdown(secKillId,nowTime,startTime,endTime);

}else{
consolw.error('result:',result);
}
});
}

}

}
```
3. 在detail.jsp页面中引入seckill.js文件，并进行初始化
```
<script type="text/javascript">
$(function(){
//使用EL表达式传入参数
seckill.detail.init({
secKillId: ${secKill.secKillId},
startTime: ${secKill.startTime.time},
endTime: ${secKill.endTime.time}
});
});
</script>

作者：叶子的翅膀
链接：http://www.jianshu.com/p/d94615b89204
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。