From 691bee4229856f8bf81c2720092ecee1c9f21509 Mon Sep 17 00:00:00 2001
From: zhou zhou <3272660260@qq.com>
Date: 星期四, 09 四月 2026 19:18:12 +0800
Subject: [PATCH] #getter$摘出entity
---
rsf-server/src/main/java/com/vincent/rsf/server/manager/utils/buildPageRowsUtils.java | 338 +++++++++++++++++++++++++++-----------------------------
1 files changed, 163 insertions(+), 175 deletions(-)
diff --git a/rsf-server/src/main/java/com/vincent/rsf/server/manager/utils/buildPageRowsUtils.java b/rsf-server/src/main/java/com/vincent/rsf/server/manager/utils/buildPageRowsUtils.java
index 47bd756..ca537f5 100644
--- a/rsf-server/src/main/java/com/vincent/rsf/server/manager/utils/buildPageRowsUtils.java
+++ b/rsf-server/src/main/java/com/vincent/rsf/server/manager/utils/buildPageRowsUtils.java
@@ -14,13 +14,11 @@
import com.vincent.rsf.server.manager.entity.Companys;
import com.vincent.rsf.server.manager.entity.Warehouse;
import com.vincent.rsf.server.manager.entity.WarehouseAreas;
-import com.vincent.rsf.server.manager.service.CompanysService;
-import com.vincent.rsf.server.manager.service.WarehouseService;
+import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.system.constant.DictTypeCode;
import com.vincent.rsf.server.system.entity.DictData;
import com.vincent.rsf.server.system.entity.User;
-import com.vincent.rsf.server.system.service.DictDataService;
-import com.vincent.rsf.server.system.service.UserService;
+import com.vincent.rsf.server.system.service.*;
import java.lang.reflect.Field;
import java.util.ArrayList;
@@ -45,27 +43,35 @@
private static final String USER_NAME_CACHE_FLAG = "PAGE_ROWS_USER_NAME";
private static final String WAREHOUSE_NAME_CACHE_FLAG = "PAGE_ROWS_WAREHOUSE_NAME";
private static final String COMPANY_NAME_CACHE_FLAG = "PAGE_ROWS_COMPANY_NAME";
+ private static final String DICT_LABEL_CACHE_FLAG = "PAGE_ROWS_DICT_LABEL";
+ private static final String ENTITY_FIELD_CACHE_FLAG = "PAGE_ROWS_ENTITY_FIELD";
private static final int NAME_CACHE_TTL_SECONDS = 300;
+ private static final Consumer<List<Object>> NO_OP_ENRICHER = records -> {
+ };
private static final List<IdFieldMapping> COMMON_ID_FIELD_MAPPINGS = List.of(
- new IdFieldMapping("tenantId", "tenantId$", com.vincent.rsf.server.system.service.TenantService.class, "name"),
- new IdFieldMapping("deptId", "deptId$", com.vincent.rsf.server.system.service.DeptService.class, "name"),
- new IdFieldMapping("dictTypeId", "dictTypeId$", com.vincent.rsf.server.system.service.DictTypeService.class, "name"),
+ new IdFieldMapping("tenantId", "tenantId$", TenantService.class, "name"),
+ new IdFieldMapping("deptId", "deptId$", DeptService.class, "name"),
+ new IdFieldMapping("dictTypeId", "dictTypeId$", DictTypeService.class, "name"),
new IdFieldMapping("userId", "userId$", UserService.class, "nickname"),
new IdFieldMapping("root", "root$", UserService.class, "username"),
new IdFieldMapping("warehouseId", "warehouseId$", WarehouseService.class, "name"),
new IdFieldMapping("warehouse", "warehouse$", WarehouseService.class, "name"),
- new IdFieldMapping("area", "area$", com.vincent.rsf.server.manager.service.WarehouseAreasService.class, "name"),
- new IdFieldMapping("areaId", "areaId$", com.vincent.rsf.server.manager.service.WarehouseAreasService.class, "name"),
+ new IdFieldMapping("area", "area$", WarehouseAreasService.class, "name"),
+ new IdFieldMapping("areaId", "areaId$", WarehouseAreasService.class, "name"),
new IdFieldMapping("shipperId", "shipperId$", CompanysService.class, "name"),
new IdFieldMapping("supplierId", "supplierId$", CompanysService.class, "name"),
new IdFieldMapping("splrId", "splrId$", CompanysService.class, "name"),
- new IdFieldMapping("groupId", "groupId$", com.vincent.rsf.server.manager.service.MatnrGroupService.class, "name"),
- new IdFieldMapping("locId", "locId$", com.vincent.rsf.server.manager.service.LocService.class, "code"),
- new IdFieldMapping("locTypeId", "locTypeId$", com.vincent.rsf.server.manager.service.LocTypeService.class, "name")
+ new IdFieldMapping("groupId", "groupId$", MatnrGroupService.class, "name"),
+ new IdFieldMapping("locId", "locId$", LocService.class, "code"),
+ new IdFieldMapping("locTypeId", "locTypeId$", LocTypeService.class, "name")
);
private static final Map<Class<?>, Consumer<List<Object>>> SPECIAL_RECORD_ENRICHERS = createSpecialRecordEnrichers();
+ private static final Map<Class<?>, Consumer<List<Object>>> RESOLVED_ENRICHER_CACHE = new ConcurrentHashMap<>();
+ private static final Map<Class<?>, List<IdFieldMapping>> APPLICABLE_ID_FIELD_MAPPINGS_CACHE = new ConcurrentHashMap<>();
private static final Map<Class<?>, Map<String, Optional<Field>>> FIELD_CACHE = new ConcurrentHashMap<>();
private static final Map<Class<?>, Optional<Field>> ID_FIELD_CACHE = new ConcurrentHashMap<>();
+ private static final Map<Class<?>, Map<String, String>> COLUMN_CACHE = new ConcurrentHashMap<>();
+ private static final Map<Class<?>, Optional<IService<?>>> SERVICE_CACHE = new ConcurrentHashMap<>();
public static <T> T rowsMap(T data) {
if (data == null) {
@@ -172,7 +178,7 @@
}
private static void rowsMapByClass(Class<?> recordClass, List<Object> records) {
- if (recordClass == null || Cools.isEmpty(records)) {
+ if (recordClass == null || Cools.isEmpty(records) || isSimpleValueType(recordClass)) {
return;
}
if (WarehouseAreas.class.isAssignableFrom(recordClass)) {
@@ -182,7 +188,7 @@
return;
}
userNameMap(records);
- applyCommonIdFieldMappings(records);
+ applyCommonIdFieldMappings(recordClass, records);
Consumer<List<Object>> enricher = findSpecialRecordEnricher(recordClass);
if (enricher != null) {
enricher.accept(records);
@@ -190,8 +196,8 @@
fillUserRoleIds(records);
}
- private static void applyCommonIdFieldMappings(List<Object> records) {
- for (IdFieldMapping mapping : COMMON_ID_FIELD_MAPPINGS) {
+ private static void applyCommonIdFieldMappings(Class<?> recordClass, List<Object> records) {
+ for (IdFieldMapping mapping : getApplicableIdFieldMappings(recordClass)) {
fillFieldById(records, mapping.sourceField(), mapping.targetField(), mapping.serviceClass(), mapping.returnField());
}
}
@@ -294,12 +300,17 @@
}
private static Consumer<List<Object>> findSpecialRecordEnricher(Class<?> recordClass) {
+ Consumer<List<Object>> enricher = RESOLVED_ENRICHER_CACHE.computeIfAbsent(recordClass, buildPageRowsUtils::resolveSpecialRecordEnricher);
+ return enricher == NO_OP_ENRICHER ? null : enricher;
+ }
+
+ private static Consumer<List<Object>> resolveSpecialRecordEnricher(Class<?> recordClass) {
for (Map.Entry<Class<?>, Consumer<List<Object>>> entry : SPECIAL_RECORD_ENRICHERS.entrySet()) {
if (entry.getKey().isAssignableFrom(recordClass)) {
return entry.getValue();
}
}
- return null;
+ return NO_OP_ENRICHER;
}
private static void fillWkOrderRows(List<Object> records) {
@@ -531,9 +542,6 @@
userRoleMap.computeIfAbsent(userId, key -> new ArrayList<>()).add(roleId);
}
for (Object record : records) {
- if (!hasField(record, "userRoleIds")) {
- continue;
- }
Long userId = readLongId(record, "id");
List<Long> roleIds = userId == null ? Collections.emptyList() : userRoleMap.getOrDefault(userId, Collections.emptyList());
writeField(record, "userRoleIds", roleIds.toArray(Long[]::new));
@@ -556,9 +564,6 @@
return;
}
for (Object record : records) {
- if (!hasField(record, targetField)) {
- continue;
- }
writeStringField(record, targetField, valueMap.get(readLongId(record, sourceField)));
}
}
@@ -567,24 +572,19 @@
if (serviceClass == null || Cools.isEmpty(ids) || Cools.isEmpty(returnField)) {
return Collections.emptyMap();
}
- IService<?> service = getServiceBean(serviceClass);
- if (service == null) {
- return Collections.emptyMap();
- }
- List<?> entities = service.listByIds(new ArrayList<>(ids));
- if (Cools.isEmpty(entities)) {
- return Collections.emptyMap();
- }
- Map<Long, String> valueMap = new HashMap<>();
- for (Object entity : entities) {
- Long id = readEntityId(entity);
- Object value = readFieldValue(entity, returnField);
- if (id == null || value == null) {
- continue;
- }
- valueMap.put(id, String.valueOf(value));
- }
- return valueMap;
+ RedisService redisService = getRedisService();
+ String cacheFlag = buildEntityFieldCacheFlag(serviceClass, returnField);
+ return loadValueMap(
+ ids,
+ id -> getCachedStringValue(redisService, id, cacheFlag),
+ missingIds -> {
+ IService<?> service = getServiceBean(serviceClass);
+ return service == null ? Collections.emptyList() : service.listByIds(new ArrayList<>(missingIds));
+ },
+ buildPageRowsUtils::readEntityId,
+ entity -> normalizeStringValue(readFieldValue(entity, returnField)),
+ loadedValueMap -> cacheStringValues(redisService, loadedValueMap, cacheFlag)
+ );
}
private static Long readEntityId(Object entity) {
@@ -599,44 +599,6 @@
}
}
return getLongFieldValue(entity, "id");
- }
-
- public static String getDictLabel(String dictTypeCode, Object value) {
- if (Cools.isEmpty(dictTypeCode) || value == null || Cools.isEmpty(String.valueOf(value))) {
- return null;
- }
- Object dictData = getEntityByFields(
- DictDataService.class,
- DictData.class,
- Map.of(
- "dictTypeCode", dictTypeCode,
- "value", value
- )
- );
- return getStringFieldValue(dictData, "label");
- }
-
- public static String getDictLabelWithValue(String dictTypeCode, Object value) {
- String label = getDictLabel(dictTypeCode, value);
- if (label == null || value == null) {
- return null;
- }
- return value + "." + label;
- }
-
- public static List<Long> getDictIds(String dictTypeCode, Collection<?> values) {
- if (Cools.isEmpty(dictTypeCode) || Cools.isEmpty(values)) {
- return Collections.emptyList();
- }
- List<?> dictDataList = listEntitiesByFieldIn(DictDataService.class, DictData.class, "value", values,
- Map.of("dictTypeCode", dictTypeCode));
- if (Cools.isEmpty(dictDataList)) {
- return Collections.emptyList();
- }
- return dictDataList.stream()
- .map(item -> getLongFieldValue(item, "id"))
- .filter(Objects::nonNull)
- .toList();
}
private static Long readLongId(Object record, String fieldName) {
@@ -666,37 +628,40 @@
private static Map<Long, String> loadUserNameMap(Set<Long> userIds) {
RedisService redisService = getRedisService();
- return loadNameMap(
+ UserService userService = getServiceBean(UserService.class, UserService.class);
+ return loadValueMap(
userIds,
- userId -> getCachedName(redisService, userId, USER_NAME_CACHE_FLAG),
- missingUserIds -> SpringUtils.getBean(UserService.class).listByIds(missingUserIds),
+ userId -> getCachedStringValue(redisService, userId, USER_NAME_CACHE_FLAG),
+ missingUserIds -> userService == null ? Collections.emptyList() : userService.listByIds(missingUserIds),
User::getId,
User::getNickname,
- loadedUserNameMap -> cacheNames(redisService, loadedUserNameMap, USER_NAME_CACHE_FLAG)
+ loadedUserNameMap -> cacheStringValues(redisService, loadedUserNameMap, USER_NAME_CACHE_FLAG)
);
}
private static Map<Long, String> loadWarehouseNameMap(Set<Long> warehouseIds) {
RedisService redisService = getRedisService();
- return loadNameMap(
+ WarehouseService warehouseService = getServiceBean(WarehouseService.class, WarehouseService.class);
+ return loadValueMap(
warehouseIds,
- id -> getCachedName(redisService, id, WAREHOUSE_NAME_CACHE_FLAG),
- missingIds -> SpringUtils.getBean(WarehouseService.class).listByIds(missingIds),
+ id -> getCachedStringValue(redisService, id, WAREHOUSE_NAME_CACHE_FLAG),
+ missingIds -> warehouseService == null ? Collections.emptyList() : warehouseService.listByIds(missingIds),
Warehouse::getId,
Warehouse::getName,
- loadedNameMap -> cacheNames(redisService, loadedNameMap, WAREHOUSE_NAME_CACHE_FLAG)
+ loadedNameMap -> cacheStringValues(redisService, loadedNameMap, WAREHOUSE_NAME_CACHE_FLAG)
);
}
private static Map<Long, String> loadCompanyNameMap(Set<Long> companyIds) {
RedisService redisService = getRedisService();
- return loadNameMap(
+ CompanysService companysService = getServiceBean(CompanysService.class, CompanysService.class);
+ return loadValueMap(
companyIds,
- id -> getCachedName(redisService, id, COMPANY_NAME_CACHE_FLAG),
- missingIds -> SpringUtils.getBean(CompanysService.class).listByIds(missingIds),
+ id -> getCachedStringValue(redisService, id, COMPANY_NAME_CACHE_FLAG),
+ missingIds -> companysService == null ? Collections.emptyList() : companysService.listByIds(missingIds),
Companys::getId,
Companys::getName,
- loadedNameMap -> cacheNames(redisService, loadedNameMap, COMPANY_NAME_CACHE_FLAG)
+ loadedNameMap -> cacheStringValues(redisService, loadedNameMap, COMPANY_NAME_CACHE_FLAG)
);
}
@@ -704,73 +669,69 @@
if (Cools.isEmpty(values) || Cools.isEmpty(dictTypeCode)) {
return Collections.emptyMap();
}
- List<String> normalizedValues = values.stream()
- .filter(value -> !Cools.isEmpty(value))
- .distinct()
- .toList();
- if (normalizedValues.isEmpty()) {
- return Collections.emptyMap();
- }
- DictDataService dictDataService;
- try {
- dictDataService = SpringUtils.getBean(DictDataService.class);
- } catch (Exception ignored) {
- return Collections.emptyMap();
- }
- List<DictData> dictDataList = dictDataService.list(
- new LambdaQueryWrapper<DictData>()
- .eq(DictData::getDictTypeCode, dictTypeCode)
- .in(DictData::getValue, normalizedValues)
+ RedisService redisService = getRedisService();
+ DictDataService dictDataService = getServiceBean(DictDataService.class, DictDataService.class);
+ String cacheFlag = buildDictLabelCacheFlag(dictTypeCode);
+ return loadValueMap(
+ values,
+ value -> getCachedStringValue(redisService, value, cacheFlag),
+ missingValues -> {
+ if (dictDataService == null) {
+ return Collections.emptyList();
+ }
+ return dictDataService.list(
+ new LambdaQueryWrapper<DictData>()
+ .eq(DictData::getDictTypeCode, dictTypeCode)
+ .in(DictData::getValue, missingValues)
+ );
+ },
+ DictData::getValue,
+ DictData::getLabel,
+ loadedLabelMap -> cacheStringValues(redisService, loadedLabelMap, cacheFlag)
);
- if (Cools.isEmpty(dictDataList)) {
- return Collections.emptyMap();
- }
- return dictDataList.stream()
- .filter(Objects::nonNull)
- .filter(item -> !Cools.isEmpty(item.getValue()) && item.getLabel() != null)
- .collect(Collectors.toMap(DictData::getValue, DictData::getLabel, (left, right) -> left));
}
- private static <E> Map<Long, String> loadNameMap(Set<Long> ids,
- Function<Long, String> cacheGetter,
- Function<List<Long>, List<E>> entityLoader,
- Function<E, Long> idGetter,
- Function<E, String> nameGetter,
- Consumer<Map<Long, String>> cacheWriter) {
- if (Cools.isEmpty(ids)) {
+ private static <K, E> Map<K, String> loadValueMap(Set<K> keys,
+ Function<K, String> cacheGetter,
+ Function<List<K>, List<E>> entityLoader,
+ Function<E, K> keyGetter,
+ Function<E, String> valueGetter,
+ Consumer<Map<K, String>> cacheWriter) {
+ if (Cools.isEmpty(keys)) {
return Collections.emptyMap();
}
- List<Long> normalizedIds = ids.stream()
+ List<K> normalizedKeys = keys.stream()
.filter(Objects::nonNull)
.distinct()
.toList();
- if (normalizedIds.isEmpty()) {
+ if (normalizedKeys.isEmpty()) {
return Collections.emptyMap();
}
- Map<Long, String> nameMap = new HashMap<>();
- List<Long> missingIds = new ArrayList<>();
- for (Long id : normalizedIds) {
- String cachedName = cacheGetter.apply(id);
- if (cachedName == null) {
- missingIds.add(id);
+ Map<K, String> valueMap = new HashMap<>();
+ List<K> missingKeys = new ArrayList<>();
+ for (K key : normalizedKeys) {
+ String cachedValue = cacheGetter.apply(key);
+ if (cachedValue == null) {
+ missingKeys.add(key);
continue;
}
- nameMap.put(id, cachedName);
+ valueMap.put(key, cachedValue);
}
- if (missingIds.isEmpty()) {
- return nameMap;
+ if (missingKeys.isEmpty()) {
+ return valueMap;
}
- List<E> loadedEntities = entityLoader.apply(missingIds);
+ List<E> loadedEntities = entityLoader.apply(missingKeys);
if (loadedEntities == null) {
- return nameMap;
+ return valueMap;
}
- Map<Long, String> loadedNameMap = loadedEntities.stream()
+ Map<K, String> loadedValueMap = loadedEntities.stream()
.filter(Objects::nonNull)
- .filter(item -> idGetter.apply(item) != null && nameGetter.apply(item) != null)
- .collect(Collectors.toMap(idGetter, nameGetter, (left, right) -> left));
- nameMap.putAll(loadedNameMap);
- cacheWriter.accept(loadedNameMap);
- return nameMap;
+ .map(item -> new java.util.AbstractMap.SimpleEntry<>(keyGetter.apply(item), valueGetter.apply(item)))
+ .filter(item -> item.getKey() != null && item.getValue() != null)
+ .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (left, right) -> left));
+ valueMap.putAll(loadedValueMap);
+ cacheWriter.accept(loadedValueMap);
+ return valueMap;
}
private static RedisService getRedisService() {
@@ -782,17 +743,22 @@
}
private static IService<?> getServiceBean(Class<?> serviceClass) {
- try {
- Object bean = SpringUtils.getBean(serviceClass);
- return bean instanceof IService<?> iService ? iService : null;
- } catch (Exception ignored) {
+ if (serviceClass == null) {
return null;
}
+ return SERVICE_CACHE.computeIfAbsent(serviceClass, key -> {
+ try {
+ Object bean = SpringUtils.getBean(key);
+ return bean instanceof IService<?> iService ? Optional.of(iService) : Optional.empty();
+ } catch (Exception ignored) {
+ return Optional.empty();
+ }
+ }).orElse(null);
}
- private static Object getEntityByFields(Class<?> serviceClass, Class<?> entityClass, Map<String, Object> conditions) {
- List<?> entityList = listEntitiesByFields(serviceClass, entityClass, conditions, false);
- return Cools.isEmpty(entityList) ? null : entityList.get(0);
+ private static <T> T getServiceBean(Class<?> serviceClass, Class<T> targetType) {
+ IService<?> serviceBean = getServiceBean(serviceClass);
+ return targetType != null && targetType.isInstance(serviceBean) ? targetType.cast(serviceBean) : null;
}
private static List<?> listEntitiesByFieldIn(Class<?> serviceClass,
@@ -813,27 +779,16 @@
return service.list((Wrapper) queryWrapper);
}
- private static List<?> listEntitiesByFields(Class<?> serviceClass,
- Class<?> entityClass,
- Map<String, Object> conditions,
- boolean all) {
- if (serviceClass == null || entityClass == null || Cools.isEmpty(conditions)) {
- return Collections.emptyList();
+ private static String resolveColumnName(Class<?> entityClass, String fieldName) {
+ if (entityClass == null || Cools.isEmpty(fieldName)) {
+ return fieldName;
}
- IService<?> service = getServiceBean(serviceClass);
- if (service == null) {
- return Collections.emptyList();
- }
- QueryWrapper<Object> queryWrapper = new QueryWrapper<>();
- conditions.forEach((fieldName, value) -> queryWrapper.eq(resolveColumnName(entityClass, fieldName), value));
- if (all) {
- return service.list((Wrapper) queryWrapper);
- }
- Object entity = service.getOne((Wrapper) queryWrapper, false);
- return entity == null ? Collections.emptyList() : Collections.singletonList(entity);
+ return COLUMN_CACHE
+ .computeIfAbsent(entityClass, key -> new ConcurrentHashMap<>())
+ .computeIfAbsent(fieldName, key -> resolveColumnNameInternal(entityClass, key));
}
- private static String resolveColumnName(Class<?> entityClass, String fieldName) {
+ private static String resolveColumnNameInternal(Class<?> entityClass, String fieldName) {
Field field = getCachedField(entityClass, fieldName);
if (field == null) {
return camelToSnake(fieldName);
@@ -847,6 +802,15 @@
return stripColumnQuotes(tableField.value());
}
return camelToSnake(fieldName);
+ }
+
+ private static List<IdFieldMapping> getApplicableIdFieldMappings(Class<?> recordClass) {
+ if (recordClass == null) {
+ return Collections.emptyList();
+ }
+ return APPLICABLE_ID_FIELD_MAPPINGS_CACHE.computeIfAbsent(recordClass, key -> COMMON_ID_FIELD_MAPPINGS.stream()
+ .filter(mapping -> hasField(key, mapping.sourceField()) && hasField(key, mapping.targetField()))
+ .toList());
}
private static String stripColumnQuotes(String column) {
@@ -910,31 +874,39 @@
}
}
- private static String getCachedName(RedisService redisService, Long id, String cacheFlag) {
- if (redisService == null || id == null) {
+ private static String getCachedStringValue(RedisService redisService, Object key, String cacheFlag) {
+ if (redisService == null || key == null || Cools.isEmpty(cacheFlag)) {
return null;
}
try {
- String value = redisService.getValue(cacheFlag, String.valueOf(id));
+ String value = redisService.getValue(cacheFlag, String.valueOf(key));
return Cools.isEmpty(value) ? null : value;
} catch (Exception ignored) {
return null;
}
}
- private static void cacheNames(RedisService redisService, Map<Long, String> nameMap, String cacheFlag) {
- if (redisService == null || Cools.isEmpty(nameMap)) {
+ private static void cacheStringValues(RedisService redisService, Map<?, String> valueMap, String cacheFlag) {
+ if (redisService == null || Cools.isEmpty(valueMap) || Cools.isEmpty(cacheFlag)) {
return;
}
- nameMap.forEach((id, name) -> {
- if (id == null || Cools.isEmpty(name)) {
+ valueMap.forEach((key, value) -> {
+ if (key == null || Cools.isEmpty(value)) {
return;
}
try {
- redisService.setValue(cacheFlag, String.valueOf(id), name, NAME_CACHE_TTL_SECONDS);
+ redisService.setValue(cacheFlag, String.valueOf(key), value, NAME_CACHE_TTL_SECONDS);
} catch (Exception ignored) {
}
});
+ }
+
+ private static String buildDictLabelCacheFlag(String dictTypeCode) {
+ return DICT_LABEL_CACHE_FLAG + "." + dictTypeCode;
+ }
+
+ private static String buildEntityFieldCacheFlag(Class<?> serviceClass, String returnField) {
+ return ENTITY_FIELD_CACHE_FLAG + "." + serviceClass.getName() + "." + returnField;
}
private static <T> void fillUserNameFields(List<T> records, Map<Long, String> userNameMap) {
@@ -1015,8 +987,24 @@
return findField(type, "id");
}
+ private static boolean hasField(Class<?> recordClass, String fieldName) {
+ return recordClass != null && !Cools.isEmpty(fieldName) && getCachedField(recordClass, fieldName) != null;
+ }
+
private static boolean hasField(Object record, String fieldName) {
- return record != null && !Cools.isEmpty(fieldName) && getCachedField(record.getClass(), fieldName) != null;
+ return record != null && hasField(record.getClass(), fieldName);
+ }
+
+ private static boolean isSimpleValueType(Class<?> type) {
+ return type != null
+ && (type.isPrimitive()
+ || Number.class.isAssignableFrom(type)
+ || CharSequence.class.isAssignableFrom(type)
+ || Boolean.class.isAssignableFrom(type)
+ || Character.class.isAssignableFrom(type)
+ || Enum.class.isAssignableFrom(type)
+ || java.util.Date.class.isAssignableFrom(type)
+ || java.time.temporal.Temporal.class.isAssignableFrom(type));
}
private record IdFieldMapping(String sourceField, String targetField, Class<?> serviceClass, String returnField) {
--
Gitblit v1.9.1