어노테이션 기반 Spring MVC 프레임워크 구현하기

// RequestMapping.java
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestMapping {
  String value() default "";

  RequestMethod method() default RequestMethod.GET;
}

// Controller.java
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Controller {
  String value() default "";
}

public enum RequestMethod {
  GET, POST, // ...
}

public class ControllerScanner {
    private static final Logger log = LoggerFactory.getLogger(ControllerScanner.class);
    private Reflections reflections;

    public ControllerScanner(Object... basePackage) {
        reflections = new Reflections(basePackage);
    }

    public Map<Class<?>, Object> getControllers() throws InstantiationException, IllegalAccessException {
        Set<Class<?>> preInitiatedControllers = reflections.getTypesAnnotatedWith(Controller.class);
        return instantiateControllers(preInitiatedControllers);
    }

    Map<Class<?>, Object> instantiateControllers(Set<Class<?>> preInitiatedControlllers)
            throws InstantiationException, IllegalAccessException {
        Map<Class<?>, Object> controllers = Maps.newHashMap();
        try {
            for(Class<?> clazz : preInitiatedControlllers) {
                controllers.put(clazz, clazz.newInstance());
            }
        } catch (InstantiationException | IllegalAccessException e) {
            log.error(e.getMessage());
        }
        return controllers;
    }
}

public class HandlerKey {
    private String url; // 요청 URL
    private RequestMethod requestMethod; // HTTP 메소드 정보

    public HandlerKey(String url, RequestMethod requestMethod) {
        this.url = url;
        this.requestMethod = requestMethod;
    }

    @Override
    public String toString() {
        return "HandlerKey [url=" + url + ", requestMethod=" + requestMethod + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((requestMethod == null) ? 0 : requestMethod.hashCode());
        result = prime * result + ((url == null) ? 0 : url.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        HandlerKey other = (HandlerKey) obj;
        if (requestMethod != other.requestMethod)
            return false;
        if (url == null) {
            if (other.url != null)
                return false;
        } else if (!url.equals(other.url))
            return false;
        return true;
    }
}

public class HandlerExecution {
  public static final Logger logger = LoggerFactory.getLogger(HandlerExecution.class);
  private Object declaredObject; // 메소드가 위치하는 클래스의 인스턴스 정보
  private Method method;  // Method 정보

  public HandlerExecution(Object declaredObject, Method method) {
    this.declaredObject = declaredObject;
    this.method = method;
  }

  public ModelAndView handle(HttpServletRequest request, HttpServletResponse response) throws Exception {
    try {
        return (ModelAndView) method.invoke(declaredObject, request, response);
    } catch (IllegalAccessExcpetion | IllegalArgumentException e) {
        logger.error("{} method invoke fail. Error message : {}", method, e.getMessage());
        throw new RunTimeException(e);
    }
  }
}

public class AnnotationHandlerMapping {
  private static final Logger logger = LoggerFactory.getLogger(AnnotationHandlerMapping.class);
  private Object[] basePackage;
  private Map<HandlerKey, HandlerExecution> handlerExecutions = Maps.newHashMap();

  public AnnotationHandlerMapping(Object... basePackage) {
    this.basePackage = basePackage;
  }

  public void initalize() {
    ControllerScanner controllerScanner = new ControllerScanner(basePackage);
    Map<Class<?>, Object> cotnrollers = controllerScanner.getControllers();
    Set<Method> methods = getRequestMappingMethods(controllers.keySet());
    for(Method method : methods) {
        RequestMapping rm = method.getAnnotation(RequestMapping.class);
        logger.debud("register handlerExecution : url is {}, method is {}", rm.value()., method);
        handlerExecutions.put(createHandlerKey(rm), new HandlerExecution(controllers.get(method.getDeclaringClass()), method));
    }
  }

  private HandlerKey createHandlerKey(RequestMappign rm) {
    return new HandlerKey(rm.value(), rm.method());
  }

  @SuppressWarnings("unchecked")
  private Set<Method> getRequestMappingMethods(Set<Class<?>> controllers) {
    Set<Method> requestMappingMethods = Sets.newHashSet();
    for(Class<?> clazz : controllers) {
        requestMappingMethods.addAll(ReflectionUtils.getAllMethods(clazz, ReflectionUtils.withAnnotataion(RequestMapping.class)));
    }
    return requestMappingMethods;
  }

  // 클라이언트 요청에 해당하는 HandlerExecution 을 조회하는 매소드
  public HandlerExecution getHandler(HttpServletRequest request) {
    String requestUri = request.getRequestURI();
    RequestMethod rm = RequestMethod.valueOf(request.getMethod().toUpperCase());
    logger.debug("reqeustUri: {}, requestMethod: {}", requestUri, rm);
    return handlerExecutions.get(new HandlerKey(requestUri, rm));
  }
}

public interface HandlerMapping {
  Object getHandler(HttpServletRequest request);
}

public class LegacyHandlerMapping implements HandlerMapping {
  private Map<String, Controller> mappings = new HashMap<>();

   void initMapping() {
      // ...
   }

   @Override
   public Controller getHandler(HttpServletRequest request) {
     return mappings.get(request.getRequestURI());
   }
}

@WebServlet(name = "dispatcher", urlPatterns = "/", loadOnStartUp = 1)
public class DispacherServlet extends HttpServlet {
  private static final Logger logger = LoggerFactory.getLogger(DispacherServlet.class);
  private List<HandlerMapping> mappings = Lists.newArrayList();

  @Override
  public void init() throws ServletException {
    LegacyHandlerMapping lhm = new LegacyHandlerMapping();
    lhm.initMapping();
    AnnotationHandlerMapping ahm = AnnotationHandlerMapping("next.controller");

    ahm.initalize();
    mappings.add(lhm);
    mappings.add(ahm);
  }

  @Override
  protected void service(HttpServletRequest req, HttpServletRespisnoe resp) throws ServletException, IOException {
    Object handler = getHandler(req);
    if(handler == null) {
      throw new IllegalArgumentExcpetion("존재하지 않는 URL입니다.");
    }

    try {
      ModelAndView mav = execute(handler, req, resp);
      View view = mav.getView();
      view.render(mav.getModel(), req, resp);
    } catch (Throwable e) {
      logger.error("Exception : {}", e);
      throw new ServletException(e.getMessage());
    }
  }

  private Object getHandler(HttpServletRequest req) {
    for(HandlerMapping handlerMapping : mappings) {
      Object handler = handlerMapping.getHandler(req);
      if(handler != null) {
        return handler;
      }
    }
    return null;
  }

  private ModelAndView execurte(Object handler, HttpServletRequest req, HttpServletResponse resp) throws Exception {
    if(handler instanceof Controller) {
      return ((Contoller)handler).executea(req, resp);
    } else {
      return ((HandlerExecution)handler).handler(req, resp);
    }
  }
}

@Controller
public class TestController {

    @RequestMapping(value = "/get-test", method = RequestMethod.GET)
    public ModelAndView findUserId(HttpServletRequest request, HttpServletResponse response) {
        // ...
        return modelAndView;
    }

    @RequestMapping(value = "/post-test", method = RequestMethod.POST)
    public ModelAndView save(HttpServletRequest request, HttpServletResponse response) {
        // ...
        return modelAndView;
    }
}