dnc Module error fix

yangys

2024-03-29 153cc3fd4ef015a8b1390b2eef3d102c5859a5e7

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
package com.qianwen.core.cache.utils;
 
import java.lang.reflect.Field;
import java.util.List;
import java.util.concurrent.Callable;
import com.qianwen.core.secure.utils.AuthUtil;
import com.qianwen.core.tool.utils.ClassUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.ObjectUtil;
import com.qianwen.core.tool.utils.ReflectUtil;
import com.qianwen.core.tool.utils.SpringUtil;
import com.qianwen.core.tool.utils.StringUtil;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.lang.Nullable;
 
/* loaded from: blade-starter-cache-9.3.0.0-SNAPSHOT.jar:org/springblade/core/cache/utils/CacheUtil.class */
public class CacheUtil {
    private static CacheManager cacheManager;
    private static final Boolean TENANT_MODE = Boolean.TRUE;
 
    private static CacheManager getCacheManager() {
        if (cacheManager == null) {
            cacheManager = (CacheManager) SpringUtil.getBean(CacheManager.class);
        }
        return cacheManager;
    }
 
    public static Cache getCache(String cacheName) {
        return getCache(cacheName, TENANT_MODE);
    }
 
    public static Cache getCache(String cacheName, Boolean tenantMode) {
        return getCacheManager().getCache(formatCacheName(cacheName, tenantMode));
    }
 
    public static Cache getCache(String cacheName, String tenantId) {
        return getCacheManager().getCache(formatCacheName(cacheName, tenantId));
    }
 
    public static String formatCacheName(String cacheName, Boolean tenantMode) {
        if (!tenantMode.booleanValue()) {
            return cacheName;
        }
        return formatCacheName(cacheName, AuthUtil.getTenantId());
    }
 
    public static String formatCacheName(String cacheName, String tenantId) {
        return StringUtil.isBlank(tenantId) ? cacheName : tenantId.concat(":").concat(cacheName);
    }
 
    @Nullable
    public static Object get(String cacheName, String keyPrefix, Object key) {
        return get(cacheName, keyPrefix, key, TENANT_MODE);
    }
 
    @Nullable
    public static Object get(String cacheName, String keyPrefix, Object key, Boolean tenantMode) {
        if (Func.hasEmpty(new Object[]{cacheName, keyPrefix, key})) {
            return null;
        }
        Cache.ValueWrapper valueWrapper = getCache(cacheName, tenantMode).get(keyPrefix.concat(String.valueOf(key)));
        if (Func.isEmpty(valueWrapper)) {
            return null;
        }
        return valueWrapper.get();
    }
 
    @Nullable
    public static <T> T get(String cacheName, String keyPrefix, Object key, @Nullable Class<T> type) {
        return (T) get(cacheName, keyPrefix, key, type, TENANT_MODE);
    }
 
    @Nullable
    public static <T> T get(String cacheName, String keyPrefix, Object key, @Nullable Class<T> type, Boolean tenantMode) {
        if (Func.hasEmpty(new Object[]{cacheName, keyPrefix, key})) {
            return null;
        }
        return (T) getCache(cacheName, tenantMode).get(keyPrefix.concat(String.valueOf(key)), type);
    }
 
    @Nullable
    public static <T> T get(String cacheName, String keyPrefix, Object key, Callable<T> valueLoader) {
        return (T) get(cacheName, keyPrefix, key, valueLoader, TENANT_MODE);
    }
 
    /* JADX WARN: Multi-variable type inference failed */
    @Nullable
    public static <T> T get(String cacheName, String keyPrefix, Object key, Callable<T> valueLoader, Boolean tenantMode) {
        if (Func.hasEmpty(new Object[]{cacheName, keyPrefix, key})) {
            return null;
        }
        try {
            Cache.ValueWrapper valueWrapper = getCache(cacheName, tenantMode).get(keyPrefix.concat(String.valueOf(key)));
            //T t = null;
            Object value = null;
            if (valueWrapper == null) {
                T call = valueLoader.call();
                if (ObjectUtil.isNotEmpty(call)) {
                    Field field = ReflectUtil.getField(call.getClass(), "id");
                    if (ObjectUtil.isNotEmpty(field) && ObjectUtil.isEmpty(ClassUtil.getMethod(call.getClass(), "getId", new Class[0]).invoke(call, new Object[0]))) {
                        return null;
                    }
                    getCache(cacheName, tenantMode).put(keyPrefix.concat(String.valueOf(key)), call);
                    value = call;
                }
            } else {
                
                value = valueWrapper.get();
            }
            return (T)value;
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }
 
    public static void put(String cacheName, String keyPrefix, Object key, @Nullable Object value) {
        put(cacheName, keyPrefix, key, value, TENANT_MODE);
    }
 
    public static void put(String cacheName, String keyPrefix, Object key, @Nullable Object value, Boolean tenantMode) {
        getCache(cacheName, tenantMode).put(keyPrefix.concat(String.valueOf(key)), value);
    }
 
    public static void evict(String cacheName, String keyPrefix, Object key) {
        evict(cacheName, keyPrefix, key, TENANT_MODE);
    }
 
    public static void evict(String cacheName, String keyPrefix, Object key, Boolean tenantMode) {
        if (Func.hasEmpty(new Object[]{cacheName, keyPrefix, key})) {
            return;
        }
        getCache(cacheName, tenantMode).evict(keyPrefix.concat(String.valueOf(key)));
    }
 
    public static void clear(String cacheName) {
        clear(cacheName, TENANT_MODE);
    }
 
    public static void clear(String cacheName, Boolean tenantMode) {
        if (Func.isEmpty(cacheName)) {
            return;
        }
        getCache(cacheName, tenantMode).clear();
    }
 
    public static void clear(String cacheName, String tenantId) {
        if (Func.isEmpty(cacheName)) {
            return;
        }
        getCache(cacheName, tenantId).clear();
    }
 
    public static void clear(String cacheName, List<String> tenantIds) {
        if (Func.isEmpty(cacheName)) {
            return;
        }
        tenantIds.forEach(tenantId -> {
            getCache(cacheName, tenantId).clear();
        });
    }
}