目录
1.首先简历数据库，在main包下的sql包中创建数据库初始化脚本，相关表的sql语句如下：
4.接下来基于MyBatis来实现我们之前设计的Dao层接口
5、mybatis为我们提供了mapper动态代理开发的方式为我们自动实现Dao的接口。
初始秒杀设计
业务分析
秒杀系统业务流程如下：
由图可以发现，整个系统其实是针对库存做的系统。用户成功秒杀商品，对于我们系统的操作就是:
1.减库存。
2.记录用户的购买明细。
下面看看我们用户对库存的业务分析:
记录用户的秒杀成功信息，我们需要记录:1.谁购买成功了。2.购买成功的时间/有效期。这些数据组成了用户的秒杀成功信息，也就是用户的购买行为。
为什么我们的系统需要事务?
- 1.若是用户成功秒杀商品我们记录了其购买明细却没有减库存。导致商品的超卖。
- 2.减了库存却没有记录用户的购买明细。导致商品的少卖。对于上述两个故障，若是没有事务的支持，损失最大的无疑是我们的用户和商家。在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中进行创建
配置pom.xml
<?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*/
修改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语句时，遇到特殊字符时，如：< 等，建议使用
<!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>
注：上面的s.seckill_id “seckill.seckill_id”表示s.seckill_id这一列的数据是Success_killed实体类里的seckill属性里的seckill_id属性，是一个级联的过程，使用的就是别名只是忽略了as关键字，别名要加上双引号。
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，,该库存表的商品数量没有减少，是因为我们当前时间没有达到秒杀商品要求的时间，所以不会成功秒杀。
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层的开发工作
扫一扫
3149
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
