1

zj

2024-08-02 a7bd76dfd00efc7b03999c4559cf8554e34c19cb

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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
package project.data.internal;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
import kernel.util.DateUtils;
import project.data.DataService;
import project.data.model.Depth;
import project.data.model.Kline;
import project.data.model.Realtime;
import project.data.model.Trade;
import project.data.model.Trend;
import project.syspara.SysparaService;
 
public class DataServiceImpl implements DataService {
    
    private DataService remoteDataService;
    
    private SysparaService sysparaService;
    
    private volatile static Map<String, TimeObject> cache = new ConcurrentHashMap<String, TimeObject>();
 
    /**
     * 行情实时价格
     */
    @Override
    public List<Realtime> realtime(String symbol) {
        String key = "realtime_" + symbol;
        List<Realtime> list = new ArrayList<Realtime>();
        list = remoteDataService.realtime(symbol);
        RealtimeTimeObject realtimeTimeObject = new RealtimeTimeObject();
        realtimeTimeObject.setLastTime(new Date());
        realtimeTimeObject.setList(list);
        cache.put(key, realtimeTimeObject);
 
        return list;
    }
 
    /**
     * 分时图
     */
    @Override
    public List<Trend> trend(String symbol) {
        String key = "trend_" + symbol;
        List<Trend> list = new ArrayList<Trend>();
        TimeObject timeObject = cache.get(key);
        if (isRemote(timeObject)) {
            list = remoteDataService.trend(symbol);
            TrendTimeObject trendTimeObject = new TrendTimeObject();
            trendTimeObject.setLastTime(new Date());
            trendTimeObject.setTrend(list);
            cache.put(key, trendTimeObject);
        } else {
            list = ((TrendTimeObject) timeObject).getTrend();
        }
 
        return list;
    }
 
    /**
     * Kline
     */
    @Override
    public List<Kline> kline(String symbol, String line) {
 
        String key = "kline_" + symbol + "_" + line;
        List<Kline> list = new ArrayList<Kline>();
        TimeObject timeObject = cache.get(key);
        if (isRemote(timeObject)) {
            list = remoteDataService.kline(symbol, line);
            Collections.sort(list); // 按时间升序
            KlineTimeObject klineTimeObject = new KlineTimeObject();
            klineTimeObject.setLastTime(new Date());
            klineTimeObject.setKline(list);
            cache.put(key, klineTimeObject);
        } else {
            list = ((KlineTimeObject) timeObject).getKline();
        }
 
        return list;
 
    }
 
    /**
     * 深度数据
     */
    @Override
    public Depth depth(String symbol) {
        String key = "depth_" + symbol;
        Depth depth = new Depth();
        TimeObject timeObject = cache.get(key);
        if (isRemote(timeObject)) {
            depth = remoteDataService.depth(symbol);
            DepthTimeObject depthTimeObject = new DepthTimeObject();
            depthTimeObject.setLastTime(new Date());
            depthTimeObject.setDepth(depth);
            cache.put(key, depthTimeObject);
        } else {
            depth = ((DepthTimeObject) timeObject).getDepth();
        }
 
        return depth;
 
    }
 
    /**
     * 近期交易记录
     */
    @Override
    public Trade trade(String symbol) {
 
        String key = "trade_" + symbol;
        Trade trade = new Trade();
        TimeObject timeObject = cache.get(key);
        if (isRemote(timeObject)) {
            trade = remoteDataService.trade(symbol);
            if(trade!=null) {
                TradeTimeObject tradeTimeObject = new TradeTimeObject();
                tradeTimeObject.setLastTime(new Date());
                tradeTimeObject.put(symbol, trade.getData());
                cache.put(key, tradeTimeObject);
            }
            
        } else {
            trade = ((TradeTimeObject) timeObject).getTrade();
        }
 
        return trade;
    }
 
    private boolean isRemote(TimeObject timeObject) {
        if (timeObject == null) {
            return true;
        }
 
        /**
         * 判断是否远程 读取数据，先完成3秒过期。后期补上非开盘时间不调用。
         */
        Date timestamps = timeObject.getLastTime();
 
        /**
         * 数据超时时间
         */
        // 15秒
        //默认3秒
        double huobi_data_timeout = Double.valueOf(sysparaService.find("symbol_data_timeout").getValue());
 
        //int timeout = 3;
        
        int timeout = (int) huobi_data_timeout;
        if (DateUtils.addSecond(timestamps, timeout).before(new Date())) {
            return true;
        }
 
        return false;
    }
 
    public void setRemoteDataService(DataService remoteDataService) {
        this.remoteDataService = remoteDataService;
    }
 
    public void setSysparaService(SysparaService sysparaService) {
        this.sysparaService = sysparaService;
    }
    
 
}