java如何实现秒杀业务 java 秒杀服务端的实现

总结复习一下之前的demo,本demo使用SpringMVC+Spring+MyBatis+MySQL实现一个秒杀系统。
1、Java高并发秒杀API之业务分析与DAO层

2、Java高并发秒杀API之web层

3、Java高并发秒杀API之Service层

4、Java高并发秒杀API之高并发优化
其实这几个流程也就是开发的流程,首先从DAO层开始开发,从后往前开发,开始Coding吧！
项目环境的搭建：
操作系统 : Windows10
IDE ：IntelliJ IDEA 2017.3.1 x64用Eclipse也一样的,工具时靠人用的
JDK : JDK1.8
Web容器 ： apache-tomcat-7.0.52
数据库 ：5.5.49 MySQL Community Server 实验性的项目用Mysql就足够啦
依赖管理工具 : Maven 管理jar包真的很方便（apache-maven-3.3.9）

这里列出的环境不是必须的,依照是自己目前方便获取的版本
项目效果图：
秒杀商品列表
秒杀结束提示界面
开始秒杀提示界面
重复秒杀提示界面
秒杀成功提示界面

注意知识点：

1、MySQL的数据类型

选择数据类型的基本原则
前提：使用适合存储引擎。
选择原则：根据选定的存储引擎，确定如何选择合适的数据类型。
下面的选择方法按存储引擎分类：
MyISAM 数据存储引擎和数据列：MyISAM数据表，最好使用固定长度(CHAR)的数据列代替可变长度(VARCHAR)的数据列。
MEMORY存储引擎和数据列：MEMORY数据表目前都使用固定长度的数据行存储，因此无论使用CHAR或VARCHAR列都没有关系。两者都是作为CHAR类型处理的。
InnoDB 存储引擎和数据列：建议使用 VARCHAR类型。

对于InnoDB数据表，内部的行存储格式没有区分固定长度和可变长度列（所有数据行都使用指向数据列值的头指针），因此在本质上，使用固定长度的CHAR列不一定比使用可变长度VARCHAR列简单。因而，主要的性能因素是数据行使用的存储总量。由于CHAR平均占用的空间多于VARCHAR，因此使用VARCHAR来最小化需要处理的数据行的存储总量和磁盘I/O是比较好的。

2、浮点数与定点数

在mysql中float、double（或real）是浮点数，decimal（或numberic）是定点数。
浮点数相对于定点数的优点是在长度一定的情况下，浮点数能够表示更大的数据范围；它的缺点是会引起精度问题。在今后关于浮点数和定点数的应用中，大家要记住以下几点：

1. 浮点数存在误差问题；
2. 对货币等对精度敏感的数据，应该用定点数表示或存储；
3. 编程中，如果用到浮点数，要特别注意误差问题，并尽量避免做浮点数比较；
4. 要注意浮点数中一些特殊值的处理。

3、SQL中# 与$ 的区别

区别：
（1）#将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。如：order by #user_id#，如果传入的值是id，则解析成的sql为order by “id”。
（2）$将传入的数据直接显示生成在sql中。如：order by $user_id$，如果传入的值是id，则解析成的sql为order by id。
（3）#方式在很大程度上能够防止sql注入。
（4）$方式无法防止sql注入。 （5）$方式一般用于传入数据库对象，例如传入表名。
（6）一般能用#的就别用KaTeX parse error: Expected 'EOF', got '#' at position 88: …执行一个存储过程。 总结区别：#̲{} 传入值时，sql解析时，…{}穿入值，sql解析时，参数是不带引号的。

初始秒杀设计

业务分析

秒杀系统业务流程如下:

由图可以发现，整个系统其实是针对库存做的系统。用户成功秒杀商品，对于我们系统的操作就是:

1.减库存。

2.记录用户的购买明细。

下面看看我们用户对库存的业务分析:

记录用户的秒杀成功信息，我们需要记录:1.谁购买成功了。2.购买成功的时间/有效期。这些数据组成了用户的秒杀成功信息，也就是用户的购买行为。

为什么我们的系统需要事务?

1.若是用户成功秒杀商品我们记录了其购买明细却没有减库存。导致商品的超卖。
2.减了库存却没有记录用户的购买明细。导致商品的少卖。对于上述两个故障，若是没有事务的支持，损失最大的无疑是我们的用户和商家。在MySQL中，它内置的事务机制，可以准确的帮我们完成减库存和记录用户购买明细的过程。

难点分析

当用户A秒杀id为10的商品时，此时MySQL需要进行的操作是:
1.开启事务。
2.更新商品的库存信息。
3.添加用户的购买明细，包括用户秒杀的商品id以及唯一标识用户身份的信息如电话号码等。
4.提交事务。
若此时有另一个用户B也在秒杀这件id为10的商品，他就需要等待，等待到用户A成功秒杀到这件商品，然后MySQL成功的提交了事务他才能拿到这个id为10的商品的锁从而进行秒杀，而同一时间是不可能只有用户B在等待，肯定是有很多很多的用户都在等待竞争行级锁。秒杀的难点就在这里，如何高效的处理这些竞争？如何高效的完成事务?

构建项目的基本骨架

首先我们要搭建出一个符合Maven约定的目录来,这里大致有两种方式,第一种:

1.使用maven命令创建项目

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

-DgroupId：代表组织和整个项目的唯一标识，比如：所有Maven组件的groupId就是org.apache.maven
-DartifactId：代表项目的具体名称，它和groupId共同确定一个项目在maven repo中的位置
-DarchetypeArtifactId：指的是原型的名字
-DarchetypeCatalog：指的是查找的规则

2.第二种直接在IDE中进行创建,这里以IDEA为例

点击左上角File>New>Project>Maven，其中Maven的配置参考maven 然后在里面勾选Create from archetype,然后再往下拉找到org.apache.cocoon:cocoon-22-archetype-webapp,选中它,注意要先勾选那个选项,否则选择不了,然后点击Next继续

然后就填写你的Maven的那几个重要的坐标了

再就配置你的Maven的相关信息,默认应该是配置好的

之后就是点Finsh,到此不出意外的话就应该创建成功了

然后在pom.xml里面添加我们需要的第三方jar包的坐标配置信息，如SSM框架、数据库、日志，如下:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.myseckill</groupId>
    <artifactId>myseckill</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <!--3.0的junit是使用编程的方式来进行测试，而junit4是使用注解的方式来运行junit-->
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>


        <!--补全项目依赖-->
        <!--1.日志 java日志有:slf4j,log4j,logback,common-logging
            slf4j:是规范/接口
            日志实现:log4j,logback,common-logging
            使用:slf4j+logback
        -->
        <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>


        <!--1.数据库相关依赖-->
        <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.1</version>
        </dependency>

        <!--2.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>

        <!-- redis客户端：Jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.7.3</version>
        </dependency>
        
        <!-- protolstuff序列化依赖 -->
        <dependency>
            <groupId>com.dyuproject.protostuff</groupId>
            <artifactId>protostuff-core</artifactId>
            <version>1.0.8</version>
        </dependency>
        <dependency>
            <groupId>com.dyuproject.protostuff</groupId>
            <artifactId>protostuff-runtime</artifactId>
            <version>1.0.8</version>
        </dependency>

        <!--3.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>
            <!--需要时候提供,工程 包含javax.servlet包的JAR包，造成与Tomcat自身的servlet-api.jar的冲突-->
            <scope>provided</scope>
        </dependency>

        <!--4:spring依赖-->
        <!--1)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>
        <!--2)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>
        <!--3)springweb相关依赖-->
        <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>
        <!--4)spring test相关依赖
        方便集成测试-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.1.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.1</version>
        </dependency>
    </dependencies>
</project>

DAO层的设计和开发

1、首先创建数据库，在main包下的sql包中创建数据库初始化脚本，相关表的sql语句如下：

-- 数据库初始化脚本

-- 创建数据库
CREATE DATABASE seckill;

-- 使用数据库
use seckill;

-- 创建秒杀数据库
-- 重点是出现多个TIMESTAMP的解决
CREATE  TABLE seckill(
  /*bigint
  从 -2^63 -1(-9223372036854775808) 到 2^63-1 (9223372036854775807) 的整型数据（所有数字）
  无符号的范围是0到18446744073709551615（2^64 - 1）。一位为 8 个字节*/
  `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 DEFAULT  '0000-00-00 00:00:00' COMMENT '秒杀时间开始',
  `end_time` TIMESTAMP NOT NULL DEFAULT  '0000-00-00 00:00:00' COMMENT '秒杀时间结束',
  `create_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (seckill_id),
  KEY inx_start_time(start_time),
  KEY inx_end_time(end_time),
  KEY inx_create_time(create_time)
)ENGINE=InnoDB AUTO_INCREMENT=1000 DEFAULT CHARSET=utf8 COMMENT = '秒杀库存表';
-- 可以支持事物的引擎只有InooDB
-- MySQL
-- Administrator建数据库的时候，表缺省是InnoDB类型。
-- MySQL默认采用的是MyISAM


-- 初始化数据
INSERT INTO
  seckill(name, number, start_time, end_time)
VALUES
  ('1000元秒杀iPhone6',100,'2019-06-20 00:00:00','2019-06-21 00:00:00'),
  ('500元秒杀iPad2',200,'2019-06-20 00:00:00','2019-06-21 00:00:00'),
  ('300元秒杀小米4',300,'2019-06-20 00:00:00','2019-06-21 00:00:00'),
  ('200元秒杀红米note',400,'2019-06-20 00:00:00','2019-06-21 00:00:00');


-- 秒杀成功明细表
-- 用户登录认证相关的信息
CREATE TABLE success_killed(
  `seckill_id` bigint NOT NULL COMMENT '秒杀商品ID',
  `user_phone` bigint NOT NULL COMMENT '用户手机号',
  `state` tinyint NOT NULL DEFAULT -1 COMMENT '状态标识：-1：无效 0：成功 1：已付款 2：已发货',
  `create_time` TIMESTAMP NOT NULL COMMENT '创建时间',
  -- 联合主键 表示只允许一个id，一个手机号
  PRIMARY KEY (seckill_id,user_phone),
  KEY idx_create_time(create_time)
)ENGINE = InnoDB  DEFAULT charset=utf8 COMMENT = '秒杀成功明细表';

-- 连接数据库控制台
/*mysql -uroot -p*/

还需要注意的是SQL版本的问题会导致视频中seckill表创建会出错。只要将create_time放在start_time和end_time之前是方便的解决方法。

这里我们需要修改下web.xml中的servlet版本为3.0

打开WEB-INF下的web.xml,修改为以下代码:

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                      http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0"
         metadata-complete="true">
  <!--用maven创建的web-app需要修改servlet的版本为3.0-->
</web-app>

修改的原因有以下几点:
高版本的Servlet支持更多的特性,更方便我们的Coding,特别是支持注解这一特性
在Servlet2.3中新加入了Listener接口的实现,我们可以使用Listener引入Spring的ContextLoaderListener

2、建立实体类

在java包下创建org.myseckill.entity包，创建一个Seckill.java实体类，用于存放秒杀商品的相关信息，代码如下

package org.myseckill.entity;

import java.util.Date;

/**
 * 用于存放秒杀商品的相关信息
 * @author kankan
 * @creater 2019-06-23 9:26
 */
public class 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 DEFAULT  '0000-00-00 00:00:00' COMMENT '秒杀时间开始',
            `end_time` TIMESTAMP NOT NULL DEFAULT  '0000-00-00 00:00:00' COMMENT '秒杀时间结束',
            `create_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',*/
    private long seckillid;//商品id
    private String name;//商品名称
    private int number;//商品库存
    private Date starttime;//秒杀开启时间
    private Date endtime;//秒杀结束时间
    private Date createtime;//创建时间

    public long getSeckillid() {
        return seckillid;
    }

    public void setSeckillid(long seckillid) {
        this.seckillid = seckillid;
    }

    public String getName() {
        return name;
    }

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

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public Date getStarttime() {
        return starttime;
    }

    public void setStarttime(Date starttime) {
        this.starttime = starttime;
    }

    public Date getEndtime() {
        return endtime;
    }

    public void setEndtime(Date endtime) {
        this.endtime = endtime;
    }

    public Date getCreatetime() {
        return createtime;
    }

    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }

    @Override
    public String toString() {
        return "Seckill{" +
                "seckillid=" + seckillid +
                ", name='" + name + '\'' +
                ", number=" + number +
                ", starttime=" + starttime +
                ", endtime=" + endtime +
                ", createtime=" + createtime +
                '}';
    }
}

同一个包下创建SuccessKilled.java，用于存放秒杀成功的用户信息和相应商品信息，代码如下

package org.myseckill.entity;

import java.util.Date;

/**
 * 用于存放秒杀成功的用户信息和相应商品信息
 * @author kankan
 * @creater 2019-06-23 9:32
 */
public class SuccessKilled {

    /*`seckill_id` bigint NOT NULL COMMENT '秒杀商品ID',
            `user_phone` bigint NOT NULL COMMENT '用户手机号',
            `state` tinyint NOT NULL DEFAULT -1 COMMENT '状态标识：-1：无效 0：成功 1：已付款 2：已发货',
            `create_time` TIMESTAMP NOT NULL COMMENT '创建时间',*/
    private long seckillId;
    private long userPhone;//bigint-8个字节
    private short state;//2个字节  tinyint-1个字节
    private Date createTime;

    //多对一，因为一件商品在库存中有很多数量，对应的购买明细也有很多。
    //复合属性
    private Seckill seckill;

    public Seckill getSeckill() {
        return seckill;
    }

    public void setSeckill(Seckill seckill) {
        this.seckill = seckill;
    }

    public long getSeckillId() {
        return seckillId;
    }

    public void setSeckillId(long seckillId) {
        this.seckillId = seckillId;
    }

    public long getUserPhone() {
        return userPhone;
    }

    public void setUserPhone(long userPhone) {
        this.userPhone = userPhone;
    }

    public short getState() {
        return state;
    }

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

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    @Override
    public String toString() {
        return "SuccessKilled{" +
                "seckillId=" + seckillId +
                ", userPhone=" + userPhone +
                ", state=" + state +
                ", createTime=" + createTime +
                '}';
    }
}

3、然后针对实体类创建出对应dao层的接口

在org.myseckill.dao包下创建SeckillDao.java:

package org.myseckill.dao;

import org.apache.ibatis.annotations.Param;
import org.myseckill.entity.Seckill;

import java.util.Date;
import java.util.List;

/**
 * 针对实体创建出对应dao层的接口
 * @author kankan
 * @creater 2019-06-23 9:57
 */
public interface SeckillDao {
    /**
     * 减库存
     * @param seckillId
     * @param killTime
     * @return 如果影响行数>1，表示更新库存的记录行数
     */
    int reduceNumber(@Param("seckillId") long seckillId,@Param("killTime") Date killTime);

    /**
     * 根据id查询秒杀的商品信息
     * @param seckillId
     * @return
     */
    Seckill queryById(long seckillId);

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

和SuccessKilled.java

package org.myseckill.dao;

import org.apache.ibatis.annotations.Param;
import org.myseckill.entity.SuccessKilled;

/**
 * 针对实体创建出对应dao层的接口
 * @author kankan
 * @creater 2019-06-23 9:59
 */
public interface SuccessKilledDao {
    /**
     * 插入购买明细,可过滤重复
     * @param seckillId
     * @param userPhone
     * @return插入的行数
     */
    int insertSuccessKilled(@Param("seckillId") long seckillId,@Param("userPhone") long userPhone);


    /**
     * 根据秒杀商品的id查询明细SuccessKilled对象(该对象携带了Seckill秒杀产品对象)
     * @param seckillId
     * @return
     */
    SuccessKilled queryByIdWithSeckill(@Param("seckillId") long seckillId,@Param("userPhone")  long userPhone);
}

4、接下来基于MyBatis来实现我们之前设计的Dao层接口。

首先需要配置我们的MyBatis，在resources包下创建MyBatis全局配置文件mybatis-config.xml文件，在浏览器中输入打开MyBatis的官网文档，点击左边的”入门”栏框，找到mybatis全局配置文件，在这里有xml的一个规范，也就是它的一个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">

到我们的项目mybatis全局配置文件中，然后在全局配置文件中加入如下配置信息:

<?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的getGeneratekeys获取自增主键值-->
        <setting name="useGeneratedKeys" value="true"/>
        <!--使用列别名替换列名　　默认值为true
        select name as title(实体中的属性名是title) form table;
        开启后mybatis会自动帮我们把表中name的值赋到对应实体的title属性中
        -->
        <setting name="useColumnLabel" value="true"/>

        <!--开启驼峰命名转换Table:create_time到 Entity(createTime)-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

</configuration>

配置文件创建好后我们需要关注的是Dao接口该如何实现

5、mybatis为我们提供了mapper动态代理开发的方式为我们自动实现Dao的接口。

在mapper包下创建对应Dao接口的xml映射文件，里面用于编写我们操作数据库的sql语句，SeckillDao.xml和SuccessKilledDao.xml。既然又是一个xml文件，我们肯定需要它的dtd文件，在官方文档中，点击左侧”XML配置”，在它的一些事例中，找到它的xml约束:

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

首先在src/main/resources建立com.myseckill.mapper这个包,也就是对应mapper接口文件包一样的包名,这样符合Maven的约定,就是资源放置在Resource包下,Java包下则是放置java类文件,编译后最后还是会在同一个目录下

加入到两个mapper映射xml文件中，然后对照Dao层方法编写我们的映射文件内容如下:

SeckillDao.xml:

知识点：

CDATA 部分中的所有内容都会被解析器忽略。CDATA 部分由 “<![CDATA[" 开始，由 "]]>” 结束。

在mapper文件中写sql语句时，遇到特殊字符时，如：< 等，建议使用 <![CDATA[ sql 语句 ]]>标记，将sql语句包裹住，不被解析器解析

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="org.myseckill.dao.SeckillDao">
    <!--目的:为dao接口方法提供sql语句配置
   即针对dao接口中的方法编写我们的sql语句
   使用mybatis 时我们sql是写在xml 映射文件中，如果写的sql中有一些特殊的字符的话
   在解析xml文件的时候会被转义，但我们不希望他被转义，所以我们要使用<![CDATA[ ]]>来解决
   <![CDATA[    ]]> 夹住代码
   -->

    <!--减库存-->
    <update id="reduceNumber">
        UPDATE seckill
        SET number = number-1
        WHERE seckill_id = #{seckillId}
        AND start_time <![CDATA[ <= ]]> #{killTime}
        AND end_time >= #{killTime}
        AND number > 0;
    </update>

    <!--根据id查询秒杀的商品信息-->
    <select id="queryById" resultType="Seckill" parameterType="long">
        SELECT *
        FROM seckill
        WHERE seckill_id = #{seckillId}
    </select>

    <!--根据偏移量查询秒杀商品列表
    List<Seckill> queryAll(int off, int limit);
    parameterType为多个可以不给
    按照降序对记录进行排序，可以使用 DESC 关键字-->
    <select id="queryAll" resultType="Seckill">
        SELECT *
        FROM seckill
        ORDER BY create_time DESC
        limit #{offset},#{limit}
    </select>

</mapper>

SuccessKilledDao.xml:

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="org.myseckill.dao.SuccessKilledDao">

    <insert id="insertSuccessKilled">
        <!--sql技巧1：
        当出现主键冲突时(即重复秒杀时)，会报错;
        不想让程序报错，加入ignore,返回结果0-->
        INSERT ignore INTO success_killed(seckill_id,user_phone,state)
        VALUES (#{seckillId},#{userPhone},0)
    </insert>

    <select id="queryByIdWithSeckill" resultType="SuccessKilled">
        <!--根据seckillId查询SuccessKilled对象，并携带Seckill对象-->
        <!--如何告诉mybatis把结果映射到SuccessKill属性同时映射到Seckill属性-->
        <!--可以自由控制SQL语句-->
        <!--inner join(等值连接) on 只返回两个表中联结字段相等的行-->
        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.create_time"
        FROM success_killed sk
        INNER JOIN seckill s ON sk.seckill_id = s.seckill_id
        WHERE sk.seckill_id = #{seckillId}
        AND sk.user_phone = #{userPhone}
    </select>


</mapper>

6、接下来我们开始MyBatis和Spring的整合

整合目标:
1.更少的编码:只写接口，不写实现类。
2.更少的配置:别名、配置扫描映射xml文件、dao实现。
3.足够的灵活性:自由定制SQL语句、自由传结果集自动赋值。

在resources包下创建一个spring包，里面放置spring对Dao、Service、transaction的配置文件。在浏览器中输入进入到Spring的官网中下载其pdf官方文档，在其官方文档中找到它的xml的定义内容头部:

<?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.xsd">

在spring包下创建一个spring配置dao层对象的配置文件spring-dao.xml，加入上述dtd约束，然后添加二者整合的配置，内容如下:

<?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.xsd">

    <!--配置整合mybatis过程
    1.配置数据库相关参数-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--2.数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--配置连接池属性-->
        <property name="driverClass" value="${driver}" />

        <!-- 基本属性 url、user、password -->
        <property name="jdbcUrl" value="${url}" />
        <property name="user" value="${jdbc.username}" />
        <property name="password" value="${password}" />

        <!--c3p0私有属性-->
        <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>

    <!--约定大于配置-->
    <!--spring与mybatis整合-->
    <!--３.配置SqlSessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--往下才是mybatis和spring真正整合的配置-->
        <!--注入数据库连接池-->
        <property name="dataSource" ref="dataSource"/>
        <!--配置mybatis全局配置文件:mybatis-config.xml-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!--更少的配置-别名
        扫描entity包,使用别名,多个用;隔开-->
        <property name="typeAliasesPackage" value="org.myseckill.entity"/>
        <!--更少的配置-配置扫描
        扫描sql配置文件:mapper需要的xml文件-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>

    <!--４:配置扫描Dao接口包,动态实现DAO接口,注入到spring容器-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--注入SqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--更少的配置-dao实现
        给出需要扫描的Dao接口-->
        <property name="basePackage" value="org.myseckill.dao"/>
    </bean>
</beans>

在resources包下创建jdbc.properties用于配置数据库的连接信息，内容如下:

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

基础的部分我们搭建完成了,然后要开始测试了 在IDEA里面有一个快速建立测试的快捷键Ctrl+Shift+T,在某个要测试的类里面按下这个快捷键就会出现Create new Test,然后选择你要测试的方法跟测试的工具就可以了,这里我们使用Junit作为测试

测试类SeckillDaoTest.java,内容如下:

package org.myseckill.dao;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.myseckill.entity.Seckill;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

import java.util.Date;
import java.util.List;

import static org.junit.Assert.*;

/**
 * 配置spring和junit整合，这样junit在启动时就会加载spring容器
 * @author kankan
 * @creater 2019-06-23 11:41
 */
@RunWith(SpringJUnit4ClassRunner.class)
//告诉junit Spring的配置文件
@ContextConfiguration({"classpath:spring/spring-dao.xml"})
public class SeckillDaoTest {

    @Resource
    private  SeckillDao seckillDao;//注入Dao实现类依赖

    //减库存
    @Test
    public void reduceNumber() {
        Date killTime = new Date();
        int updateCount = seckillDao.reduceNumber(1000L, killTime);
        System.out.println("updateCount=" + updateCount);
    }
    //根据id查询秒杀的商品信息
    @Test
    public void queryById() {
        long seckillId = 1000L;
        Seckill seckill = seckillDao.queryById(seckillId);
        System.out.println(seckill.getName());
        System.out.println(seckill);
    }
    //根据偏移量查询秒杀商品列表
    @Test
    public void queryAll() {
        /**
         * java没有保存形参的记录，要加上@Param让mybatis知道是哪个参数，
         * queryAll(int offset,int limit)-->queryAll(arg0，arg1)
         * SeckillDao中改为queryAll(@Param("offset")int offset,@Param("limit")int limit)
         * 用来匹配SeckillDao中的limit #{offset},#{limit}
         */
        List<Seckill> seckills = seckillDao.queryAll(0, 100);
        for(Seckill seckill : seckills){
            System.out.println(seckill);
        }
    }
}

这样才能使我们的MyBatis识别offset和limit两个参数，将Dao层方法中的这两个参数与xml映射文件中sql语句的传入参数完成映射。
经过调试，测试成功
queryAll输出：

Seckill{seckillid=1000, name='1000元秒杀iPhone6', number=100, starttime=Wed Jun 26 00:00:00 CST 2019, endtime=Thu Jun 27 00:00:00 CST 2019, createtime=Thu Jun 20 21:29:19 CST 2019}
Seckill{seckillid=1001, name='500元秒杀iPad2', number=200, starttime=Thu Jun 20 00:00:00 CST 2019, endtime=Fri Jun 21 00:00:00 CST 2019, createtime=Thu Jun 20 21:29:19 CST 2019}
Seckill{seckillid=1002, name='300元秒杀小米4', number=300, starttime=Thu Jun 20 00:00:00 CST 2019, endtime=Fri Jun 21 00:00:00 CST 2019, createtime=Thu Jun 20 21:29:19 CST 2019}
Seckill{seckillid=1003, name='200元秒杀红米note', number=400, starttime=Thu Jun 20 00:00:00 CST 2019, endtime=Fri Jun 21 00:00:00 CST 2019, createtime=Thu Jun 20 21:29:19 CST 2019}

queryById的输出：

1000元秒杀iPhone6
Seckill{seckillid=1000, name='1000元秒杀iPhone6', number=100, starttime=Wed Jun 26 00:00:00 CST 2019, endtime=Thu Jun 27 00:00:00 CST 2019, createtime=Thu Jun 20 21:29:19 CST 2019}

reduceNumber的输出：

updateCount=1

修改数据的数目为0，,该库存表的商品数量没有减少，是因为我们当前时间没有达到秒杀商品要求的时间，所以不会成功秒杀。
接下来进行SuccessKilledDao接口相关方法的测试

package org.myseckill.dao;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.myseckill.entity.SuccessKilled;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

import static org.junit.Assert.*;

/**
 * @author kankan
 * @creater 2019-06-23 14:57
 */
@RunWith(SpringJUnit4ClassRunner.class)
//告诉junit Spring的配置文件
@ContextConfiguration({"classpath:spring/spring-dao.xml"})
public class SuccessKilledDaoTest {


    @Resource
    private  SuccessKilledDao successKilledDao;//注入Dao实现类依赖

    @Test
    public void insertSuccessKilled() {
        long seckillId = 1000L;
        long userPhone = 12375319389L;
        int insertCount = successKilledDao.insertSuccessKilled(seckillId, userPhone);
        System.out.println("insertCount=" + insertCount);
    }

    @Test
    public void queryByIdWithSeckill() {
        long seckillId = 1000L;
        long userPhone = 12375319389L;
        SuccessKilled successKilled = successKilledDao.queryByIdWithSeckill(seckillId, userPhone);
        System.out.println(successKilled);
        System.out.println(successKilled.getSeckill());
    }
}

insertSuccessKilled测试输出：

insertCount=1

即我们修改了表中的一条记录，这时查看秒杀成功明细表，发现该用户的信息已经被插入。然后再次运行该测试方法，程序没有报主键异常的错，是因为我们在编写我们的明细表的时候添加了一个联合主键的字段，它保证我们明细表中的seckillId和userPhone不能重复插入，另外在SuccessDao.xml中写的插入语句的ignore关键字也保证了这点。
控制台输出再次运行的话

insertCount=0

表示没有对明细表做插入操作。
queryByIdWithSeckill输出：

SuccessKilled{seckillId=1000, userPhone=12375319389, state=0, createTime=Wed Jun 26 20:50:57 CST 2019}
Seckill{seckillid=1000, name='1000元秒杀iPhone6', number=99, starttime=Wed Jun 26 00:00:00 CST 2019, endtime=Thu Jun 27 00:00:00 CST 2019, createtime=Thu Jun 20 21:29:19 CST 2019}

运行，成功查询出我们明细表中id为1000且手机号码为12375319389的用户信息，并将表中对应的信息映射到SuccessKilled对象和Seckill对象的属性中。

到此，我们成功完成了Dao层开发及测试，接下来我们将进行Service层的开发工作