3단계 - @MVC 구현(힌트) - 리뷰요청 (#245)

* feat: AnnotationHandlerMapping 구현 (요구사항 1)

* feat: forward, redirect View 구현

* refactor: Controller가 ModelAndView를 반환하도록 수정

* feat: HandlerAdapter 구현

* refactor: 점진적 리팩토링으로 RequestMapping, AnnotationHandlerMapping 공존 (요구사항 2)

* refactor: RequestMapping을 AnnotationHandlerMapping으로 변경 (요구사항 2)

* docs: Step2 요구사항 정리

* refactor: HandlerMapping을 AnnotationHandlerMapping이 바로 구현하도록 수정

* refactor: redirectView에서 ForwardView로 수정

* refactor: 클래스명 수정

* feat: form, loginForm 컨트롤러 메서드 추가

* feat: 매개변수 예외처리 추가

* refactor: redirect render 메서드 수정

* fix: loginForm URI 수정

* refactor: render 메서드 수정

* refactor: Adapter 패턴 삭제

* feat: ControllerScanner 구현 (요구사항 1)

* refactor: ControllerScanner 적용 및 HandlerKey 생성 메서드 추출 (요구사항 1)

* refactor: initMapping 메서드 인터페이스 레벨로 수정

* refactor: 변수명 수정

* feat: 어뎁터 패턴 적용

* docs: 요구사항 정리

Author: headF1rst

README.md

@@ -59,3 +59,19 @@
   * 점진적 리팩토링 도입
     * 기존 MVC와 새로운 MVC가 공존.
     * 모든 Controller가 새로운 MVC로 전환되면 기존 레거시 MVC 삭제.
+
+## 3단계 - @MVC 구현(힌트)
+
+### 요구사항 - ControllerScanner 클래스 추가
+
+* **ControllerScanner**
+  * reflections 사용해서 `@Controller`어노테이션 설정된 클래스를 **찾는다**.
+  * 찾은 각 클래스에 대한 **인스턴스 생성**을 담당한다.
+
+* **AnnotationHandlerMapping**
+  * 어노테이션 기반 매핑을 담당.
+  * @Controller 클래스의 메서드 중 `@RequestMapping` 어노테이션 설정된 모든 메서드를 **찾는다**
+  * 찾은 메서드를 바탕으로 `Map<HandlerKey, HandlerExecution>`에 값을 저장.
+    * `HandlerKey` : `@RequestMapping` 어노테이션이 갖고 있는 URL과 HTTP 메서드를 저장.
+    * `HandlerExecution` : 자바 리플랙션에서 메서드를 실행하기 위해 필요한 정보 저장.
+      * 실행할 메서드가 존재하는 클래스의 인스턴스 정보, 실행할 메서드 정보 저장.

src/main/java/core/mvc/asis/DispatcherServlet.java

@@ -1,9 +1,7 @@
 package core.mvc.asis;
 
 import core.mvc.ModelAndView;
-import core.mvc.tobe.AnnotationHandlerMapping;
-import core.mvc.tobe.HandlerExecution;
-import core.mvc.tobe.HandlerMapping;
+import core.mvc.tobe.*;
 import core.mvc.view.View;
 import exception.NotFoundException;
 import org.slf4j.Logger;
@@ -24,18 +22,22 @@ public class DispatcherServlet extends HttpServlet {
     private static final long serialVersionUID = 1L;
     private static final Logger logger = LoggerFactory.getLogger(DispatcherServlet.class);
 
+    private HandlerAdapterStorage handlerAdapterStorage;
     private RequestMapping requestMapping;
-
+    
     private AnnotationHandlerMapping AnnotationHandlerMapping;
     private final List<HandlerMapping> mappings = new ArrayList<>();
 
     @Override
     public void init() {
+        handlerAdapterStorage = new HandlerAdapterStorage();
+        handlerAdapterStorage.init();
+
         requestMapping = new RequestMapping();
         requestMapping.initMapping();
 
         AnnotationHandlerMapping = new AnnotationHandlerMapping();
-        AnnotationHandlerMapping.initialize();
+        AnnotationHandlerMapping.initMapping();
 
         mappings.add(requestMapping);
         mappings.add(AnnotationHandlerMapping);
@@ -47,22 +49,25 @@ protected void service(HttpServletRequest request, HttpServletResponse response)
         if (handler == null) {
             throw new NotFoundException(HttpStatus.NOT_FOUND);
         }
+        HandlerAdapter adapter = handlerAdapterStorage.getHandlerAdapter(handler);
+        handleAdapter(request, response, handler, adapter);
+    }
 
+    private void handleAdapter(HttpServletRequest request, HttpServletResponse response,
+                               Object handler, HandlerAdapter adapter) throws ServletException {
         try {
-            ModelAndView modelAndView = execute(request, response, handler);
-            View view = modelAndView.getView();
-            view.render(modelAndView.getModel(), request, response);
+            handle(request, response, handler, adapter);
         } catch (Exception e) {
             logger.error("Exception: {}", e.getMessage());
             throw new ServletException(e.getMessage());
         }
     }
 
-    private ModelAndView execute(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
-        if (handler instanceof Controller) {
-            return ((Controller) handler).execute(request, response);
-        }
-        return ((HandlerExecution) handler).handle(request, response);
+    private void handle(HttpServletRequest request, HttpServletResponse response,
+                        Object handler, HandlerAdapter adapter) throws Exception {
+        ModelAndView modelAndView = adapter.handle(request, response, handler);
+        View view = modelAndView.getView();
+        view.render(modelAndView.getModel(), request, response);
     }
 
     private Object getHandler(HttpServletRequest request) {

src/main/java/core/mvc/asis/RequestMapping.java

@@ -12,7 +12,8 @@ public class RequestMapping implements HandlerMapping {
     private static final Logger logger = LoggerFactory.getLogger(DispatcherServlet.class);
     private final Map<String, Controller> mappings = new HashMap<>();
 
-    void initMapping() {
+    @Override
+    public void initMapping() {
         logger.info("Initialized Request Mapping!");
         mappings.keySet().forEach(path -> {
             logger.info("Path : {}, Controller : {}", path, mappings.get(path).getClass());

src/main/java/core/mvc/tobe/AnnotationHandlerMapping.java

@@ -4,13 +4,15 @@
 import core.annotation.web.Controller;
 import core.annotation.web.RequestMapping;
 import core.annotation.web.RequestMethod;
-import org.reflections.Reflections;
+import exception.NotFoundException;
+import org.reflections.ReflectionUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpStatus;
 
 import javax.servlet.http.HttpServletRequest;
 import java.lang.reflect.Method;
-import java.util.List;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 
@@ -24,44 +26,50 @@ public AnnotationHandlerMapping(Object... basePackage) {
         this.basePackage = basePackage;
     }
 
-    public void initialize() {
-        Reflections reflections = new Reflections(basePackage);
-        Set<Class<?>> controllers = reflections.getTypesAnnotatedWith(Controller.class);
-        for (Class<?> controller : controllers) {
-            String path = controller.getAnnotation(Controller.class).value();
-            detectHandlerExecution(path, controller);
+    @Override
+    public void initMapping() {
+        ControllerScanner controllerScanner = new ControllerScanner(basePackage);
+        Map<Class<?>, Object> controllers = controllerScanner.getControllers();
+        if (controllers.isEmpty()) {
+            throw new NotFoundException(HttpStatus.NOT_FOUND);
         }
+        initHandlerExecution(controllers);
     }
 
-    @Override
-    public HandlerExecution getHandler(HttpServletRequest request) {
-        String requestURI = request.getRequestURI();
-        RequestMethod requestMethod = RequestMethod.valueOf(request.getMethod().toUpperCase());
-        return handlerExecutions.get(new HandlerKey(requestURI, requestMethod));
+    private void initHandlerExecution(Map<Class<?>, Object> controllers) {
+        Set<Method> methods = getMethods(controllers);
+        for (Method method : methods) {
+            Class<?> declaringClass = method.getDeclaringClass();
+            Controller annotation = declaringClass.getAnnotation(Controller.class);
+            addHandlerExecution(controllers.get(declaringClass), annotation.value(), method);
+        }
     }
 
-    private void detectHandlerExecution(String path, Class<?> controller) {
-        Object controllerInstance = null;
-        try {
-            controllerInstance = controller.getConstructor().newInstance();
-        } catch (Exception e) {
-            e.printStackTrace();
-            logger.error("detectHandlerExecution Exception : {}", e.getMessage());
-        }
-        List<Method> methods = List.of(controller.getDeclaredMethods());
-        for (Method method : methods) {
-            addHandlerExecution(controllerInstance, path, method);
+    private Set<Method> getMethods(Map<Class<?>, Object> controllers) {
+        Set<Method> methods = new HashSet<>();
+        for (Class<?> clazz : controllers.keySet()) {
+            methods.addAll(ReflectionUtils.getAllMethods(clazz, ReflectionUtils.withAnnotation(RequestMapping.class)));
         }
+        return methods;
     }
 
     private void addHandlerExecution(Object controllerInstance, String path, Method method) {
-        if (method.isAnnotationPresent(RequestMapping.class)) {
-            String uriPath = method.getAnnotation(RequestMapping.class).value();
-            RequestMethod requestMethod = method.getAnnotation(RequestMapping.class).method();
-            HandlerKey handlerKey = new HandlerKey(path + uriPath, requestMethod);
+        RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
+        HandlerKey handlerKey = createHandlerKey(requestMapping, path);
+        logger.debug("Add RequestMapping. URI: {}, requestMethod: {}", handlerKey, method);
+        handlerExecutions.put(handlerKey, new HandlerExecution(controllerInstance, method));
+    }
 
-            logger.debug("Add RequestMapping. URI: {}, requestMethod: {}", handlerKey, method);
-            handlerExecutions.put(handlerKey, new HandlerExecution(controllerInstance, method));
-        }
+    private HandlerKey createHandlerKey(RequestMapping requestMapping, String path) {
+        String uriPath = requestMapping.value();
+        RequestMethod requestMethod = requestMapping.method();
+        return new HandlerKey(path + uriPath, requestMethod);
+    }
+
+    @Override
+    public HandlerExecution getHandler(HttpServletRequest request) {
+        String requestURI = request.getRequestURI();
+        RequestMethod requestMethod = RequestMethod.valueOf(request.getMethod().toUpperCase());
+        return handlerExecutions.get(new HandlerKey(requestURI, requestMethod));
     }
 }

src/main/java/core/mvc/tobe/ControllerScanner.java

@@ -0,0 +1,41 @@
+package core.mvc.tobe;
+
+import core.annotation.web.Controller;
+import org.reflections.Reflections;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class ControllerScanner {
+    private static final Logger logger = LoggerFactory.getLogger(ControllerScanner.class);
+
+    private final Reflections reflections;
+
+    public ControllerScanner(Object... basePackage) {
+        this.reflections = new Reflections(basePackage);
+    }
+
+    public Map<Class<?>, Object> getControllers() {
+        Set<Class<?>> controllerClasses = reflections.getTypesAnnotatedWith(Controller.class);
+        try {
+            return instantiateControllers(controllerClasses);
+        } catch (NoSuchMethodException | InvocationTargetException | InstantiationException | IllegalAccessException e) {
+            logger.error("Fail to instantiate controllers : {}", e.getMessage());
+        }
+        return null;
+    }
+
+    private Map<Class<?>, Object> instantiateControllers(Set<Class<?>> controllerClasses)
+            throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
+        Map<Class<?>, Object> controllerInstances = new HashMap<>();
+        for (Class<?> controllerClass : controllerClasses) {
+            Object instance = controllerClass.getConstructor().newInstance();
+            controllerInstances.put(controllerClass, instance);
+        }
+        return controllerInstances;
+    }
+}

src/main/java/core/mvc/tobe/HandlerAdapter.java

@@ -0,0 +1,13 @@
+package core.mvc.tobe;
+
+import core.mvc.ModelAndView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+public interface HandlerAdapter {
+
+    boolean support(Object handler);
+
+    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
+}

src/main/java/core/mvc/tobe/HandlerAdapterStorage.java

@@ -0,0 +1,26 @@
+package core.mvc.tobe;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class HandlerAdapterStorage {
+
+    private final List<HandlerAdapter> handlerAdapters = new ArrayList<>();
+
+    public HandlerAdapterStorage() {
+    }
+
+    public void init() {
+        handlerAdapters.add(new HandlerExecution());
+        handlerAdapters.add(new SimpleControllerHandlerAdapter());
+    }
+
+    public HandlerAdapter getHandlerAdapter(Object handler) {
+        for (HandlerAdapter adapter : handlerAdapters) {
+            if (adapter.support(handler)) {
+                return adapter;
+            }
+        }
+        throw new IllegalArgumentException("매칭되는 HandlerAdapter를 찾지 못했습니다. handler = " + handler);
+    }
+}

src/main/java/core/mvc/tobe/HandlerExecution.java

@@ -7,10 +7,13 @@
 import javax.servlet.http.HttpServletResponse;
 import java.lang.reflect.Method;
 
-public class HandlerExecution {
+public class HandlerExecution implements HandlerAdapter {
 
-    private final Object bean;
-    private final Method method;
+    private Object bean;
+    private Method method;
+
+    public HandlerExecution() {
+    }
 
     public HandlerExecution(Object bean, Method method) {
         Assert.notNull(bean, "Bean이 null이어선 안됩니다.");
@@ -19,7 +22,17 @@ public HandlerExecution(Object bean, Method method) {
         this.method = method;
     }
 
-    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response) throws Exception {
+    @Override
+    public boolean support(Object handler) {
+        return (handler instanceof HandlerExecution);
+    }
+
+    @Override
+    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        return ((HandlerExecution) handler).execute(request, response);
+    }
+
+    public ModelAndView execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
         return (ModelAndView) method.invoke(bean, request, response);
     }
 }

src/main/java/core/mvc/tobe/HandlerMapping.java

@@ -4,5 +4,6 @@
 
 public interface HandlerMapping {
 
+    void initMapping();
     Object getHandler(HttpServletRequest request);
 }

src/main/java/core/mvc/tobe/SimpleControllerHandlerAdapter.java

@@ -0,0 +1,19 @@
+package core.mvc.tobe;
+
+import core.mvc.ModelAndView;
+import core.mvc.asis.Controller;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+public class SimpleControllerHandlerAdapter implements HandlerAdapter {
+    @Override
+    public boolean support(Object handler) {
+        return (handler instanceof Controller);
+    }
+
+    @Override
+    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        return ((Controller) handler).execute(request, response);
+    }
+}