Java高并发秒杀API-Java高并发秒杀APi之业务分析与DAO层代码编写

旧城等待， 2021-12-24 05:35 280阅读 0赞

总结复习一下之前的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  u s e r i d user\_id userid，如果传入的值是id，则解析成的sql为order by id。  
（3）\#方式在很大程度上能够防止sql注入。  
（4） 方 式 无 法 防 止 s q l 注 入 。 （ 5 ） 方式无法防止sql注入。 （5） 方式无法防止sql注入。（5）方式一般用于传入数据库对象，例如传入表名。  
（6）一般能用\#的就别用KaTeX parse error: Expected 'EOF', got '\#' at position 88: …执行一个存储过程。 总结区别：\#̲\{\} 传入值时，sql解析时，…\{\}穿入值，sql解析时，参数是不带引号的。

## 初始秒杀设计 ##

### 业务分析 ###

秒杀系统业务流程如下:  
![在这里插入图片描述][20190626213016996.png]  
由图可以发现，整个系统其实是针对库存做的系统。用户成功秒杀商品，对于我们系统的操作就是:  
1.减库存。  
2.记录用户的购买明细。  
下面看看我们用户对库存的业务分析:  
![在这里插入图片描述][20190626213037173.png]  
记录用户的秒杀成功信息，我们需要记录: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继续  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]  
然后就填写你的Maven的那几个重要的坐标了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]  
再就配置你的Maven的相关信息,默认应该是配置好的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]  
之后就是点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>
                
                <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>
            
            <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.1</version>
            </dependency>
    
            
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.3.0</version>
            </dependency>
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.2.3</version>
            </dependency>
    
            
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>2.7.3</version>
            </dependency>
            
            
            <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>
    
            
            <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>
                
                <scope>provided</scope>
            </dependency>
    
            
            
            <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>
            
            <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>
            
            <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>
            
            <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*/

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][20190626210603433.png]  
还需要注意的是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">
      
    </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]，点击左边的”入门”栏框，找到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">

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]  
到我们的项目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>
            
            <setting name="useGeneratedKeys" value="true"/>
            
            <setting name="useColumnLabel" value="true"/>
    
            
            <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">

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]  
首先在src/main/resources建立com.myseckill.mapper这个包,也就是对应mapper接口文件包一样的包名,这样符合Maven的约定,就是资源放置在Resource包下,Java包下则是放置java类文件,编译后最后还是会在同一个目录下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]  
加入到两个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">
        
    
        
        <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>
    
        
        <select id="queryById" resultType="Seckill" parameterType="long">
            SELECT *
            FROM seckill
            WHERE seckill_id = #{seckillId}
        </select>
    
        
        <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">
            
            INSERT ignore INTO success_killed(seckill_id,user_phone,state)
            VALUES (#{seckillId},#{userPhone},0)
        </insert>
    
        <select id="queryByIdWithSeckill" resultType="SuccessKilled">
            
            
            
            
            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的官网][Spring]中下载其pdf官方文档，在其官方文档中找到它的xml的定义内容头部:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]  
在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">
    
        
        <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="${jdbc.username}" />
            <property name="password" value="${password}" />
    
            
            <property name="maxPoolSize" value="30"/>
            <property name="minPoolSize" value="10"/>
            
            <property name="autoCommitOnClose" value="false"/>
    
            
            <property name="checkoutTimeout" value="1000"/>
            
            <property name="acquireRetryAttempts" value="2"/>
        </bean>
    
        
        
        
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            
            
            <property name="dataSource" ref="dataSource"/>
            
            <property name="configLocation" value="classpath:mybatis-config.xml"/>
            
            <property name="typeAliasesPackage" value="org.myseckill.entity"/>
            
            <property name="mapperLocations" value="classpath:mapper/*.xml"/>
        </bean>
    
        
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
            
            <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作为测试  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]  
测试类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层的开发工作

[20190626213016996.png]: /images/20211223/5b355c510fac40d1ab75c6147ed682de.png
[20190626213037173.png]: /images/20211223/3feaf16fd00f4a349d564b0a1c82048e.png
[maven]: https://www.cnblogs.com/Silencepeng/p/7444012.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]: /images/20211223/6c152eb5e1de44cd8010739e0a6ee4e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]: /images/20211223/6ebbc3cd436a405b9c006a339a53f0e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]: /images/20211223/e98d8044ab764eeaa82a8a8b66e026f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]: /images/20211223/bab48e920ea04d9a904b553461370e67.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]: /images/20211223/4f90e00923fb4312b5af870e6288d0fd.png
[20190626210603433.png]: /images/20211223/0fddb52c69114988875d5f383e2ab718.png
[MyBatis]: http://mybatis.github.io/mybatis-3/zh/index.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]: /images/20211223/3f64d5fa96fc427f87b0a7a0e1a1645e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]: /images/20211223/dd13144b921c4984bc20581435ba54ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]: /images/20211223/9b62d15b2816449688444ad29d0df5dd.png
[Spring]: https://docs.spring.io/spring/docs/4.1.7.RELEASE/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]: /images/20211223/2b9f8f3fb23c449b8be8d2c2ce5f46cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]: /images/20211223/13a52924899340eba3680bdb09867198.png