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
package com.iailab.module.model.mcs.pre.service.impl;
 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.iailab.module.model.mcs.pre.dao.MmItemOutputDao;
import com.iailab.module.model.mcs.pre.dto.MmItemOutputDTO;
import com.iailab.module.model.mcs.pre.entity.MmItemOutputEntity;
import com.iailab.module.model.mcs.pre.service.MmItemOutputService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
/**
 * @author PanZhibao
 * @date 2021年04月27日 9:22
 */
@Service
public class MmItemOutputServiceImpl extends ServiceImpl<MmItemOutputDao, MmItemOutputEntity> implements MmItemOutputService {
 
    @Autowired
    private MmItemOutputDao mmItemOutputDao;
 
    private static Map<String, MmItemOutputEntity> outputMap = new ConcurrentHashMap<>();
 
    private static Map<String, List<MmItemOutputEntity>> itemMap = new ConcurrentHashMap<>();
    
    @Override
    public void saveMmItemOutput(List<MmItemOutputEntity> mmItemOutput) {
        mmItemOutput.forEach(e -> {
            e.setId(e.getId().replace("+","").replace("-",""));
        });
        mmItemOutputDao.insert(mmItemOutput);
        // 清空缓存
        clearCache();
    }
 
    @Override
    public void update(MmItemOutputEntity mmItemOutput) {
        mmItemOutputDao.updateById(mmItemOutput);
        // 清空缓存
        clearCache();
    }
 
    public void deleteBatch(String[] itemIds) {
        QueryWrapper<MmItemOutputEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.in("itemid", itemIds);
        mmItemOutputDao.delete(queryWrapper);
        // 清空缓存
        clearCache();
    }
 
    private void clearCache() {
        outputMap.clear();
        itemMap.clear();
    }
 
    @Override
    public List<MmItemOutputEntity> getByItemid(String itemId) {
        if (itemMap.containsKey(itemId)) {
            return itemMap.get(itemId);
        }
        QueryWrapper<MmItemOutputEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("itemid", itemId).orderByAsc("outputorder");
        List<MmItemOutputEntity> list = mmItemOutputDao.selectList(queryWrapper);
        if (CollectionUtils.isEmpty(list)) {
            return null;
        }
        itemMap.put(itemId, list);
        return itemMap.get(itemId);
    }
 
    @Override
    public MmItemOutputEntity getByItemid(String itemid, String resultstr, String resultIndex) {
        QueryWrapper<MmItemOutputEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("itemid", itemid)
                .eq("resultstr", resultstr)
                .eq(StringUtils.isNotBlank(resultIndex), "result_index", resultIndex);
        return mmItemOutputDao.selectOne(queryWrapper);
    }
 
    @Override
    public List<MmItemOutputEntity> getByItemid(String itemid, String resultstr, List<Integer> resultIndexs) {
        QueryWrapper<MmItemOutputEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("itemid", itemid)
                .eq("resultstr", resultstr)
                .in(!CollectionUtils.isEmpty(resultIndexs), "result_index", resultIndexs);
        return mmItemOutputDao.selectList(queryWrapper);
    }
 
    @Override
    public void deleteByItemId(String itemId) {
        QueryWrapper<MmItemOutputEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("itemid", itemId);
        mmItemOutputDao.delete(queryWrapper);
    }
 
    @Override
    public List<MmItemOutputDTO> queryList(Map<String, Object> params) {
        return mmItemOutputDao.queryList(params);
    }
 
    @Override
    public List<String> getItemIdByOut(List<String> outIds) {
        List<String> result = new ArrayList<>();
        QueryWrapper<MmItemOutputEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.in("id", outIds);
        List<MmItemOutputEntity> list = baseMapper.selectList(queryWrapper);
        if (CollectionUtils.isEmpty(list)) {
            return result;
        }
        list.forEach(item -> {
            result.add(item.getId());
        });
        return result;
    }
 
    @Override
    public MmItemOutputEntity getOutPutById(String outputid) {
        if (outputMap.containsKey(outputid)) {
            return outputMap.get(outputid);
        }
        MmItemOutputEntity entity = mmItemOutputDao.selectById(outputid);
        if (entity != null) {
            outputMap.put(outputid, entity);
        }
        return outputMap.get(outputid);
    }
}