package com.hqs.flashsales.controller;

import com.hqs.flashsales.annotation.DistriLimitAnno;
import com.hqs.flashsales.aspect.LimitAspect;
import com.hqs.flashsales.lock.DistributedLock;
import com.hqs.flashsales.limit.DistributedLimit;
import com.hqs.flashsales.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import java.util.Collections;


/**
* @author huangqingshi
* @Date 2019-01-23
*/
@Slf4j
@Controller
public class FlashSaleController {

@Autowired
OrderService orderService;
@Autowired
DistributedLock distributedLock;
@Autowired
LimitAspect limitAspect;
//注意RedisTemplate用的String,String，后续所有用到的key和value都是String的
@Autowired
RedisTemplate<String, String> redisTemplate;

private static final String LOCK_PRE = "LOCK_ORDER";

@PostMapping("/initCatalog")
@ResponseBody
public String initCatalog() {
try {
orderService.initCatalog();
} catch (Exception e) {
log.error("error", e);
}

return "init is ok";
}

@PostMapping("/placeOrder")
@ResponseBody
@DistriLimitAnno(limitKey = "limit", limit = 100, seconds = "1")
public Long placeOrder(Long orderId) {
Long saleOrderId = 0L;
boolean locked = false;
String key = LOCK_PRE + orderId;
String uuid = String.valueOf(orderId);
try {
locked = distributedLock.distributedLock(key, uuid,
"10" );
if(locked) {
//直接操作数据库
// saleOrderId = orderService.placeOrder(orderId);
//操作缓存 异步操作数据库
saleOrderId = orderService.placeOrderWithQueue(orderId);
}
log.info("saleOrderId:{}", saleOrderId);
} catch (Exception e) {
log.error(e.getMessage());
} finally {
if(locked) {
distributedLock.distributedUnlock(key, uuid);
}
}
return saleOrderId;
}

}

-- bucket name
local key = KEYS[1]
-- token generate interval
local intervalPerPermit = tonumber(ARGV[1])
-- grant timestamp
local refillTime = tonumber(ARGV[2])
-- limit token count
local limit = tonumber(ARGV[3])
-- ratelimit time period
local interval = tonumber(ARGV[4])

local counter = redis.call('hgetall', key)

if table.getn(counter) == 0 then
-- first check if bucket not exists, if yes, create a new one with full capacity, then grant access
redis.call('hmset', key, 'lastRefillTime', refillTime, 'tokensRemaining', limit - 1)
-- expire will save memory
redis.call('expire', key, interval)
return 1
elseif table.getn(counter) == 4 then
-- if bucket exists, first we try to refill the token bucket
local lastRefillTime, tokensRemaining = tonumber(counter[2]), tonumber(counter[4])
local currentTokens
if refillTime > lastRefillTime then
-- check if refillTime larger than lastRefillTime.
-- if not, it means some other operation later than this call made the call first.
-- there is no need to refill the tokens.
local intervalSinceLast = refillTime - lastRefillTime
if intervalSinceLast > interval then
currentTokens = limit
redis.call('hset', key, 'lastRefillTime', refillTime)
else
local grantedTokens = math.floor(intervalSinceLast / intervalPerPermit)
if grantedTokens > 0 then
-- ajust lastRefillTime, we want shift left the refill time.
local padMillis = math.fmod(intervalSinceLast, intervalPerPermit)
redis.call('hset', key, 'lastRefillTime', refillTime - padMillis)
end
currentTokens = math.min(grantedTokens + tokensRemaining, limit)
end
else
-- if not, it means some other operation later than this call made the call first.
-- there is no need to refill the tokens.
currentTokens = tokensRemaining
end

assert(currentTokens >= 0)

if currentTokens == 0 then
-- we didn't consume any keys
redis.call('hset', key, 'tokensRemaining', currentTokens)
return 0
else
-- we take 1 token from the bucket
redis.call('hset', key, 'tokensRemaining', currentTokens - 1)
return 1
end
else
error("Size of counter is " .. table.getn(counter) .. ", Should Be 0 or 4.")
end

public Boolean distributedRateLimit(String key, String limit, String seconds) {
Long id = 0L;
long intervalInMills = Long.valueOf(seconds) * 1000;
long limitInLong = Long.valueOf(limit);
long intervalPerPermit = intervalInMills / limitInLong;
// Long refillTime = System.currentTimeMillis();
// log.info("调用redis执行lua脚本, {} {} {} {} {}", "ratelimit", intervalPerPermit, refillTime,
// limit, intervalInMills);
try {
id = redisTemplate.execute(rateLimitScript, Collections.singletonList(key),
String.valueOf(intervalPerPermit), String.valueOf(System.currentTimeMillis()),
String.valueOf(limitInLong), String.valueOf(intervalInMills));
} catch (Exception e) {
log.error("error", e);
}

if(id == 0L) {
return false;
} else {
return true;
}
}

CREATE TABLE `catalog` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(50) NOT NULL DEFAULT '' COMMENT '名称',
`total` int(11) NOT NULL COMMENT '库存',
`sold` int(11) NOT NULL COMMENT '已售',
`version` int(11) NULL COMMENT '乐观锁，版本号',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `sales_order` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`cid` int(11) NOT NULL COMMENT '库存ID',
`name` varchar(30) NOT NULL DEFAULT '' COMMENT '商品名称',
`create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

@Override
public void initCatalog() {
Catalog catalog = new Catalog();
catalog.setName("mac");
catalog.setTotal(1000L);
catalog.setSold(0L);
catalogMapper.insertCatalog(catalog);
log.info("catalog:{}", catalog);
redisTemplate.opsForValue().set(CATALOG_TOTAL + catalog.getId(), catalog.getTotal().toString());
redisTemplate.opsForValue().set(CATALOG_SOLD + catalog.getId(), catalog.getSold().toString());
log.info("redis value:{}", redisTemplate.opsForValue().get(CATALOG_TOTAL + catalog.getId()));
handleCatalog();
}

package com.hqs.flashsales;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;

import java.util.concurrent.TimeUnit;

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = FlashsalesApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class FlashSalesApplicationTests {

@Autowired
private TestRestTemplate testRestTemplate;

@Test
public void flashsaleTest() {
String url = "http://localhost:8080/placeOrder";
for(int i = 0; i < 3000; i++) {
try {
TimeUnit.MILLISECONDS.sleep(20);
new Thread(() -> {
MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
params.add("orderId", "1");
Long result = testRestTemplate.postForObject(url, params, Long.class);
if(result != 0) {
System.out.println("-------------" + result);
}
}
).start();
} catch (Exception e) {
log.info("error:{}", e.getMessage());
}

}
}

@Test
public void contextLoads() {
}

}