Merge 0.3.0 to develop (#23)

Author: Properks

api-payload/README.md

@@ -13,14 +13,8 @@ Because DefaultResponseWriteUtil and DefaultResponseWriter is already registered
 public class ExceptionAdviceConfig {
 
     @Bean
-    ExceptionAdviceConfigurer exceptionAdviceConfigurer(ExceptionHandlerRegistry exceptionHandlerRegistry) {
-        ExceptionAdviceConfigurer exceptionAdviceConfigurer = new ExceptionAdviceConfigurer(exceptionHandlerRegistry);
-        return exceptionAdviceConfigurer
-                .withDefault()
-                .enableMethodArgumentNotValidExceptionAdvice(DefaultResponseErrorCode._BAD_REQUEST)
-                .enableConstraintViolationExceptionAdvice(DefaultResponseErrorCode._BAD_REQUEST)
-                .enableGlobalExceptionAdvice(DefaultResponseErrorCode._INTERNAL_SERVER_ERROR)
-                ;
+    ExceptionAdviceConfigurer<DefaultResponseErrorReasonDTO> defaultExceptionAdviceConfigurer(FailureResponseWriter<DefaultResponseErrorReasonDTO> failureResponseWriter) {
+        return new DefaultExceptionAdviceConfigurer(failureResponseWriter);
     }
 }
 ```
@@ -51,4 +45,26 @@ You can make custom response by implementing BaseResponse, ErrorReasonDTO, Succe
 1. Make custom BaseResponse
 2. Make custom ErrorReasonDTO, SuccessReasonDTO
 3. Make custom SuccessResponseWriter, FailureResponseWriter 
-4. Register your custom Util, Handler, Writer in bean
+4. Register your custom Handler, Writer in bean
+
+### how to add custom handler in ExceptionAdvice
+```java
+@Configuration
+@RequiredArgsConstructor
+public class ExceptionAdviceConfig {
+
+    private final CustomFailureResponseWriter customFailureResponseWriter;
+    private final CustomServerApplicationExceptionHandler customServerApplicationExceptionHandler;
+
+    @Bean
+    ExceptionAdviceConfigurer<CustomErrorReasonDTO> exceptionAdviceConfigurer() {
+        ExceptionAdviceConfigurer<CustomErrorReasonDTO> configurer = new ExceptionAdviceConfigurer<>(customFailureResponseWriter); // Apply response writer when exception occurs
+        configurer.addConstraintViolation(CustomErrorCode.ERROR.getReason()); // apply with default handler
+        configurer.addMethodArgumentNotValid(CustomErrorCode.ERROR.getReason());
+        configurer.addServerApplication(customServerApplicationExceptionHandler, CustomErrorCode.ERROR.getReason()); // apply custom handler
+        configurer.addGlobalException(CustomErrorCode.BAD_ERROR.getReason());
+        return configurer;
+    }
+
+}
+```

api-payload/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <groupId>org.namul</groupId>
         <artifactId>beginner</artifactId>
-        <version>0.2.1</version>
+        <version>0.3.0</version>
     </parent>
 
     <artifactId>api-payload</artifactId>

api-payload/src/main/java/org/namul/api/payload/config/ExceptionAdviceAutoConfiguration.java

@@ -1,21 +1,14 @@
 package org.namul.api.payload.config;
 
-import jakarta.validation.ConstraintViolationException;
-import org.namul.api.payload.error.*;
+import org.namul.api.payload.code.dto.ErrorReasonDTO;
+import org.namul.api.payload.error.ExceptionAdvice;
 import org.namul.api.payload.error.configurer.ExceptionAdviceConfigurer;
-import org.namul.api.payload.error.exception.ServerApplicationException;
-import org.namul.api.payload.handler.*;
-import org.namul.api.payload.registry.ExceptionHandlerRegistry;
 import org.namul.api.payload.writer.FailureResponseWriter;
 import org.namul.api.payload.writer.supports.DefaultFailureResponseWriter;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.context.annotation.Bean;
-import org.springframework.web.bind.MethodArgumentNotValidException;
-
-import java.util.Optional;
 
 @AutoConfiguration
 public class ExceptionAdviceAutoConfiguration {
@@ -26,65 +19,9 @@ DefaultFailureResponseWriter defaultFailureResponseWriter() {
         return new DefaultFailureResponseWriter();
     }
 
-    @Bean
-    @ConditionalOnClass(ConstraintViolationException.class)
-    ConstraintViolationExceptionHandler constraintViolationExceptionHandler(FailureResponseWriter failureResponseWriter) {
-        return new ConstraintViolationExceptionHandler(failureResponseWriter);
-    }
-
-    @Bean
-    @ConditionalOnClass(MethodArgumentNotValidException.class)
-    MethodArgumentNotValidExceptionHandler methodArgumentNotValidExceptionHandler(FailureResponseWriter failureResponseWriter) {
-        return new MethodArgumentNotValidExceptionHandler(failureResponseWriter);
-    }
-
-    @Bean
-    ServerApplicationExceptionHandler serverApplicationExceptionHandler(FailureResponseWriter failureResponseWriter) {
-        return new ServerApplicationExceptionHandler(failureResponseWriter);
-    }
-
-    @Bean
-    GlobalExceptionHandler globalExceptionHandler(FailureResponseWriter failureResponseWriter) {
-        return new GlobalExceptionHandler(failureResponseWriter);
-    }
-
-    @Bean
-    @ConditionalOnMissingBean(ExceptionHandlerRegistry.class)
-    ExceptionHandlerRegistry exceptionHandlerRegistry(Optional<ConstraintViolationExceptionHandler> constraintViolationExceptionHandler,
-                                                      Optional<MethodArgumentNotValidExceptionHandler> methodArgumentNotValidExceptionHandler,
-                                                      Optional<ServerApplicationExceptionHandler> serverApplicationExceptionHandler,
-                                                      GlobalExceptionHandler globalExceptionHandler) {
-        ExceptionHandlerRegistry exceptionHandlerRegistry = new ExceptionHandlerRegistry();
-        constraintViolationExceptionHandler.ifPresent(handler -> exceptionHandlerRegistry.addHandler(ConstraintViolationException.class, handler));
-        methodArgumentNotValidExceptionHandler.ifPresent(handler -> exceptionHandlerRegistry.addHandler(MethodArgumentNotValidException.class, handler));
-        serverApplicationExceptionHandler.ifPresent(handler -> exceptionHandlerRegistry.addHandler(ServerApplicationException.class, handler));
-        exceptionHandlerRegistry.addHandler(Exception.class, globalExceptionHandler);
-        return exceptionHandlerRegistry;
-    }
-
-    @Bean
-    @ConditionalOnBean(ExceptionAdviceConfigurer.class)
-    @ConditionalOnClass(ConstraintViolationException.class)
-    ConstraintViolationExceptionAdvice constraintViolationExceptionAdvice(ExceptionAdviceConfigurer configurer) {
-        return configurer.getConstraintViolationExceptionAdvice();
-    }
-
-    @Bean
-    @ConditionalOnBean(ExceptionAdviceConfigurer.class)
-    @ConditionalOnClass(MethodArgumentNotValidException.class)
-    MethodArgumentNotValidExceptionAdvice methodArgumentNotValidExceptionAdvice(ExceptionAdviceConfigurer configurer) {
-        return configurer.getMethodArgumentNotValidExceptionAdvice();
-    }
-
-    @Bean
-    @ConditionalOnBean(ExceptionAdviceConfigurer.class)
-    ServerApplicationExceptionAdvice serverApplicationExceptionAdvice(ExceptionAdviceConfigurer configurer) {
-        return configurer.getServerApplicationExceptionAdvice();
-    }
-
     @Bean
     @ConditionalOnBean(ExceptionAdviceConfigurer.class)
-    GlobalExceptionAdvice advices(ExceptionAdviceConfigurer configurer) {
-        return configurer.getGlobalExceptionAdvice();
+    <R extends ErrorReasonDTO> ExceptionAdvice<R> exceptionAdvice(ExceptionAdviceConfigurer<R> exceptionAdviceConfigurer) {
+        return new ExceptionAdvice<>(exceptionAdviceConfigurer);
     }
 }

api-payload/src/main/java/org/namul/api/payload/error/ConstraintViolationExceptionAdvice.java

@@ -2,18 +2,47 @@
 
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.namul.api.payload.code.dto.ErrorReasonDTO;
+import org.namul.api.payload.error.configurer.ExceptionAdviceConfigurer;
+import org.namul.api.payload.handler.ExceptionAdviceHandler;
+import org.namul.api.payload.response.BaseResponse;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
 
 /**
  * The class for Error handling when error occurs.
- * @param <R> The return type after handling exception
- * @param <T> The exception type which will be handled
  */
-public interface ExceptionAdvice<R, T extends Exception> {
+@RestControllerAdvice
+@RequiredArgsConstructor
+public class ExceptionAdvice<R extends ErrorReasonDTO> {
+
+    private final ExceptionAdviceConfigurer<R> exceptionAdviceConfigurer;
 
     /**
      * Handle method when exception occurs
      * @param e The Exception type
      * @return The Response value after handling exception
      */
-    R handle(T e, HttpServletRequest request, HttpServletResponse response);
+    @ExceptionHandler
+    public <E extends Exception> BaseResponse handle(E e, HttpServletRequest request, HttpServletResponse response) {
+        ExceptionAdviceRegistry<E, R> registry = this.exceptionAdviceConfigurer.findRegistry(e.getClass());
+        if (registry == null) {
+            throw new IllegalArgumentException("The appropriate handler was not found.");
+        }
+        return handleDelegated(e, request, response, registry);
+    }
+
+    /**
+     * Create BaseResponse with handler and errorReasonDTO
+     * @param e The exception class
+     * @param request The HttpServletRequest
+     * @param response The HttpServletResponse
+     * @param registry The registry contains handler and ErrorReasonDTO
+     * @return The created response
+     * @param <E> The exception type
+     */
+    private <E extends Exception> BaseResponse handleDelegated(E e, HttpServletRequest request, HttpServletResponse response, ExceptionAdviceRegistry<E, R> registry) {
+        return registry.getHandler().handleException(e, request, response, registry.getErrorReasonDTO());
+    }
 }

api-payload/src/main/java/org/namul/api/payload/error/ExceptionAdvice.java

@@ -0,0 +1,19 @@
+package org.namul.api.payload.error;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.namul.api.payload.code.dto.ErrorReasonDTO;
+import org.namul.api.payload.handler.ExceptionAdviceHandler;
+
+/**
+ * The registry contains handler and ErrorReasonDTO
+ * @param <E> The type of exception will be handled by handler
+ * @param <R> The type of ErrorReasonDTO
+ */
+@Getter
+@RequiredArgsConstructor
+public class ExceptionAdviceRegistry<E extends Exception, R extends ErrorReasonDTO> {
+
+    private final ExceptionAdviceHandler<E, R> handler;
+    private final R errorReasonDTO;
+}

api-payload/src/main/java/org/namul/api/payload/error/ExceptionAdviceRegistry.java

@@ -0,0 +1,18 @@
+package org.namul.api.payload.error.configurer;
+
+import org.namul.api.payload.code.DefaultResponseErrorCode;
+import org.namul.api.payload.code.dto.supports.DefaultResponseErrorReasonDTO;
+import org.namul.api.payload.writer.FailureResponseWriter;
+
+public class DefaultExceptionAdviceConfigurer extends ExceptionAdviceConfigurer<DefaultResponseErrorReasonDTO> {
+
+    public DefaultExceptionAdviceConfigurer(FailureResponseWriter<DefaultResponseErrorReasonDTO> failureResponseWriter) {
+        super(failureResponseWriter);
+        super.withDefault(
+                DefaultResponseErrorCode._BAD_REQUEST.getReason(),
+                DefaultResponseErrorCode._BAD_REQUEST.getReason(),
+                DefaultResponseErrorCode._BAD_REQUEST.getReason(),
+                DefaultResponseErrorCode._INTERNAL_SERVER_ERROR.getReason()
+        );
+    }
+}