From 2439631e407372615e49ac76e7044d29d9a76b9f Mon Sep 17 00:00:00 2001 From: kric_jspark Date: Wed, 10 Jun 2026 13:56:32 +0900 Subject: [PATCH] =?UTF-8?q?260610=5F01=5FENH:=20=EC=BB=AC=EB=9F=BC?= =?UTF-8?q?=EB=AA=85=EC=9C=BC=EB=A1=9C=20entity=20=EC=A0=91=EA=B7=BC?= =?UTF-8?q?=ED=95=98=EB=8A=94=20=EC=9C=A0=ED=8B=B8=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- build.gradle | 2 +- .../feature/jpa/EntityColumnAccessor.java | 423 ++++++++++++++++++ 2 files changed, 424 insertions(+), 1 deletion(-) create mode 100644 src/main/java/com/kri/common/feature/jpa/EntityColumnAccessor.java diff --git a/build.gradle b/build.gradle index e167fc3..a90b702 100644 --- a/build.gradle +++ b/build.gradle @@ -4,7 +4,7 @@ plugins { } // 버전 변경은 여기서 -def commonVer = "beta.1.1.23" +def commonVer = "beta.1.1.24" group = 'com.kri.common' version = commonVer diff --git a/src/main/java/com/kri/common/feature/jpa/EntityColumnAccessor.java b/src/main/java/com/kri/common/feature/jpa/EntityColumnAccessor.java new file mode 100644 index 0000000..09f8d4f --- /dev/null +++ b/src/main/java/com/kri/common/feature/jpa/EntityColumnAccessor.java @@ -0,0 +1,423 @@ +package com.kri.common.feature.jpa; + +import com.kri.common.feature.web.BusinessException; +import jakarta.persistence.Column; +import jakarta.persistence.EmbeddedId; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.util.HashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +public final class EntityColumnAccessor { + + private static final ConcurrentHashMap, Map> CACHE = + new ConcurrentHashMap<>(); + + private final Class entityType; + private final Map columns; + + private EntityColumnAccessor(Class entityType) { + this.entityType = entityType; + this.columns = CACHE.computeIfAbsent(entityType, EntityColumnAccessor::createColumnMap); + } + + public static EntityColumnAccessor of(Class entityType) { + return new EntityColumnAccessor<>(entityType); + } + + public Object get(T entity, String columnName) { + validateEntity(entity); + ColumnMeta meta = getColumnMeta(columnName); + Object target = getTarget(entity, meta, false); + if (target == null) { + return null; + } + + try { + return meta.field().get(target); + } catch (IllegalAccessException e) { + throw BusinessException.internalError( + "ENTITY_COLUMN_ACCESS_FAILED", + "엔티티 컬럼 값을 읽을 수 없습니다.") + .with("entityType", entityType.getName()) + .with("columnName", columnName); + } + } + + public V get(T entity, String columnName, Class valueType) { + Object value = get(entity, columnName); + if (value == null) { + return null; + } + if (!valueType.isInstance(value)) { + throw BusinessException.validationError( + "ENTITY_COLUMN_TYPE_MISMATCH", + "엔티티 컬럼 값 타입이 요청 타입과 일치하지 않습니다.") + .with("entityType", entityType.getName()) + .with("columnName", columnName) + .with("actualType", value.getClass().getName()) + .with("requestedType", valueType.getName()); + } + return valueType.cast(value); + } + + public void set(T entity, String columnName, Object value) { + setValue(entity, columnName, value, WriteMode.ANY); + } + + public void setForInsert(T entity, String columnName, Object value) { + setValue(entity, columnName, value, WriteMode.INSERT); + } + + public void setForUpdate(T entity, String columnName, Object value) { + setValue(entity, columnName, value, WriteMode.UPDATE); + } + + private void setValue(T entity, String columnName, Object value, WriteMode writeMode) { + validateEntity(entity); + ColumnMeta meta = getColumnMeta(columnName); + validateWritable(meta, columnName, writeMode); + validateFinal(meta, columnName); + + Object converted = convertValue(value, meta.field().getType(), columnName); + Object target = getTarget(entity, meta, true); + + try { + meta.field().set(target, converted); + } catch (IllegalAccessException e) { + throw BusinessException.internalError( + "ENTITY_COLUMN_ACCESS_FAILED", + "엔티티 컬럼 값을 설정할 수 없습니다.") + .with("entityType", entityType.getName()) + .with("columnName", columnName); + } + } + + private void validateEntity(T entity) { + if (entity == null) { + throw BusinessException.badRequest( + "ENTITY_REQUIRED", + "엔티티 객체가 필요합니다."); + } + } + + private ColumnMeta getColumnMeta(String columnName) { + if (columnName == null || columnName.isBlank()) { + throw BusinessException.badRequest( + "COLUMN_NAME_REQUIRED", + "컬럼명이 필요합니다."); + } + + ColumnMeta meta = columns.get(normalizeColumnName(columnName)); + if (meta == null) { + throw BusinessException.notFound( + "ENTITY_COLUMN_NOT_FOUND", + "엔티티에 해당 컬럼이 없습니다.") + .with("entityType", entityType.getName()) + .with("columnName", columnName); + } + return meta; + } + + private Object getTarget(T entity, ColumnMeta meta, boolean createEmbeddedId) { + if (meta.embeddedIdField() == null) { + return entity; + } + + try { + Object embeddedId = meta.embeddedIdField().get(entity); + if (embeddedId == null && createEmbeddedId) { + embeddedId = createEmbeddedId(meta.embeddedIdField().getType(), meta); + meta.embeddedIdField().set(entity, embeddedId); + } + return embeddedId; + } catch (IllegalAccessException e) { + throw BusinessException.internalError( + "ENTITY_EMBEDDED_ID_ACCESS_FAILED", + "엔티티 EmbeddedId에 접근할 수 없습니다.") + .with("entityType", entityType.getName()) + .with("embeddedIdField", meta.embeddedIdField().getName()); + } + } + + private Object createEmbeddedId(Class embeddedIdType, ColumnMeta meta) { + try { + Constructor constructor = embeddedIdType.getDeclaredConstructor(); + constructor.setAccessible(true); + return constructor.newInstance(); + } catch (ReflectiveOperationException e) { + throw BusinessException.internalError( + "ENTITY_EMBEDDED_ID_CREATE_FAILED", + "엔티티 EmbeddedId 객체를 생성할 수 없습니다.") + .with("entityType", entityType.getName()) + .with("embeddedIdType", embeddedIdType.getName()) + .with("columnName", meta.columnName()); + } + } + + private void validateWritable(ColumnMeta meta, String columnName, WriteMode writeMode) { + if (writeMode == WriteMode.INSERT && !meta.insertable()) { + throw BusinessException.validationError( + "ENTITY_COLUMN_NOT_INSERTABLE", + "insertable=false 컬럼은 insert 값으로 설정할 수 없습니다.") + .with("entityType", entityType.getName()) + .with("columnName", columnName); + } + if (writeMode == WriteMode.UPDATE && !meta.updatable()) { + throw BusinessException.validationError( + "ENTITY_COLUMN_NOT_UPDATABLE", + "updatable=false 컬럼은 update 값으로 설정할 수 없습니다.") + .with("entityType", entityType.getName()) + .with("columnName", columnName); + } + } + + private void validateFinal(ColumnMeta meta, String columnName) { + if (Modifier.isFinal(meta.field().getModifiers())) { + throw BusinessException.validationError( + "ENTITY_COLUMN_FINAL_FIELD", + "final 필드는 값을 설정할 수 없습니다.") + .with("entityType", entityType.getName()) + .with("columnName", columnName) + .with("fieldName", meta.field().getName()); + } + } + + private Object convertValue(Object value, Class targetType, String columnName) { + if (value == null) { + if (targetType.isPrimitive()) { + throw BusinessException.validationError( + "ENTITY_COLUMN_NULL_PRIMITIVE", + "primitive 타입 컬럼에는 null을 설정할 수 없습니다.") + .with("entityType", entityType.getName()) + .with("columnName", columnName) + .with("targetType", targetType.getName()); + } + return null; + } + + Class boxedType = boxType(targetType); + if (boxedType.isInstance(value)) { + return value; + } + + String text = value.toString(); + if (text.isBlank()) { + return convertBlankValue(boxedType, columnName); + } + + try { + return convertText(text, boxedType); + } catch (RuntimeException e) { + throw BusinessException.validationError( + "ENTITY_COLUMN_CONVERT_FAILED", + "엔티티 컬럼 값 타입 변환에 실패했습니다.") + .with("entityType", entityType.getName()) + .with("columnName", columnName) + .with("value", value) + .with("targetType", targetType.getName()); + } + } + + private Object convertBlankValue(Class targetType, String columnName) { + if (targetType == String.class) { + return ""; + } + throw BusinessException.validationError( + "ENTITY_COLUMN_CONVERT_FAILED", + "빈 문자열은 대상 타입으로 변환할 수 없습니다.") + .with("entityType", entityType.getName()) + .with("columnName", columnName) + .with("targetType", targetType.getName()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + private Object convertText(String text, Class targetType) { + if (targetType == String.class) { + return text; + } + if (targetType == Integer.class) { + return Integer.valueOf(text); + } + if (targetType == Long.class) { + return Long.valueOf(text); + } + if (targetType == Short.class) { + return Short.valueOf(text); + } + if (targetType == Byte.class) { + return Byte.valueOf(text); + } + if (targetType == Double.class) { + return Double.valueOf(text); + } + if (targetType == Float.class) { + return Float.valueOf(text); + } + if (targetType == BigDecimal.class) { + return new BigDecimal(text); + } + if (targetType == BigInteger.class) { + return new BigInteger(text); + } + if (targetType == Boolean.class) { + return convertBoolean(text); + } + if (targetType == LocalDate.class) { + return LocalDate.parse(text); + } + if (targetType == LocalDateTime.class) { + return LocalDateTime.parse(text); + } + if (targetType == LocalTime.class) { + return LocalTime.parse(text); + } + if (targetType.isEnum()) { + return Enum.valueOf((Class) targetType, text); + } + + throw new IllegalArgumentException("Unsupported target type: " + targetType.getName()); + } + + private Boolean convertBoolean(String text) { + return switch (text.trim().toLowerCase(Locale.ROOT)) { + case "true", "t", "yes", "y", "1" -> true; + case "false", "f", "no", "n", "0" -> false; + default -> throw new IllegalArgumentException("Unsupported boolean value: " + text); + }; + } + + private Class boxType(Class type) { + if (!type.isPrimitive()) { + return type; + } + if (type == int.class) { + return Integer.class; + } + if (type == long.class) { + return Long.class; + } + if (type == short.class) { + return Short.class; + } + if (type == byte.class) { + return Byte.class; + } + if (type == double.class) { + return Double.class; + } + if (type == float.class) { + return Float.class; + } + if (type == boolean.class) { + return Boolean.class; + } + if (type == char.class) { + return Character.class; + } + return type; + } + + private static Map createColumnMap(Class entityType) { + Map columns = new HashMap<>(); + for (Field field : getAllFields(entityType)) { + field.setAccessible(true); + if (field.isAnnotationPresent(EmbeddedId.class)) { + addEmbeddedIdColumns(entityType, columns, field); + continue; + } + + Column column = field.getAnnotation(Column.class); + if (column != null) { + addColumn(entityType, columns, null, field, column); + } + } + return Map.copyOf(columns); + } + + private static void addEmbeddedIdColumns( + Class entityType, + Map columns, + Field embeddedIdField + ) { + for (Field field : getAllFields(embeddedIdField.getType())) { + field.setAccessible(true); + Column column = field.getAnnotation(Column.class); + if (column != null) { + addColumn(entityType, columns, embeddedIdField, field, column); + } + } + } + + private static void addColumn( + Class entityType, + Map columns, + Field embeddedIdField, + Field field, + Column column + ) { + String columnName = column.name(); + if (columnName == null || columnName.isBlank()) { + columnName = field.getName(); + } + + String key = normalizeColumnName(columnName); + ColumnMeta previous = columns.putIfAbsent( + key, + new ColumnMeta( + columnName, + embeddedIdField, + field, + column.insertable(), + column.updatable() + ) + ); + if (previous != null) { + throw BusinessException.internalError( + "ENTITY_COLUMN_DUPLICATED", + "엔티티 컬럼 매핑이 중복되었습니다.") + .with("entityType", entityType.getName()) + .with("columnName", columnName) + .with("fieldName", field.getName()) + .with("previousFieldName", previous.field().getName()); + } + } + + private static List getAllFields(Class type) { + List fields = new java.util.ArrayList<>(); + Class current = type; + while (current != null && current != Object.class) { + fields.addAll(List.of(current.getDeclaredFields())); + current = current.getSuperclass(); + } + return fields; + } + + private static String normalizeColumnName(String columnName) { + return columnName.toLowerCase(Locale.ROOT); + } + + private enum WriteMode { + ANY, + INSERT, + UPDATE + } + + private record ColumnMeta( + String columnName, + Field embeddedIdField, + Field field, + boolean insertable, + boolean updatable + ) { + } +}