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
package data.loadcache;
 
import java.util.Iterator;
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 kernel.web.ApplicationUtil;
import project.item.ItemRedisKeys;
import project.item.model.Item;
import project.item.model.ItemLever;
import project.item.model.ItemUserOptional;
import project.redis.RedisHandler;
 
public class ItemLoadCacheService {
    
    private RedisHandler redisHandler;
 
    private Logger logger = LoggerFactory.getLogger(ItemLoadCacheService.class); 
    
    public void loadcache() {
        loadItem();
        loadItemLever();
        loadItemUserOptional();
        logger.info("完成Item数据加载redis");
    }
 
    private void loadItem() {
        Map<String, Item> cache = new ConcurrentHashMap<String, Item>();
        List<Item> list=ApplicationUtil.executeSelect(Item.class);
        for (int i = 0; i < list.size(); i++) {
            Item item = list.get(i);
            redisHandler.setSync(ItemRedisKeys.ITEM_SYMBOL + item.getSymbol(), item);
            cache.put(list.get(i).getSymbol(), item);
        }
        redisHandler.setSync(ItemRedisKeys.ITEM_MAP, cache);
    }
 
    private void loadItemLever() {
        List<ItemLever> list=ApplicationUtil.executeSelect(ItemLever.class);
        Map<String, Map<String, ItemLever>> lever_map = new ConcurrentHashMap<String, Map<String, ItemLever>>();
        for (int i = 0; i < list.size(); i++) {
            ItemLever itemLever = list.get(i);
            Map<String, ItemLever> lever_list = lever_map.get(itemLever.getItem_id());
            if (lever_list == null) {
                lever_list = new ConcurrentHashMap<String, ItemLever>();
            }
            lever_list.put(itemLever.getId().toString(), itemLever);
            lever_map.put(itemLever.getItem_id(), lever_list);
 
        }
 
        Map<String, Object> params = new ConcurrentHashMap<String, Object>();
        Iterator<Entry<String, Map<String, ItemLever>>> it = lever_map.entrySet().iterator();
        while (it.hasNext()) {
            Entry<String, Map<String, ItemLever>> entry = it.next();
            params.put(ItemRedisKeys.ITEM_LEVER_ID + entry.getKey(), entry.getValue());
        }
        redisHandler.setBatchSync(params);
 
    }
 
    public void loadItemUserOptional() {
        Map<String, Map<String, ItemUserOptional>> cacheMap = new ConcurrentHashMap<String, Map<String, ItemUserOptional>>();
        List<ItemUserOptional> list=ApplicationUtil.executeSelect(ItemUserOptional.class);
        for (ItemUserOptional entity : list) {
            if (cacheMap.containsKey(entity.getPartyId())) {
                Map<String, ItemUserOptional> map = cacheMap.get(entity.getPartyId().toString());
                map.put(entity.getSymbol(), entity);
                cacheMap.put(entity.getPartyId().toString(), map);
            } else {
                Map<String, ItemUserOptional> map = new ConcurrentHashMap<String, ItemUserOptional>();
                map.put(entity.getSymbol(), entity);
                cacheMap.put(entity.getPartyId().toString(), map);
            }
        }
 
        for (Entry<String, Map<String, ItemUserOptional>> entry : cacheMap.entrySet()) {
            redisHandler.setSync(ItemRedisKeys.ITEM_USER_OPTIONAL_MAP_PARTY_ID + entry.getKey(), entry.getValue());
        }
    }
 
    public void setRedisHandler(RedisHandler redisHandler) {
        this.redisHandler = redisHandler;
    }
}