Java高并发秒杀API(四)之高并发优化

1
2
3
4
5
6

	<!--添加Redis依赖 -->
	<dependency>
		<groupId>redis.clients</groupId>
		<artifactId>jedis</artifactId>
		<version>2.7.3</version>
	</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

	<!--prostuff序列化依赖 -->
	<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>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

	public class RedisDao {
		private final JedisPool jedisPool;
	
		public RedisDao(String ip, int port) {
			jedisPool = new JedisPool(ip, port);
		}
	
		private RuntimeSchema<Seckill> schema = RuntimeSchema.createFrom(Seckill.class);
	
		public Seckill getSeckill(long seckillId) {
			// redis操作逻辑
			try {
				Jedis jedis = jedisPool.getResource();
				try {
					String key = "seckill:" + seckillId;
					// 并没有实现哪部序列化操作
					// 采用自定义序列化
					// protostuff: pojo.
					byte[] bytes = jedis.get(key.getBytes());
					// 缓存重获取到
					if (bytes != null) {
						Seckill seckill = schema.newMessage();
						ProtostuffIOUtil.mergeFrom(bytes, seckill, schema);
						// seckill被反序列化
	
						return seckill;
					}
				} finally {
					jedis.close();
				}
			} catch (Exception e) {
	
			}
			return null;
		}
	
		public String putSeckill(Seckill seckill) {
			try {
				Jedis jedis = jedisPool.getResource();
				try {
					String key = "seckill:" + seckill.getSeckillId();
					byte[] bytes = ProtostuffIOUtil.toByteArray(seckill, schema,
							LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
					// 超时缓存
					int timeout = 60 * 60;// 1小时
					String result = jedis.setex(key.getBytes(), timeout, bytes);
	
					return result;
				} finally {
					jedis.close();
				}
			} catch (Exception e) {
	
			}
	
			return null;
		}
	}

1
2
3
4
5

	<!--redisDao -->
	<bean id="redisDao" class="com.lewis.dao.cache.RedisDao">
		<constructor-arg index="0" value="localhost" />
		<constructor-arg index="1" value="6379" />
	</bean>

1
2

	 @Autowired
	 private RedisDao redisDao;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

	public Exposer exportSeckillUrl(long seckillId) {
		// 优化点:缓存优化:超时的基础上维护一致性
		// 1.访问redis

		Seckill seckill = redisDao.getSeckill(seckillId);
		if (seckill == null) {
			// 2.访问数据库
			seckill = seckillDao.queryById(seckillId);
			if (seckill == null) {// 说明查不到这个秒杀产品的记录
				return new Exposer(false, seckillId);
			} else {
				// 3.放入redis
				redisDao.putSeckill(seckill);
			}
		}

		// 若是秒杀未开启
		Date startTime = seckill.getStartTime();
		Date endTime = seckill.getEndTime();
		// 系统当前时间
		Date nowTime = new Date();
		if (startTime.getTime() > nowTime.getTime() || endTime.getTime() < nowTime.getTime()) {
			return new Exposer(false, seckillId, nowTime.getTime(), startTime.getTime(), endTime.getTime());
		}

		// 秒杀开启，返回秒杀商品的id、用给接口加密的md5
		String md5 = getMD5(seckillId);
		return new Exposer(true, md5, seckillId);
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

	@RunWith(SpringJUnit4ClassRunner.class)
	// 告诉junit spring的配置文件
	@ContextConfiguration({ "classpath:spring/spring-dao.xml" })
	public class RedisDaoTest {
		private final Logger logger = LoggerFactory.getLogger(this.getClass());
	
		private long id = 1001;
	
		@Autowired
		private RedisDao redisDao;
	
		@Autowired
		private SeckillDao seckillDao;
	
		@Test
		public void testSeckill() {
	
			Seckill seckill = redisDao.getSeckill(id);
			if (seckill == null) {
				seckill = seckillDao.queryById(id);
				if (seckill != null) {
					String result = redisDao.putSeckill(seckill);
					logger.info("result={}", result);
					seckill = redisDao.getSeckill(id);
					logger.info("seckill={}", seckill);
				}
			}
		}
	
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

	public SeckillExecution executeSeckill(long seckillId, long userPhone, String md5) throws SeckillException,
			RepeatKillException, SeckillCloseException {

		if (md5 == null || !md5.equals(getMD5(seckillId))) {
			throw new SeckillException("seckill data rewrite");// 秒杀数据被重写了
		}
		// 执行秒杀逻辑:减库存+增加购买明细
		Date nowTime = new Date();

		try {

			// 否则更新了库存，秒杀成功,增加明细
			int insertCount = successKilledDao.insertSuccessKilled(seckillId, userPhone);
			// 看是否该明细被重复插入，即用户是否重复秒杀
			if (insertCount <= 0) {
				throw new RepeatKillException("seckill repeated");
			} else {

				// 减库存,热点商品竞争
				int updateCount = seckillDao.reduceNumber(seckillId, nowTime);
				if (updateCount <= 0) {
					// 没有更新库存记录，说明秒杀结束 rollback
					throw new SeckillCloseException("seckill is closed");
				} else {
					// 秒杀成功,得到成功插入的明细记录,并返回成功秒杀的信息 commit
					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());
		}

	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

	-- 秒杀执行储存过程
	DELIMITER $$ -- 将定界符从;转换为$$
	-- 定义储存过程
	-- 参数： in输入参数   out输出参数
	-- row_count() 返回上一条修改类型sql(delete,insert,update)的影响行数
	-- row_count:0:未修改数据 ; >0:表示修改的行数； <0:sql错误
	CREATE PROCEDURE `seckill`.`execute_seckill`
	  (IN v_seckill_id BIGINT, IN v_phone BIGINT,
	   IN v_kill_time  TIMESTAMP, OUT r_result INT)
	  BEGIN
	    DECLARE insert_count INT DEFAULT 0;
	    START TRANSACTION;
	    INSERT IGNORE INTO success_killed
	    (seckill_id, user_phone, state)
	    VALUES (v_seckill_id, v_phone, 0);
	    SELECT row_count() INTO insert_count;
	    IF (insert_count = 0) THEN
	      ROLLBACK;
	      SET r_result = -1;
	    ELSEIF (insert_count < 0) THEN
	        ROLLBACK;
	        SET r_result = -2;
	    ELSE
	      UPDATE seckill
	      SET number = number - 1
	      WHERE seckill_id = v_seckill_id
	            AND end_time > v_kill_time
	            AND start_time < v_kill_time
	            AND number > 0;
	      SELECT row_count() INTO insert_count;
	      IF (insert_count = 0) THEN
	        ROLLBACK;
	        SET r_result = 0;
	      ELSEIF (insert_count < 0) THEN
	          ROLLBACK;
	          SET r_result = -2;
	      ELSE
	        COMMIT;
	        SET r_result = 1;
	      END IF;
	    END IF;
	  END;
	$$
	-- 储存过程定义结束
	-- 将定界符重新改为;
	DELIMITER ;

	-- 定义一个用户变量r_result
	SET @r_result = -3;
	-- 执行储存过程
	CALL execute_seckill(1003, 13502178891, now(), @r_result);
	-- 获取结果
	SELECT @r_result;

1

	CREATE PROCEDURE `seckill`.`execute_seckill`

1

	CREATE PROCEDURE `execute_seckill`

1
2
3
4
5

	/**
     *  使用储存过程执行秒杀
     * @param paramMap
     */
    void killByProcedure(Map<String,Object> paramMap);

1
2
3
4
5
6
7
8
9

	<!--调用储存过程 -->
	<select id="killByProcedure" statementType="CALLABLE">
		CALL execute_seckill(
			#{seckillId,jdbcType=BIGINT,mode=IN},
			#{phone,jdbcType=BIGINT,mode=IN},
			#{killTime,jdbcType=TIMESTAMP,mode=IN},
			#{result,jdbcType=INTEGER,mode=OUT}
		)
	</select>

1
2
3
4
5
6
7
8
9

	/**
	 * 调用存储过程来执行秒杀操作，不需要抛出异常
	 * 
	 * @param seckillId 秒杀的商品ID
	 * @param userPhone 手机号码
	 * @param md5 md5加密值
	 * @return 根据不同的结果返回不同的实体信息
	 */
	SeckillExecution executeSeckillProcedure(long seckillId,long userPhone,String md5);

1
2
3
4
5
6

	<!--导入apache工具类-->
    <dependency>
        <groupId>commons-collections</groupId>
        <artifactId>commons-collections</artifactId>
        <version>3.2.2</version>
    </dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

	@Override
	public SeckillExecution executeSeckillProcedure(long seckillId, long userPhone, String md5) {
		if (md5 == null || !md5.equals(getMD5(seckillId))) {
			return new SeckillExecution(seckillId, SeckillStatEnum.DATE_REWRITE);
		}
		Date killTime = new Date();
		Map<String, Object> map = new HashMap<>();
		map.put("seckillId", seckillId);
		map.put("phone", userPhone);
		map.put("killTime", killTime);
		map.put("result", null);
		// 执行储存过程,result被复制
		seckillDao.killByProcedure(map);
		// 获取result
		int result = MapUtils.getInteger(map, "result", -2);
		if (result == 1) {
			SuccessKilled successKilled = successKilledDao.queryByIdWithSeckill(seckillId, userPhone);
			return new SeckillExecution(seckillId, SeckillStatEnum.SUCCESS, successKilled);
		} else {
			return new SeckillExecution(seckillId, SeckillStatEnum.stateOf(result));
		}
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

	@Test
	public void executeSeckillProcedure(){
		long seckillId = 1001;
        long phone = 13680115101L;
        Exposer exposer = seckillService.exportSeckillUrl(seckillId);
        if (exposer.isExposed()) {
            String md5 = exposer.getMd5();
            SeckillExecution execution = seckillService.executeSeckillProcedure(seckillId, phone, md5);
            logger.info("execution={}", execution);
        }
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

	    @RequestMapping(value = "/{seckillId}/{md5}/execution",
	            method = RequestMethod.POST,
	            produces = {"application/json;charset=UTF-8"})
	    @ResponseBody
	    public SeckillResult<SeckillExecution> execute(@PathVariable("seckillId") Long seckillId,
	                                                   @PathVariable("md5") String md5,
	                                                   @CookieValue(value = "userPhone",required = false) Long userPhone)
	    {
	        if (userPhone==null)
	        {
	            return new SeckillResult<SeckillExecution>(false,"未注册");
	        }
	
	        try {
	        	//这里改为调用存储过程
	//            SeckillExecution execution = seckillService.executeSeckill(seckillId, userPhone, md5);
	            SeckillExecution execution = seckillService.executeSeckillProcedure(seckillId, userPhone, md5);
	            return new SeckillResult<SeckillExecution>(true, execution);
	        }catch (RepeatKillException e1)
	        {
	            SeckillExecution execution=new SeckillExecution(seckillId, SeckillStatEnum.REPEAT_KILL);
	            return new SeckillResult<SeckillExecution>(true,execution);
	        }catch (SeckillCloseException e2)
	        {
	            SeckillExecution execution=new SeckillExecution(seckillId, SeckillStatEnum.END);
	            return new SeckillResult<SeckillExecution>(true,execution);
	        }
	        catch (Exception e)
	        {
	            SeckillExecution execution=new SeckillExecution(seckillId, SeckillStatEnum.INNER_ERROR);
	            return new SeckillResult<SeckillExecution>(true,execution);
	        }
	    }