🚀 4단계 - Controller 메서드 인자 매핑

README.md

@@ -39,4 +39,13 @@
 
 ### [STEP3] JSON View 구현하기
 #### TODO
-- [ ] JsonView render 구현 후 UserController가 정상동작하는지 테스트
+- [X] JsonView render 구현 후 UserController가 정상동작하는지 테스트
+
+### [STEP4] 4단계 - Controller 메서드 인자 매핑
+#### TODO
+- [X] method의 parameter types를 통해 parsing할 수 있는 parameter parser
+  - [X] query param parser -> 메소드 파라미터의 type, name 보고 request.getParameter 에서 추출
+  - [X] path variable parser -> @PathVariable이 있을경우 메소드 파라미터의 type, name 보고 /{}/{} path에 특정한 양식 ({})으로 추출 
+  - [X] parameter typed parser -> 특정 타입을 deserialization. request.getParameter에서 추출
+- [X] handlerExecution에서 invoke 시점에 parser로 parsing
+- [X] testusercontroller로 확인

app/build.gradle

@@ -45,3 +45,7 @@ sourceSets {
         java.destinationDirectory.set(file('src/main/webapp/WEB-INF/classes'))
     }
 }
+
+compileJava {
+    options.compilerArgs << '-parameters'
+}

app/src/main/java/camp/nextstep/controller/support/DefaultExceptionHandlers.java

@@ -10,6 +10,11 @@
 @ControllerAdvice
 public class DefaultExceptionHandlers {
 
+    @ExceptionHandler(IllegalArgumentException.class)
+    public void handle(IllegalArgumentException ex, HttpServletRequest request, HttpServletResponse response) {
+        response.setStatus(400);
+    }
+
     @ExceptionHandler(NoHandlerFoundException.class)
     public void handle(NoHandlerFoundException ex, HttpServletRequest request, HttpServletResponse response) {
         response.setStatus(404);

mvc/build.gradle

@@ -35,3 +35,7 @@ dependencies {
 test {
     useJUnitPlatform()
 }
+
+tasks.withType(JavaCompile) {
+    options.compilerArgs.add("-parameters")
+}

mvc/src/main/java/com/interface21/web/parameter/ParameterParser.java

@@ -0,0 +1,11 @@
+package com.interface21.web.parameter;
+
+import jakarta.servlet.http.HttpServletRequest;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public interface ParameterParser {
+    Object parse(final Method method, final Parameter parameter, final HttpServletRequest request);
+
+}

mvc/src/main/java/com/interface21/web/parameter/ParameterParsers.java

@@ -0,0 +1,48 @@
+package com.interface21.web.parameter;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+public class ParameterParsers {
+
+    private final List<ParameterParser> parsers = new ArrayList<>(Arrays.asList(new PathVariableParser(), new QueryParamParser()));
+
+    public ParameterParsers() {
+
+    }
+
+    public ParameterParsers(ParameterParser... parsers) {
+        this.parsers.addAll(Arrays.asList(parsers));
+    }
+
+    public Object[] parse(final Method method, final HttpServletRequest request, final HttpServletResponse response) {
+        var parameters = method.getParameters();
+        var params = new Object[parameters.length];
+
+        for (int i = 0; i < parameters.length; i++) {
+            var parsedParam = parse(method, parameters[i], request, response);
+            params[i] = parsedParam;
+        }
+        return params;
+    }
+
+    private Object parse(final Method method, final Parameter parameter, final HttpServletRequest request, final HttpServletResponse response) {
+        if (parameter.getType().equals(HttpServletRequest.class)) {
+            return request;
+        }
+        if (parameter.getType().equals(HttpServletResponse.class)) {
+            return response;
+        }
+
+        return parsers.stream().map(parser -> parser.parse(method, parameter, request)).filter(Objects::nonNull).findFirst()
+                .orElseThrow(IllegalArgumentException::new);
+    }
+
+}

mvc/src/main/java/com/interface21/web/parameter/ParameterTypedParser.java

@@ -0,0 +1,58 @@
+package com.interface21.web.parameter;
+
+import com.interface21.web.support.TypedParsers;
+import jakarta.servlet.http.HttpServletRequest;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.Arrays;
+
+public class ParameterTypedParser implements ParameterParser {
+    private final Class<?> type;
+
+    public ParameterTypedParser(Class<?> type) {
+        this.type = type;
+    }
+
+    @Override
+    public Object parse(Method method, Parameter parameter, HttpServletRequest request) {
+        if (!parameter.getType().equals(type)) {
+            return null;
+        }
+        var constructors = type.getDeclaredConstructors();
+        var fullyFieldConstructor = Arrays.stream(constructors).filter(constructor -> constructor.getParameterCount() == type.getDeclaredFields().length).findFirst();
+        if (fullyFieldConstructor.isPresent()) {
+            return parseFully(fullyFieldConstructor.get(), request);
+        }
+        var defaultConstructor = Arrays.stream(constructors).filter(constructor -> constructor.getParameterCount() == 0).findFirst();
+        return defaultConstructor.map(constructor -> parseDefault(constructor, request)).orElse(null);
+    }
+
+    private Object parseFully(Constructor<?> constructor, HttpServletRequest request) {
+        var parameters = constructor.getParameters();
+        var args = new Object[parameters.length];
+        for (int i = 0; i < parameters.length; i++) {
+            args[i] = TypedParsers.parse(parameters[i].getType(), request.getParameter(parameters[i].getName()));
+        }
+        try {
+            return constructor.newInstance(args);
+        } catch (Exception e) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    private Object parseDefault(Constructor<?> constructor, HttpServletRequest request) {
+        try {
+            var instance = constructor.newInstance();
+            for (Field field : type.getDeclaredFields()) {
+                field.setAccessible(true);
+                field.set(instance, TypedParsers.parse(field.getType(), request.getParameter(field.getName())));
+            }
+            return instance;
+        } catch (Exception e) {
+            throw new IllegalArgumentException();
+        }
+    }
+}

mvc/src/main/java/com/interface21/web/parameter/PathVariableParser.java

@@ -0,0 +1,33 @@
+package com.interface21.web.parameter;
+
+
+import com.interface21.web.bind.annotation.PathVariable;
+import com.interface21.web.bind.annotation.RequestMapping;
+import com.interface21.web.support.PathPatternUtil;
+import com.interface21.web.support.TypedParsers;
+import jakarta.servlet.http.HttpServletRequest;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public class PathVariableParser implements ParameterParser {
+
+    @Override
+    public Object parse(Method method, Parameter parameter, HttpServletRequest request) {
+        var variable = parameter.getAnnotation(PathVariable.class);
+        var requestMapping = method.getAnnotation(RequestMapping.class);
+        if (variable == null || requestMapping == null) {
+            return null;
+        }
+        var name = variable.name();
+        if (name.isBlank()) {
+            name = parameter.getName();
+        }
+        var param = PathPatternUtil.getUriValue(requestMapping.value(), request.getRequestURI(), name);
+        if (param == null) {
+            return null;
+        }
+        return TypedParsers.parse(parameter.getType(), param);
+    }
+
+}

mvc/src/main/java/com/interface21/web/parameter/QueryParamParser.java

@@ -0,0 +1,21 @@
+package com.interface21.web.parameter;
+
+
+import com.interface21.web.support.TypedParsers;
+import jakarta.servlet.http.HttpServletRequest;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public class QueryParamParser implements ParameterParser {
+
+    @Override
+    public Object parse(Method method, Parameter parameter, HttpServletRequest request) {
+        var param = request.getParameter(parameter.getName());
+        if (param == null) {
+            return null;
+        }
+        return TypedParsers.parse(parameter.getType(), param);
+    }
+
+}

mvc/src/main/java/com/interface21/web/support/PathPatternParser.java

@@ -0,0 +1,42 @@
+package com.interface21.web.support;
+
+import java.util.*;
+import java.util.regex.Pattern;
+
+public class PathPatternParser {
+
+    private final Pattern pattern;
+    private final List<String> variableNames = new ArrayList<>();
+
+    public PathPatternParser(String pattern) {
+        String regex = buildRegex(pattern);
+        this.pattern = Pattern.compile(regex);
+    }
+
+    private String buildRegex(String pattern) {
+        var matcher = Pattern.compile("\\{([^}]+)}").matcher(pattern);
+        StringBuffer buffer = new StringBuffer();
+        while (matcher.find()) {
+            variableNames.add(matcher.group(1));
+            matcher.appendReplacement(buffer, "([^/]+)");
+        }
+        matcher.appendTail(buffer);
+        return buffer.toString();
+    }
+
+    public boolean matches(String path) {
+        return pattern.matcher(path).matches();
+    }
+
+    public Map<String, String> extractUriVariables(String path) {
+        var matcher = pattern.matcher(path);
+        if (!matcher.matches()) {
+            return Collections.emptyMap();
+        }
+        Map<String, String> variables = new HashMap<>();
+        for (int i = 0; i < variableNames.size(); i++) {
+            variables.put(variableNames.get(i), matcher.group(i + 1));
+        }
+        return variables;
+    }
+}

mvc/src/main/java/com/interface21/web/support/PathPatternUtil.java

@@ -0,0 +1,24 @@
+package com.interface21.web.support;
+
+import java.util.Map;
+
+public class PathPatternUtil {
+
+    public static String getUriValue(String pattern, String path, String key) {
+        final Map<String, String> uriVariables = getUriVariables(pattern, path);
+        return uriVariables.get(key);
+    }
+
+    public static Map<String, String> getUriVariables(String pattern, String path) {
+        if (!isUrlMatch(pattern, path)) {
+            return Map.of();
+        }
+        final PathPatternParser parser = new PathPatternParser(pattern);
+        return parser.extractUriVariables(path);
+    }
+
+    public static boolean isUrlMatch(String pattern, String path) {
+        final PathPatternParser parser = new PathPatternParser(pattern);
+        return parser.matches(path);
+    }
+}

mvc/src/main/java/com/interface21/web/support/TypedParser.java

@@ -0,0 +1,40 @@
+package com.interface21.web.support;
+
+
+import java.util.function.Function;
+
+public class TypedParser {
+    protected static final TypedParser STRING = new TypedParser(String.class, (s) -> s);
+    protected static final TypedParser INT = new TypedParser(int.class, Integer::parseInt);
+    protected static final TypedParser WRAPPER_INTEGER = new TypedParser(Integer.class, Integer::parseInt);
+    protected static final TypedParser LONG = new TypedParser(long.class, Long::parseLong);
+    protected static final TypedParser WRAPPER_LONG = new TypedParser(Long.class, Integer::parseInt);
+    protected static final TypedParser BOOLEAN = new TypedParser(boolean.class, Boolean::parseBoolean);
+    protected static final TypedParser WRAPPER_BOOLEAN = new TypedParser(Boolean.class, Boolean::parseBoolean);
+    protected static final TypedParser SHORT = new TypedParser(short.class, Short::parseShort);
+    protected static final TypedParser WRAPPER_SHORT = new TypedParser(Short.class, Short::parseShort);
+    protected static final TypedParser FLOAT = new TypedParser(float.class, Float::parseFloat);
+    protected static final TypedParser WRAPPER_FLOAT = new TypedParser(Float.class, Float::parseFloat);
+    protected static final TypedParser DOUBLE = new TypedParser(double.class, Double::parseDouble);
+    protected static final TypedParser WRAPPER_DOUBLE = new TypedParser(Double.class, Double::parseDouble);
+    protected static final TypedParser CHAR = new TypedParser(char.class,  s -> s.charAt(0));
+    protected static final TypedParser WRAPPER_CHAR = new TypedParser(Character.class,  s -> s.charAt(0));
+
+    private final Class<?> type;
+    private final Function<String, Object> parser;
+
+    public TypedParser(Class<?> type, Function<String, Object> parser) {
+        this.type = type;
+        this.parser = parser;
+    }
+
+    protected boolean canParse(Class<?> type) {
+        return type.equals(this.type);
+    }
+
+    protected Object parse(String value) {
+        return parser.apply(value);
+    }
+
+
+}

mvc/src/main/java/com/interface21/web/support/TypedParsers.java

@@ -0,0 +1,19 @@
+package com.interface21.web.support;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TypedParsers {
+    private static List<TypedParser> parserList = new ArrayList<>(List.of(TypedParser.STRING, TypedParser.INT, TypedParser.WRAPPER_INTEGER, TypedParser.LONG, TypedParser.WRAPPER_LONG, TypedParser.BOOLEAN, TypedParser.WRAPPER_BOOLEAN, TypedParser.SHORT, TypedParser.WRAPPER_SHORT, TypedParser.FLOAT, TypedParser.WRAPPER_FLOAT, TypedParser.DOUBLE, TypedParser.WRAPPER_DOUBLE, TypedParser.CHAR, TypedParser.WRAPPER_CHAR));
+
+
+    public static void add(TypedParser... parsers) {
+        parserList.addAll(List.of(parsers));
+    }
+
+    public static Object parse(final Class<?> type, final String value) {
+        return parserList.stream().filter(parser -> parser.canParse(type)).findFirst()
+                .orElseThrow(IllegalArgumentException::new)
+                .parse(value);
+    }
+}

mvc/src/main/java/com/interface21/webmvc/servlet/ControllerAdviceHandlerMapping.java

@@ -2,15 +2,18 @@
 
 import com.interface21.context.stereotype.ControllerAdvice;
 import com.interface21.web.bind.annotation.ExceptionHandler;
+import com.interface21.web.parameter.ParameterParsers;
 
 import java.lang.reflect.Method;
 import java.util.Arrays;
 
 public class ControllerAdviceHandlerMapping implements HandlerMapping<ExceptionHandlers> {
 
+    private final ParameterParsers parsers;
     private final Object[] basePackage;
 
-    public ControllerAdviceHandlerMapping(final Object... basePackage) {
+    public ControllerAdviceHandlerMapping(ParameterParsers parsers, final Object... basePackage) {
+        this.parsers = parsers;
         this.basePackage = basePackage;
     }
 
@@ -28,7 +31,7 @@ private void mappingHandler(final ExceptionHandlers handlers, final Object contr
             return;
         }
         for (Class<? extends Throwable> exceptionClass : handler.value()) {
-            var execution = new HandlerExecution(controllerInstance, method);
+            var execution = new HandlerExecution(controllerInstance, method, parsers);
             handlers.add(exceptionClass, execution);
         }
     }