1

zj

2025-04-17 ff2d1f5acdadc466d7e199028ef385ae8ca277e7

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
package project.miner.data.loadcache;
 
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.JdbcTemplate;
 
import kernel.bo.RecordObjectMapper;
import kernel.util.Arith;
import project.miner.MinerRedisKeys;
import project.miner.model.Miner;
import project.miner.model.MinerOrder;
import project.redis.RedisHandler;
 
public class MinerLoadCacheService {
    
    private static final Logger logger = LoggerFactory.getLogger(MinerLoadCacheService.class);
 
    protected JdbcTemplate jdbcTemplate;
    protected RedisHandler redisHandler;
 
    public void loadcache() {
        load();
        logger.info("完成Miner数据加载redis");
 
        loadMinerOrder();
        logger.info("完成MinerOrder数据加载redis");
    }
 
    public void load() {
        
        List<Miner> list = jdbcTemplate.query("SELECT * FROM T_MINER ORDER BY INVESTMENT_MIN ASC", RecordObjectMapper.newInstance(Miner.class));
 
        Map<String, Miner> cacheMap = new ConcurrentHashMap<String, Miner>();
 
        for (Miner miner : list) {
            cacheMap.put(miner.getId().toString(), miner);
            redisHandler.setSync(MinerRedisKeys.MINER_ID + miner.getId().toString(), miner);
        }
 
        redisHandler.setSync(MinerRedisKeys.MINER_MAP, cacheMap);
    }
 
    public void loadMinerOrder() {
        
        List<MinerOrder> list = jdbcTemplate.query("SELECT * FROM T_MINER_ORDER ", RecordObjectMapper.newInstance(MinerOrder.class));
 
        Map<String, Map<String, MinerOrder>> cacheMap = new ConcurrentHashMap<String, Map<String, MinerOrder>>();
        
        // 矿机总资产
        Map<String, Double> minerAssetsMap = new ConcurrentHashMap<String, Double>();
 
        for (MinerOrder minerOrder : list) {
            
            Miner miner = (Miner) this.redisHandler.get(MinerRedisKeys.MINER_ID + minerOrder.getMinerId().toString());
            if (!miner.getTest()) {
                if (cacheMap.containsKey(minerOrder.getPartyId())) {
                    Map<String, MinerOrder> map = cacheMap.get(minerOrder.getPartyId().toString());
                    map.put(minerOrder.getOrder_no(), minerOrder);
                    cacheMap.put(minerOrder.getPartyId().toString(), map);
                } else {
                    Map<String, MinerOrder> map = new ConcurrentHashMap<String, MinerOrder>();
                    map.put(minerOrder.getOrder_no(), minerOrder);
                    cacheMap.put(minerOrder.getPartyId().toString(), map);
                }
            }
            
            this.redisHandler.setSync(MinerRedisKeys.MINER_ORDER_ORDERNO + minerOrder.getOrder_no(), minerOrder);
            
            // 获取 单个订单 矿机总资产
            Double minerAssetsOrder = 0.000D;
            
            // 状态：0/正常赎回； 1/ 托管中 ；2/提前赎回 (违约)；3/取消；
            if ("1".equals(minerOrder.getState())) {
                minerAssetsOrder = minerOrder.getAmount();
            }
 
            if (minerAssetsMap.containsKey(minerOrder.getPartyId())) {
                Double minerAssetsOld = minerAssetsMap.get(minerOrder.getPartyId().toString());
                if (null == minerAssetsOld) {
                    minerAssetsOld = 0.000D;
                }
                minerAssetsOld = Arith.add(minerAssetsOld, minerAssetsOrder);
                minerAssetsMap.put(minerOrder.getPartyId().toString(), minerAssetsOld);
            } else {
                minerAssetsMap.put(minerOrder.getPartyId().toString(), minerAssetsOrder);
            }
        }
 
        for (Entry<String, Map<String, MinerOrder>> entry : cacheMap.entrySet()) {
            this.redisHandler.setSync(MinerRedisKeys.MINER_ORDER_PARTY_ID + entry.getKey(), entry.getValue());
        }
        
        for (Entry<String, Double> entry : minerAssetsMap.entrySet()) {
            this.redisHandler.setSync(MinerRedisKeys.MINER_ASSETS_PARTY_ID + entry.getKey(), entry.getValue());
        }
    }
 
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
 
    public void setRedisHandler(RedisHandler redisHandler) {
        this.redisHandler = redisHandler;
    }
 
}