FEAT:(BACKENDDEV-1929) validateUtil > RequiredField 추가

Author: HyeokJoon

README.md

@@ -3,15 +3,18 @@
 이 프로젝트는 Teamo2 Java 기반 프로젝트에서 공통으로 사용되는 유틸리티 클래스들을 제공하는 라이브러리입니다.
 
 ## 버전
+
 - 1.0.5
 
 ## 개발 환경
+
 - Java 17
 - Gradle 8.x
 
 ## 주요 기능
 
 ### TimeUtil
+
 - 날짜/시간 변환 및 포맷팅
 - 나이 계산
 - 요일 기반 날짜 추출
@@ -37,7 +40,7 @@ dependencies {
     implementation 'kr.teamo2:utilmore:{version}'
 }
 ```
-  
+
 ## 패키지 수정 방법
 
 ### 1. 프로젝트 클론
@@ -47,22 +50,13 @@ git clone https://github.com/teamo2dev/utilmore-java.git
 ```
 
 ### 2. 버전 수정
-- build.gradle 파일에서 다음 부분을 수정합니다.
 
+- build.gradle 파일에서 다음 부분을 수정합니다.
+ 
 ```gradle
-publishing {
-    // repository
-    publications {
-        gpr(MavenPublication) {
-            groupId = 'kr.teamo2'
-            artifactId = 'utilmore'
-            version = '1.0.5' // 다음 버전
-        
-            from(components.java)
-        }
-    }
-}
+version = '1.0.6' // 다음 버전
 ```
+
 ### 3. 패키지 배포
 
 - Prod 브랜치로 푸시 혹은 PR을 생성하여 merge될 때 자동으로 배포됩니다.

lib/build.gradle

@@ -30,6 +30,9 @@ dependencies {
 
     compileOnly 'org.projectlombok:lombok:1.18.30'
     annotationProcessor 'org.projectlombok:lombok:1.18.30'
+
+    //springframework
+    implementation 'org.springframework.boot:spring-boot-starter-web:3.5.0'
 }
 
 // Apply a specific Java toolchain to ease working on different environments.
@@ -46,6 +49,8 @@ tasks.named('test') {
     useJUnitPlatform()
 }
 
+version = '1.0.7'
+
 publishing {
     repositories {
         maven {
@@ -63,7 +68,7 @@ publishing {
         gpr(MavenPublication) {
             groupId = 'kr.teamo2'
             artifactId = 'utilmore'
-            version = '1.0.5'
+            version = version
 
             from(components.java)
         }

lib/src/main/java/kr/teamo2/exception/error/BaseErrorCode.java

@@ -0,0 +1,14 @@
+package kr.teamo2.exception.error;
+
+import org.springframework.http.HttpStatus;
+
+public interface BaseErrorCode<T extends RuntimeException> {
+
+    String name();
+
+    String getMessage();
+
+    HttpStatus getHttpStatus();
+
+    T toException();
+}

lib/src/main/java/kr/teamo2/utils/validateUtil/RequiredException.java

@@ -0,0 +1,29 @@
+package kr.teamo2.utils.validateUtil;
+
+import lombok.Getter;
+
+@Getter
+public class RequiredException extends RuntimeException {
+
+    private String code;
+    private String message;
+    private String fieldName;
+
+    public RequiredException(String message) {
+        super(message);
+    }
+
+    public RequiredException(String code, String message, Throwable cause) {
+        super(message, cause);
+        this.code = code;
+        this.message = message;
+        this.fieldName = "";
+    }
+
+    public RequiredException(String code, String message, String fieldName) {
+        super(message);
+        this.code = code;
+        this.message = message;
+        this.fieldName = fieldName;
+    }
+}

lib/src/main/java/kr/teamo2/utils/validateUtil/RequiredField.java

@@ -0,0 +1,17 @@
+package kr.teamo2.utils.validateUtil;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface RequiredField {
+
+    boolean hasDefaultValue() default false;
+
+    String defaultValue() default "";
+
+    Class<?> defaultValueType() default String.class;
+}

lib/src/main/java/kr/teamo2/utils/validateUtil/RequiredFieldErrorCode.java

@@ -0,0 +1,52 @@
+package kr.teamo2.utils.validateUtil;
+
+import java.lang.reflect.Field;
+import java.util.Optional;
+import kr.teamo2.exception.error.BaseErrorCode;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+
+@Getter
+@RequiredArgsConstructor
+public enum RequiredFieldErrorCode implements BaseErrorCode<RequiredException> {
+
+    INTERNAL_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "INTERNAL_ERROR", "unknown internal error"),
+    REQUIRED_FIELD_NOT_EXIST(HttpStatus.UNPROCESSABLE_ENTITY, "REQUIRED_FIELD_NOT_EXIST", "required field {} is null");
+
+    private final HttpStatus httpStatus;
+    private final String errorCode;
+    private final String message;
+
+    @Override
+    public RequiredException toException() {
+        return new RequiredException(message);
+    }
+
+    @Override
+    public String getMessage() {
+        return message;
+    }
+
+    @Override
+    public HttpStatus getHttpStatus() {
+        return httpStatus;
+    }
+
+    public RequiredException toRequiredException(Field field) {
+        String requiredValue = getFieldNameWithClass(field);
+        String errorMessage = message.replace("{}", requiredValue);
+        return new RequiredException(errorCode, errorMessage, requiredValue);
+    }
+
+    public RequiredException toRequiredException(Throwable throwable) {
+        return new RequiredException(errorCode, message, throwable);
+    }
+
+    private String getFieldNameWithClass(Field field) {
+        return Optional.ofNullable(field)
+            .map(f -> f.getDeclaringClass().getSimpleName() + "." + f.getName())
+            .orElse("UnknownField");
+    }
+
+}

lib/src/main/java/kr/teamo2/utils/validateUtil/RequiredFieldValidator.java

@@ -0,0 +1,126 @@
+package kr.teamo2.utils.validateUtil;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class RequiredFieldValidator {
+
+    static final List<String> JAVA_PACKAGE_PREFIXES = List.of("java.", "javax.");
+
+    public static void validateField(Object object) {
+        if (object == null) {
+            return;
+        }
+
+        Class<?> current = object.getClass();
+        while (current != null && current != Object.class) {
+            Field[] fields = current.getDeclaredFields();
+
+            // validate basic type value
+            Arrays.stream(fields)
+                .peek(field -> field.setAccessible(true))
+                .filter(field -> field.isAnnotationPresent(RequiredField.class))
+                .filter(field -> isNull(object, field))
+                .forEach(field -> validate(object, field));
+
+            // validate object type
+            Arrays.stream(fields)
+                .peek(field -> field.setAccessible(true))
+                .filter(field -> !isEnum(field.getType()))
+                .filter(field -> !isJavaPackage(field.getType()))
+                .forEach(field -> {
+                    try {
+                        Object innerObject = field.get(object);
+                        if (innerObject != null) {
+                            validateField(innerObject);
+                        }
+                    } catch (IllegalAccessException e) {
+                        throw RequiredFieldErrorCode.INTERNAL_ERROR.toRequiredException(e);
+                    }
+                });
+
+            // Collection and Array traversal
+            Arrays.stream(fields)
+                .peek(field -> field.setAccessible(true))
+                .filter(field -> Collection.class.isAssignableFrom(field.getType()) || field.getType().isArray())
+                .forEach(field -> {
+                    try {
+                        Object value = field.get(object);
+                        if (value instanceof Collection<?> collection) {
+                            for (Object item : collection) {
+                                if (item != null && !isEnum(item.getClass()) && !isJavaPackage(item.getClass())) {
+                                    validateField(item);
+                                }
+                            }
+                        }
+                    } catch (IllegalAccessException e) {
+                        throw RequiredFieldErrorCode.INTERNAL_ERROR.toRequiredException(e);
+                    }
+                });
+
+            current = current.getSuperclass();
+        }
+    }
+
+    private static boolean isJavaPackage(Class<?> type) {
+        return Optional.ofNullable(type)
+            .map(Class::getPackage)
+            .map(Package::getName)
+            .map(name -> JAVA_PACKAGE_PREFIXES.stream().anyMatch(name::startsWith))
+            .orElse(false);
+    }
+
+    private static boolean isEnum(Class<?> type) {
+        return type.isEnum();
+    }
+
+    private static boolean isNull(Object object, Field field) {
+        field.setAccessible(true);
+        try {
+            return field.get(object) == null;
+        } catch (IllegalAccessException e) {
+            throw RequiredFieldErrorCode.INTERNAL_ERROR.toRequiredException(e);
+        }
+    }
+
+    private static void validate(Object object, Field field) {
+        RequiredField annotation = field.getAnnotation(RequiredField.class);
+        if (!annotation.hasDefaultValue()) {
+            throw RequiredFieldErrorCode.REQUIRED_FIELD_NOT_EXIST.toRequiredException(field);
+        }
+        try {
+            field.set(object, getValue(field, annotation));
+        } catch (IllegalAccessException e) {
+            throw RequiredFieldErrorCode.INTERNAL_ERROR.toRequiredException(e);
+        }
+    }
+
+    private static Object getValue(Field field, RequiredField annotation) {
+        Class<?> defaultValueType = annotation.defaultValueType();
+        String defaultValue = annotation.defaultValue();
+        if (defaultValueType == String.class) {
+            return defaultValue;
+        }
+        if (defaultValueType == int.class) {
+            return Integer.parseInt(defaultValue);
+        }
+        if (defaultValueType == BigDecimal.class) {
+            return new BigDecimal(defaultValue);
+        }
+        if (defaultValueType == boolean.class) {
+            return Boolean.parseBoolean(defaultValue);
+        }
+        if (defaultValueType == Array.class) {
+            return Array.newInstance(field.getType().getComponentType(), 0);
+        }
+        return null;
+    }
+}