lyh
2025-07-03 2a30092c6e1efa28b5ca29a1b518356a08b4044c
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
package org.jeecg.modules.system.aspect;
 
import cn.hutool.core.util.ArrayUtil;
 
import java.util.*;
import java.util.function.BiConsumer;
 
/**
 * 批量查询器
 */
public class FieldBatchQuery {
 
    // key=查询要素=table+paramName, value=查询条件
    private Map<String, QueryParam> queryBatch = new HashMap<>();
 
    /**
     * 便利查询要素
     * @param action
     */
    public void forEach(BiConsumer<? super String, ? super QueryParam> action) {
        this.queryBatch.forEach(action);
    }
 
    /**
     * 查询表数量
     * @return
     */
    public int size() {
        return queryBatch.size();
    }
 
    /**
     * 查找查询结果
     * @param tableName
     * @param paramName
     * @param paramValue
     * @param column
     * @return
     */
    public Object findResult(String tableName, String[] paramName, String[] paramValue, String column) {
        String queryKey = tableName + "()" + ArrayUtil.join(paramName, ",");
        if(!this.queryBatch.containsKey(queryKey)) return null;
 
        return this.queryBatch.get(queryKey).findResult(paramValue, column);
    }
 
    /**
     * 保存查询条件
     * @param tableName 查询表名
     * @param textName 查询字段名称
     * @param paramName 查询参数名称
     * @param paramValue 查询参数值
     */
    public void put(String tableName, String textName, String[] paramName, String[] paramValue) {
        String queryKey = tableName + "()" + ArrayUtil.join(paramName, ",");
 
        QueryParam queryParams;
        if(this.queryBatch.containsKey(queryKey)){
            queryParams = this.queryBatch.get(queryKey);
        }else{
            queryParams = new QueryParam(tableName, paramName);
            this.queryBatch.put(queryKey, queryParams);
        }
 
        // 添加查询结果column名称
        queryParams.addTextName(textName);
        // 添加查询参数
        queryParams.addParamValue(paramValue);
    }
 
    public static class QueryParam {
        private String queryTable;
        private Set<String> columns = new HashSet<>();
        private Set<String> paramValueSet = new HashSet<>();
        private String[] paramName;
        private List<Map> queryResult = new ArrayList<>();
        private Map<String, Integer> resultIndex = new HashMap<>();
 
        public QueryParam(String tableName, String[] column) {
            this.queryTable = tableName;
            this.paramName = column;
        }
 
        public void addTextName(String textName) {
            this.columns.add(textName);
        }
 
        public void addParamValue(String[] paramValue) {
            paramValueSet.add(ArrayUtil.join(paramValue, ","));
        }
 
        public String getQueryTable() {
            return queryTable;
        }
 
        public String[] getColumns() {
            String[] ret = new String[this.columns.size()];
            this.columns.toArray(ret);
            return ret;
        }
 
        public String getParamName() {
            return "concat(" + ArrayUtil.join(this.paramName, ",',',") + ")";
        }
 
        public String[] getParamValues() {
            String[] ret = new String[this.paramValueSet.size()];
            this.paramValueSet.toArray(ret);
            return ret;
        }
 
        public void setQueryResult(List<Map> queryResult) {
            this.queryResult = queryResult;
        }
 
        public Object findResult(String[] paramValue, String column) {
            if(paramValue == null) return null;
            String value = ArrayUtil.join(paramValue, ",");
 
            if(this.resultIndex.containsKey(value)){
                return this.queryResult.get(this.resultIndex.get(value)).get(column);
            }
 
            for (int i = 0; i < this.queryResult.size(); i++) {
                Map<String, Object> map = queryResult.get(i);
                if(value.equals(map.get("paramValue"))){
                    this.resultIndex.put(value, i);
                    return map.get(column);
                }
            }
 
            return null;
        }
    }
}