package com.yami.trading.huobi.task.contract;
|
|
import cn.hutool.core.util.StrUtil;
|
import com.yami.trading.bean.contract.domain.ContractApplyOrder;
|
import com.yami.trading.bean.contract.domain.ContractOrder;
|
import com.yami.trading.bean.data.domain.Realtime;
|
import com.yami.trading.bean.item.domain.Item;
|
import com.yami.trading.common.constants.RedisKeys;
|
import com.yami.trading.common.constants.RedisLockKeyConstants;
|
import com.yami.trading.service.MarketOpenChecker;
|
import com.yami.trading.common.util.RedisUtil;
|
import com.yami.trading.common.util.ThreadUtils;
|
import com.yami.trading.service.contract.ContractApplyOrderService;
|
import com.yami.trading.service.contract.ContractLock;
|
import com.yami.trading.service.contract.ContractOrderService;
|
import com.yami.trading.service.data.DataService;
|
import com.yami.trading.service.item.ItemService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.redisson.api.RLock;
|
import org.redisson.api.RedissonClient;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Qualifier;
|
import org.springframework.stereotype.Component;
|
|
import java.math.BigDecimal;
|
import java.util.List;
|
|
/**
|
*
|
* 委托单进入市场
|
*/
|
@Slf4j
|
@Component
|
public class ContractApplyOrderHandleJob implements Runnable {
|
@Autowired
|
private ContractOrderService contractOrderService;
|
|
@Autowired
|
private ContractApplyOrderService contractApplyOrderService;
|
|
@Autowired
|
@Qualifier("dataService")
|
private DataService dataService;
|
|
@Autowired
|
private ItemService itemService;
|
|
@Autowired
|
private RedissonClient redissonClient;
|
|
public void start(){
|
new Thread(this, "ContractApplyOrderHandleJob").start();
|
log.info("委托单处理线程启动！");
|
}
|
|
@Override
|
public void run() {
|
/*
|
* 系统启动先暂停40秒
|
*/
|
ThreadUtils.sleep(1000 * 40);
|
while (true) {
|
boolean processSuccess = false;
|
String oneContractApplyOrderId = null;
|
try {
|
oneContractApplyOrderId = RedisUtil.spop(RedisKeys.NEW_CONTRACT_APPLY_ORDERS);
|
if (StrUtil.isBlank(oneContractApplyOrderId)) {
|
// finally 里面仍然会执行了 sleep
|
processSuccess = true;
|
//log.info("---> ContractApplyOrderHandleJob.run 没有可以处理的单...");
|
continue;
|
}
|
|
//log.info("---> ContractApplyOrderHandleJob.run 获取一个待处理的合约订单:{}", oneContractApplyOrderId);
|
ContractApplyOrder order = this.contractApplyOrderService.getById(oneContractApplyOrderId);
|
if (order == null || !order.getState().equals(ContractApplyOrder.STATE_SUBMITTED)) {
|
processSuccess = true;
|
continue;
|
}
|
|
List<Realtime> realtime_list = this.dataService.realtime(order.getSymbol());
|
Realtime realtime = null;
|
if (realtime_list.size() > 0) {
|
realtime = realtime_list.get(0);
|
//log.info("---> ContractApplyOrderHandleJob.run symbol:{} 的 realTime 值为:{}", order.getSymbol(), realtime);
|
} else {
|
log.warn("---> ContractApplyOrderHandleJob.run symbol:{} 的 realTime 值为空", order.getSymbol());
|
continue;
|
}
|
|
// 休市不做撮合
|
Item bySymbol = itemService.findBySymbol(order.getSymbol());
|
if (bySymbol == null) {
|
continue;
|
}
|
boolean isOpen = MarketOpenChecker.isMarketOpenByItemCloseType(bySymbol.getOpenCloseType());
|
if (!isOpen) {
|
//log.warn("---> ContractApplyOrderHandleJob.run symbol:{} 未open", order.getSymbol());
|
continue;
|
}
|
|
if ("limit".equals(order.getOrderPriceType())) {
|
/**
|
* 限价单
|
*/
|
if ("buy".equals(order.getDirection())) {
|
/**
|
* 买涨
|
*/
|
if (BigDecimal.valueOf(realtime.getClose()).compareTo(order.getPrice()) <= 0) {
|
processSuccess = this.handle(order, realtime);
|
}
|
} else {
|
/**
|
* 买跌
|
*/
|
if (BigDecimal.valueOf(realtime.getClose()).compareTo(order.getPrice()) >= 0) {
|
processSuccess = this.handle(order, realtime);
|
}
|
}
|
} else {
|
/**
|
* 非限制，直接进入市场
|
*/
|
processSuccess = this.handle(order, realtime);
|
}
|
} catch (Exception e) {
|
log.error("合约订单:{} 处理失败", oneContractApplyOrderId, e);
|
} finally {
|
if (!processSuccess) {
|
// 未处理成功，缓存加回去
|
//log.warn("合约订单:{} 处理失败，重新录入缓存", oneContractApplyOrderId);
|
RedisUtil.sadd(RedisKeys.NEW_CONTRACT_APPLY_ORDERS, oneContractApplyOrderId);
|
}
|
|
ThreadUtils.sleep(1000 * 1);
|
}
|
}
|
}
|
|
public boolean handle(ContractApplyOrder applyOrder, Realtime realtime) {
|
boolean lock = false;
|
try {
|
if (!ContractLock.add(applyOrder.getOrderNo())) {
|
return false;
|
}
|
lock = true;
|
if ("open".equals(applyOrder.getOffset())) {
|
// 全局锁
|
String lockKey = RedisLockKeyConstants.LOCK_CONTRACT_APPLY_TO_ORDER_PREFIX + applyOrder.getUuid();
|
RLock rLock = redissonClient.getLock(lockKey);
|
if (!rLock.tryLock()) {
|
return false;
|
}
|
|
try {
|
ContractApplyOrder order = this.contractApplyOrderService.getById(applyOrder.getUuid());
|
if (order == null || !order.getState().equals(ContractApplyOrder.STATE_SUBMITTED)) {
|
// 已处理，跳过
|
return true;
|
}
|
|
this.contractOrderService.saveOpen(applyOrder, realtime);
|
} finally {
|
rLock.unlock();
|
}
|
|
return true;
|
} else if ("close".equals(applyOrder.getOffset())) {
|
/**
|
* 平仓
|
*/
|
List<ContractOrder> list = this.contractOrderService.findSubmitted(applyOrder.getPartyId(),
|
applyOrder.getSymbol(), applyOrder.getDirection());
|
if (list.size() == 0) {
|
applyOrder.setVolume(BigDecimal.ZERO);
|
applyOrder.setState(ContractApplyOrder.STATE_CREATED);
|
this.contractApplyOrderService.updateById(applyOrder);
|
return true;
|
}
|
|
boolean allProcessOk = true;
|
for (int i = 0; i < list.size(); i++) {
|
ContractOrder order = list.get(i);
|
boolean lock_order = false;
|
try {
|
if (!ContractLock.add(order.getOrderNo())) {
|
allProcessOk = false;
|
continue;
|
}
|
lock_order = true;
|
applyOrder = this.contractOrderService.saveClose(applyOrder, realtime, order.getOrderNo());
|
|
if (ContractApplyOrder.STATE_CREATED.equals(applyOrder.getState())) {
|
allProcessOk = true;
|
break;
|
}
|
} catch (Exception e) {
|
allProcessOk = false;
|
log.error("---> ContractApplyOrderHandleJob.handle 处理合约:{} 报错", applyOrder.getUuid(), e);
|
} finally {
|
if (lock_order) {
|
ThreadUtils.sleep(100);
|
ContractLock.remove(order.getOrderNo());
|
}
|
}
|
}
|
|
return allProcessOk;
|
}
|
|
log.error("---> ContractApplyOrderHandleJob.handle 当前合约:{} 记录无法处理", applyOrder.getUuid());
|
return false;
|
} catch (Exception e) {
|
log.error("---> ContractApplyOrderHandleJob.handle 处理合约:{} 报错:", applyOrder.getUuid(), e);
|
|
return false;
|
} finally {
|
if (lock) {
|
ThreadUtils.sleep(100);
|
ContractLock.remove(applyOrder.getOrderNo());
|
}
|
}
|
}
|
|
}
|
