[MVC 구현하기 - 1단계] 푸우(백승준) 미션 제출합니다.

mvc/src/main/java/webmvc/org/springframework/web/servlet/mvc/tobe/AnnotationHandlerMapping.java

@@ -1,11 +1,20 @@
 package webmvc.org.springframework.web.servlet.mvc.tobe;
 
+import context.org.springframework.stereotype.Controller;
 import jakarta.servlet.http.HttpServletRequest;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.BinaryOperator;
+import org.reflections.Reflections;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import web.org.springframework.web.bind.annotation.RequestMapping;
 
 public class AnnotationHandlerMapping {
 
@@ -15,15 +24,83 @@ public class AnnotationHandlerMapping {
     private final Map<HandlerKey, HandlerExecution> handlerExecutions;
 
     public AnnotationHandlerMapping(final Object... basePackage) {
+        validateBasePackage(basePackage);
         this.basePackage = basePackage;
         this.handlerExecutions = new HashMap<>();
     }
 
+    private void validateBasePackage(Object[] basePackage) {
+        for (Object o : basePackage) {
+            if (!(o instanceof String)) {
+                throw new IllegalArgumentException("basePackage 는 String 으로 입력해야 합니다");
+            }
+        }
+    }
+
     public void initialize() {
         log.info("Initialized AnnotationHandlerMapping!");
+        handlerExecutions.putAll(extractHandler());
+    }
+
+    private Map<HandlerKey, HandlerExecution> extractHandler() {
+        Reflections reflections = new Reflections(basePackage);
+        return reflections.getTypesAnnotatedWith(Controller.class).stream()
+            .map(this::extractHandlerFromClass)
+            .reduce(new HashMap<>(), migrateHandler());
+    }
+
+    private Map<HandlerKey, HandlerExecution> extractHandlerFromClass(Class<?> targetClass) {
+        Object handler = toInstance(targetClass);
+        return Arrays.stream(targetClass.getMethods())
+            .filter(method -> method.isAnnotationPresent(RequestMapping.class))
+            .map(method -> extractHandlerFromMethod(method, handler))
+            .reduce(new HashMap<>(), migrateHandler());
+    }
+
+    private Object toInstance(Class<?> targetClass) {
+        try {
+            return targetClass.getDeclaredConstructor().newInstance();
+        } catch (NoSuchMethodException | InvocationTargetException | InstantiationException |
+                 IllegalAccessException e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
+
+    private Map<HandlerKey, HandlerExecution> extractHandlerFromMethod(Method method, Object handler) {
+        HandlerExecution handlerExecution = new HandlerExecution(handler, method);
+        RequestMapping annotation = method.getAnnotation(RequestMapping.class);
+        return Arrays.stream(annotation.method())
+            .map(requestMethod -> {
+                Map<HandlerKey, HandlerExecution> extractedHandlerMapping = new HashMap<>();
+                extractedHandlerMapping.put(new HandlerKey(annotation.value(), requestMethod), handlerExecution);
+                return extractedHandlerMapping;
+            }).reduce(new HashMap<>(), migrateHandler());
+    }
+
+    private BinaryOperator<Map<HandlerKey, HandlerExecution>> migrateHandler() {
+        return (originHandler, migrateHandler) -> {
+            checkDuplication(originHandler, migrateHandler);
+            originHandler.putAll(migrateHandler);
+            return originHandler;
+        };
+    }
+
+    private void checkDuplication(Map<HandlerKey, HandlerExecution> originHandlers,
+                                  Map<HandlerKey, HandlerExecution> newHandlers) {
+        Set<HandlerKey> duplicatedHandlerKeys = new HashSet<>(originHandlers.keySet());
+        duplicatedHandlerKeys.retainAll(newHandlers.keySet());
+        if (!duplicatedHandlerKeys.isEmpty()) {
+            HandlerKey duplicatedHandlerKey = duplicatedHandlerKeys.iterator().next();
+            log.error("duplication handler : {}", duplicatedHandlerKey);
+            throw new IllegalArgumentException("Duplicated HandlerKey");
+        }
     }
 
     public Object getHandler(final HttpServletRequest request) {
-        return null;
+        Optional<HandlerKey> findHandler = handlerExecutions.keySet().stream()
+            .filter(handlerKey -> handlerKey.canHandle(request))
+            .findAny();
+        return findHandler.map(handlerExecutions::get)
+            .orElseGet(null);
     }
 }

mvc/src/main/java/webmvc/org/springframework/web/servlet/mvc/tobe/HandlerExecution.java

@@ -2,11 +2,21 @@
 
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
+import java.lang.reflect.Method;
 import webmvc.org.springframework.web.servlet.ModelAndView;
 
 public class HandlerExecution {
 
-    public ModelAndView handle(final HttpServletRequest request, final HttpServletResponse response) throws Exception {
-        return null;
+    private final Object handler;
+    private final Method handlerMethod;
+
+    public HandlerExecution(Object handler, Method handlerMethod) {
+        this.handler = handler;
+        this.handlerMethod = handlerMethod;
+    }
+
+    public ModelAndView handle(HttpServletRequest request,
+                               HttpServletResponse response) throws Exception {
+        return (ModelAndView) handlerMethod.invoke(handler, request, response);
     }
 }

mvc/src/main/java/webmvc/org/springframework/web/servlet/mvc/tobe/HandlerKey.java

@@ -1,5 +1,6 @@
 package webmvc.org.springframework.web.servlet.mvc.tobe;
 
+import jakarta.servlet.http.HttpServletRequest;
 import web.org.springframework.web.bind.annotation.RequestMethod;
 
 import java.util.Objects;
@@ -14,6 +15,11 @@ public HandlerKey(final String url, final RequestMethod requestMethod) {
         this.requestMethod = requestMethod;
     }
 
+    public boolean canHandle(HttpServletRequest httpServletRequest){
+        return httpServletRequest.getMethod().equals(requestMethod.name()) &&
+            httpServletRequest.getRequestURI().equals(url);
+    }
+
     @Override
     public String toString() {
         return "HandlerKey{" +

mvc/src/test/java/duplicate/case1/TestController.java

@@ -0,0 +1,22 @@
+package duplicate.case1;
+
+import context.org.springframework.stereotype.Controller;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import web.org.springframework.web.bind.annotation.RequestMapping;
+import web.org.springframework.web.bind.annotation.RequestMethod;
+import webmvc.org.springframework.web.servlet.ModelAndView;
+
+@Controller
+public class TestController {
+
+    private static final Logger log = LoggerFactory.getLogger(samples.TestController.class);
+
+    @RequestMapping(value = "/get-test", method = RequestMethod.GET)
+    public ModelAndView duplicatedMethod(final HttpServletRequest request,
+                                   final HttpServletResponse response) {
+        return null;
+    }
+}

mvc/src/test/java/duplicate/case2/TestController.java

@@ -0,0 +1,28 @@
+package duplicate.case2;
+
+import context.org.springframework.stereotype.Controller;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import web.org.springframework.web.bind.annotation.RequestMapping;
+import web.org.springframework.web.bind.annotation.RequestMethod;
+import webmvc.org.springframework.web.servlet.ModelAndView;
+
+@Controller
+public class TestController {
+
+    private static final Logger log = LoggerFactory.getLogger(samples.TestController.class);
+
+    @RequestMapping(value = "/get-test", method = RequestMethod.GET)
+    public ModelAndView duplicatedMethod1(final HttpServletRequest request,
+                                         final HttpServletResponse response) {
+        return null;
+    }
+
+    @RequestMapping(value = "/get-test", method = RequestMethod.GET)
+    public ModelAndView duplicatedMethod2(final HttpServletRequest request,
+                                         final HttpServletResponse response) {
+        return null;
+    }
+}

mvc/src/test/java/duplicate/case3/TestController.java

@@ -0,0 +1,28 @@
+package duplicate.case3;
+
+import context.org.springframework.stereotype.Controller;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import web.org.springframework.web.bind.annotation.RequestMapping;
+import web.org.springframework.web.bind.annotation.RequestMethod;
+import webmvc.org.springframework.web.servlet.ModelAndView;
+
+@Controller
+public class TestController {
+
+    private static final Logger log = LoggerFactory.getLogger(samples.TestController.class);
+
+    @RequestMapping(value = "/get-test", method = {
+        RequestMethod.GET,
+        RequestMethod.GET,
+        RequestMethod.GET,
+        RequestMethod.GET,
+        RequestMethod.GET
+    })
+    public ModelAndView duplicatedMethod1(final HttpServletRequest request,
+                                          final HttpServletResponse response) {
+        return null;
+    }
+}

mvc/src/test/java/samples/TestController.java

@@ -30,4 +30,21 @@ public ModelAndView save(final HttpServletRequest request, final HttpServletResp
         modelAndView.addObject("id", request.getAttribute("id"));
         return modelAndView;
     }
+
+    @RequestMapping(value = "/multi-method-test", method = {RequestMethod.GET, RequestMethod.POST} )
+    public ModelAndView multiHandle(final HttpServletRequest request, final HttpServletResponse response) {
+        log.info("test controller multi-handle method");
+        String method = request.getMethod();
+        if("GET".equals(method)){
+            final var modelAndView = new ModelAndView(new JspView(""));
+            modelAndView.addObject("id", "getPooh");
+            return modelAndView;
+        }
+        if("POST".equals(method)){
+            final var modelAndView = new ModelAndView(new JspView(""));
+            modelAndView.addObject("id", "postPooh");
+            return modelAndView;
+        }
+        throw new IllegalArgumentException("해당 요청을 Handling 할 수 없는 핸들러입니다.");
+    }
 }

mvc/src/test/java/webmvc/org/springframework/web/servlet/mvc/tobe/AnnotationHandlerMappingTest.java

@@ -6,6 +6,7 @@
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -19,6 +20,57 @@ void setUp() {
         handlerMapping.initialize();
     }
 
+    @Test
+    void methodDuplicationException_existMappingInOtherClass_case1() {
+        // given & when & then
+        AnnotationHandlerMapping duplicatedHandlerMapping = new AnnotationHandlerMapping(
+            "samples",
+            "duplicate.case1");
+        assertThatThrownBy(() -> duplicatedHandlerMapping.initialize())
+            .isInstanceOf(IllegalArgumentException.class)
+            .hasMessage("Duplicated HandlerKey");
+    }
+
+    @Test
+    void methodDuplicationException_existMappingIntSameClass_case2() {
+        // given & when & then
+        AnnotationHandlerMapping duplicatedHandlerMapping = new AnnotationHandlerMapping(
+            "duplicate.case2");
+        assertThatThrownBy(() -> duplicatedHandlerMapping.initialize())
+            .isInstanceOf(IllegalArgumentException.class)
+            .hasMessage("Duplicated HandlerKey");
+    }
+
+    @Test
+    void methodDuplicationException_duplicateMappingInOneMethod_case3() {
+        // given & when & then
+        AnnotationHandlerMapping duplicatedHandlerMapping = new AnnotationHandlerMapping(
+            "duplicate.case3");
+        assertThatThrownBy(() -> duplicatedHandlerMapping.initialize())
+            .isInstanceOf(IllegalArgumentException.class)
+            .hasMessage("Duplicated HandlerKey");
+    }
+
+    @Test
+    void oneMethodCanCreateManyHttpRequestMappings() throws Exception {
+        final var request = mock(HttpServletRequest.class);
+        final var response = mock(HttpServletResponse.class);
+
+        when(request.getAttribute("id")).thenReturn("gugu");
+        when(request.getRequestURI()).thenReturn("/multi-method-test");
+        when(request.getMethod()).thenReturn("GET");
+
+        final var handlerExecution = (HandlerExecution) handlerMapping.getHandler(request);
+        final var getModelAndView = handlerExecution.handle(request, response);
+
+        when(request.getMethod()).thenReturn("POST");
+
+        final var postModelAndView = handlerExecution.handle(request, response);
+
+        assertThat(getModelAndView.getObject("id")).isEqualTo("getPooh");
+        assertThat(postModelAndView.getObject("id")).isEqualTo("postPooh");
+    }
+
     @Test
     void get() throws Exception {
         final var request = mock(HttpServletRequest.class);

study/src/main/java/servlet/com/example/CharacterEncodingFilter.java

@@ -8,9 +8,13 @@
 @WebFilter("/*")
 public class CharacterEncodingFilter implements Filter {
 
+    public static final String DEFAULT_ENCODING = "UTF-8";
+
     @Override
     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
         request.getServletContext().log("doFilter() 호출");
+        request.setCharacterEncoding(DEFAULT_ENCODING);
+        response.setCharacterEncoding(DEFAULT_ENCODING);
         chain.doFilter(request, response);
     }
 }

study/src/test/java/reflection/Junit3TestRunner.java

@@ -1,13 +1,25 @@
 package reflection;
 
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
 import org.junit.jupiter.api.Test;
 
 class Junit3TestRunner {
 
     @Test
     void run() throws Exception {
         Class<Junit3Test> clazz = Junit3Test.class;
+        List<Method> methods = Arrays.stream(clazz.getMethods())
+            .filter(method -> method.getName().startsWith("test"))
+            .collect(Collectors.toList());
 
-        // TODO Junit3Test에서 test로 시작하는 메소드 실행
+        Junit3Test junit3Test = clazz.getConstructor()
+            .newInstance();
+
+        for (Method method : methods) {
+            method.invoke(junit3Test);
+        }
     }
 }

study/src/test/java/reflection/Junit4TestRunner.java

@@ -1,13 +1,31 @@
 package reflection;
 
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
 import org.junit.jupiter.api.Test;
 
 class Junit4TestRunner {
 
     @Test
     void run() throws Exception {
         Class<Junit4Test> clazz = Junit4Test.class;
+        List<Method> methods = Arrays.stream(clazz.getMethods())
+            .filter(method -> haveTestAnnotation(method))
+            .collect(Collectors.toList());
 
-        // TODO Junit4Test에서 @MyTest 애노테이션이 있는 메소드 실행
+        Junit4Test junit4Test = clazz.getConstructor()
+            .newInstance();
+
+        for (Method method : methods) {
+            method.invoke(junit4Test);
+        }
+    }
+
+    private boolean haveTestAnnotation(Method method) {
+        return Arrays.stream(method.getDeclaredAnnotations())
+            .anyMatch(annotation -> annotation instanceof MyTest);
     }
 }