Helius
2020-07-14 82cfdb0996309fcb708e35da37d2435e4785ff22
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
package com.xcong.excoin.rabbit.pricequeue;
 
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.PriorityBlockingQueue;
 
/**
 * 处理消费者的订单止盈等价格信息
 */
@Slf4j
public class OrderOperatePriceService {
 
    /**
     * 处理用户提交的止盈止损价格 爆仓 限价委托
     *
     * @param orderModel
     */
    public static void dealWithNewMq(OrderModel orderModel) {
        // 根据不同的类型将价格信息加入到对应队列和MAP
        // 【1:买入委托2:开多3:开空4:平多5:平空6:爆仓平多7:爆仓平空8:撤单9:止盈平多10:止盈平空11:止损平多12:止损平空】
        int type = orderModel.getType();
        Map<String, List<OrderModel>> orderMap = PricePriorityQueue.getOrderMap(orderModel.getSymbol(), type);
        if (type == 12 || type == 9 || type == 7 || type == 3) {
            // 需要价格涨的
            PriorityBlockingQueue<AscBigDecimal> queue = PricePriorityQueue.getQueueAsc(orderModel.getSymbol());
            dealPriceAsc(orderModel, orderMap, queue);
        } else {
            // 需要价格跌的
            PriorityBlockingQueue<DescBigDecimal> queue = PricePriorityQueue.getQueueDesc(orderModel.getSymbol());
            dealPriceDesc(orderModel, orderMap, queue);
        }
 
    }
 
    /**
     * 倒叙的添加价格和订单
     *
     * @param orderMap
     * @param queue
     */
    public static void dealPriceDesc(OrderModel order, Map<String, List<OrderModel>> orderMap, PriorityBlockingQueue<DescBigDecimal> queue) {
        // 添加币种的价格和价格订单信息
        String price = order.getPrice();
        int type = order.getType();
        Long orderId = order.getOrderId();
        queue.add(new DescBigDecimal(price));
 
        log.info("原有:{}", JSONObject.toJSONString(orderMap));
        removeExistOrder(type, orderId, orderMap);
        log.info("删除后:{}", JSONObject.toJSONString(orderMap));
        if (orderMap.containsKey(price)) {
            // 有这个价的key
            List<OrderModel> list = orderMap.get(price);
            // 判断这个单的这个类型是否有
            if (CollectionUtils.isNotEmpty(list)) {
                // 新增
                OrderModel orderModel = new OrderModel(orderId, type, price, null,order.getOperateNo());
                list.add(orderModel);
            }
        } else {
            List<OrderModel> list = new ArrayList<OrderModel>();
            OrderModel orderModel = new OrderModel(orderId, type, price, null,order.getOperateNo());
            list.add(orderModel);
            orderMap.put(price, list);
        }
        log.info("调整后:{}", JSONObject.toJSONString(orderMap));
    }
 
 
    /**
     * 正序的添加价格和订单
     *
     * @param orderMap
     * @param queue
     */
    public static void dealPriceAsc(OrderModel order, Map<String, List<OrderModel>> orderMap, PriorityBlockingQueue<AscBigDecimal> queue) {
        // 添加币种的价格和价格订单信息
        String price = order.getPrice();
        int type = order.getType();
        Long orderId = order.getOrderId();
        queue.add(new AscBigDecimal(price));
        log.info("原有:{}", JSONObject.toJSONString(orderMap));
        // 需要找到这个订单的原始的单进行处理
        removeExistOrder(type, orderId, orderMap);
        log.info("删除后:{}", JSONObject.toJSONString(orderMap));
        if (orderMap.containsKey(price)) {
            // 有这个价的key
            List<OrderModel> list = orderMap.get(price);
            // 判断这个单的这个类型是否有
            if (CollectionUtils.isNotEmpty(list)) {
                // 新增
                OrderModel orderModel = new OrderModel(orderId, type, price, null,order.getOperateNo());
                list.add(orderModel);
            }
        } else {
            List<OrderModel> list = new ArrayList<OrderModel>();
            OrderModel orderModel = new OrderModel(orderId, type, price, null,order.getOperateNo());
            list.add(orderModel);
            orderMap.put(price, list);
        }
        log.info("调整后:{}", JSONObject.toJSONString(orderMap));
    }
 
    private static void removeExistOrder(Integer type, Long orderId, Map<String, List<OrderModel>> orderMap) {
        // 需要找到这个订单的原始的单进行处理
        boolean breakFlag = false;
        for (Map.Entry<String, List<OrderModel>> entry : orderMap.entrySet()) {
            List<OrderModel> value = entry.getValue();
            if (CollectionUtils.isNotEmpty(value)) {
                Iterator<OrderModel> iterator = value.iterator();
                if (iterator.hasNext()) {
                    OrderModel next = iterator.next();
                    if (next.getType().equals(type)  && orderId.equals(next.getOrderId())) {
                        // 移除这个
                        System.out.println("存在相同的平仓类型,删除原来的:"+next.getOrderId()+",价格:"+next.getPrice());
                        iterator.remove();
                        break;
 
                    }
                }
 
            }
        }
    }
 
}