[Http] HttpRequest.body 관련 기능 개발

src/main/java/app/handler/RegisterHandlerImpl.java

@@ -6,22 +6,23 @@
 import exception.ServiceException;
 import http.HttpMethod;
 import http.request.HttpRequest;
+import web.dispatch.argument.QueryParameters;
 import web.handler.SingleArgHandler;
 import web.response.HandlerResponse;
 import web.response.StaticViewResponse;
 
-public class RegisterHandlerImpl extends SingleArgHandler<HttpRequest> {
+public class RegisterHandlerImpl extends SingleArgHandler<QueryParameters> {
     public RegisterHandlerImpl() {
         super(HttpMethod.GET,
                 "/create");
     }
 
     @Override
-    public HandlerResponse handle(HttpRequest request) {
-        String userId = request.getQueryValue("userId").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "userId required"));
-        String password = request.getQueryValue("password").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "password required"));
-        String name = request.getQueryValue("name").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "name required"));
-        String email = request.getQueryValue("email").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "email required"));
+    public HandlerResponse handle(QueryParameters params) {
+        String userId = params.getQueryValue("userId").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "userId required"));
+        String password = params.getQueryValue("password").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "password required"));
+        String name = params.getQueryValue("name").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "name required"));
+        String email = params.getQueryValue("email").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "email required"));
         Database.addUser(new User(userId, password, name, email));
         return StaticViewResponse.of("/login");
     }

src/main/java/config/AppConfig.java

@@ -5,17 +5,18 @@
 import exception.handler.ErrorExceptionHandler;
 import exception.handler.ServiceExceptionHandler;
 import exception.handler.UnhandledErrorHandler;
-import http.request.HttpBufferedReaderRequestConverter;
+import http.request.BufferedReaderHttpRequestConverter;
 import http.request.HttpRequestConverter;
-import http.response.HttpBufferedStreamResponseConverter;
+import http.request.InputStreamHttpRequestConverter;
+import http.response.HttpResponseBufferedStreamConverter;
 import http.response.HttpResponseConverter;
-import web.dispatch.ArgumentResolver;
+import web.dispatch.argument.ArgumentResolver;
 import web.dispatch.Dispatcher;
 import web.dispatch.HandlerAdapter;
 import web.dispatch.adapter.DefaultHandlerAdapter;
 import web.dispatch.adapter.SingleArgHandlerAdapter;
-import web.dispatch.argument.HttpRequestResolver;
-import web.dispatch.argument.QueryParamsResolver;
+import web.dispatch.argument.resolver.HttpRequestResolver;
+import web.dispatch.argument.resolver.QueryParamsResolver;
 import web.handler.StaticContentHandler;
 import web.handler.WebHandler;
 import web.renderer.StaticViewRenderer;
@@ -25,19 +26,22 @@
 
 public class AppConfig {
     //Http
-    public HttpBufferedReaderRequestConverter httpBufferedReaderRequestConverter(){
-        return new HttpBufferedReaderRequestConverter();
+    public HttpRequestConverter httpRequestConverter(){
+        return inputStreamHttpRequestConverter();
+    }
+    public HttpResponseConverter httpResponseConverter(){
+        return httpResponseBufferedStreamConverter();
     }
 
-    public HttpBufferedStreamResponseConverter httpBufferedStreamResponseConverter(){
-        return new HttpBufferedStreamResponseConverter();
+    public BufferedReaderHttpRequestConverter httpBufferedReaderRequestConverter(){
+        return new BufferedReaderHttpRequestConverter();
     }
 
-    public HttpRequestConverter httpRequestConverter(){
-        return httpBufferedReaderRequestConverter();
+    public HttpResponseBufferedStreamConverter httpResponseBufferedStreamConverter(){
+        return new HttpResponseBufferedStreamConverter();
     }
-    public HttpResponseConverter httpResponseConverter(){
-        return httpBufferedStreamResponseConverter();
+    public InputStreamHttpRequestConverter inputStreamHttpRequestConverter(){
+        return new InputStreamHttpRequestConverter();
     }
 
 

src/main/java/http/request/BufferedReaderHttpRequestConverter.java

@@ -0,0 +1,42 @@
+package http.request;
+
+import exception.ErrorException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.net.Socket;
+
+public class BufferedReaderHttpRequestConverter implements HttpRequestConverter {
+    private static final Logger logger = LoggerFactory.getLogger(BufferedReaderHttpRequestConverter.class);
+    public HttpRequest parseRequest(Socket connection){
+
+        try {
+            BufferedReader bufferedReader = new BufferedReader(
+                    new InputStreamReader(
+                            connection.getInputStream()));
+
+            HttpRequest request = HttpRequest.from(bufferedReader.readLine());
+            request.setRequestAddress(connection.getInetAddress());
+
+            setHeaders(bufferedReader, request);
+
+            //TODO: Body 파싱 추가
+
+            return request;
+
+        } catch (IOException e) {
+            throw new ErrorException("HttpRequestParseError: IO Exception", e);
+        }
+    }
+
+    private void setHeaders(BufferedReader bufferedReader, HttpRequest request) throws IOException {
+        String line;
+        while ((line = bufferedReader.readLine())!= null) {
+            if(line.isEmpty()) break;
+            int idx = line.indexOf(':');
+            if(idx<0) throw new ErrorException("HttpRequestHeaderParseError");
+            request.setHeader(line.substring(0, idx).strip(), line.substring(idx+1).strip());
+        }
+    }
+}

src/main/java/http/request/HttpRequest.java

@@ -5,33 +5,47 @@
 import exception.ServiceException;
 import http.HttpMethod;
 
-import java.io.UnsupportedEncodingException;
 import java.net.InetAddress;
 import java.net.URI;
-import java.net.URLDecoder;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 
 public class HttpRequest {
     private final HttpMethod method;
-    private final Map<String, String> headers;
-    private final URI uri;
+    private final Map<String, String> headers; //TODO: Map<String, List<String>> 타입으로 변경
     private String httpVersion;
+    private final URI uri;
     private String contentType;
-
-    //TODO: Map<String, List<String>> 타입으로 변경
-    private Map<String, String> queryMap;
-
     private byte[] body;
+
     private InetAddress requestAddress;
 
+    private HttpRequest (HttpMethod method,
+                         String target,
+                         String httpVersion) {
+        this.method = method;
+        this.uri = URI.create(target);
+        this.httpVersion = httpVersion;
+        this.headers = new HashMap<>();
+    }
+
+    public byte[] getBody() {
+        return body;
+    }
+
+    public String getContentType() {
+        return contentType;
+    }
     public String getHeader(String key){
         return headers.get(key.toLowerCase());
     }
+
     public void setHeader(String key, String value){
         headers.put(key.toLowerCase(), value);
+        if (key.equalsIgnoreCase("Content-Type")) {
+            this.contentType = value;
+        }
     }
 
     public List<String> getHeaders(){
@@ -46,31 +60,10 @@ public String getQueryString(){
         return uri.getQuery();
     }
 
-    public List<String> getQueryKeys(){
-        return queryMap.keySet().stream().toList();
-    }
-
-    public Optional<String> getQueryValue(String key){
-        if (queryMap == null) {
-            queryMap = parseQueryToMap(uri.getQuery());
-        }
-        return Optional.ofNullable(queryMap.get(key));
-    }
-
     public HttpMethod getMethod(){
         return this.method;
     }
 
-    private HttpRequest (HttpMethod method,
-                         String target,
-                         String httpVersion) {
-        this.method = method;
-        this.uri = URI.create(target);
-        this.httpVersion = httpVersion;
-        this.headers = new HashMap<>();
-
-    }
-
     public void setRequestAddress(InetAddress requestAddress) {
         this.requestAddress = requestAddress;
     }
@@ -93,33 +86,7 @@ public static HttpRequest from(String requestLine){
         }
     }
 
-
-    private Map<String, String> parseQueryToMap(String queryString) {
-        Map<String, String> map = new HashMap<>();
-        if (queryString == null || queryString.isBlank()) {
-            return map;
-        }
-
-        String[] pairs = queryString.strip().split("&");
-        for (String pair : pairs) {
-            if (pair.isEmpty()) continue;
-
-            String[] kv = pair.split("=", 2); // value에 '=' 들어가도 OK
-            String rawKey = kv[0];
-            String rawValue = kv.length == 2 ? kv[1] : "";
-
-            String key = urlDecode(rawKey);
-            String value = urlDecode(rawValue);
-            map.put(key, value);
-        }
-        return map;
-    }
-
-    private String urlDecode(String s) {
-        try {
-            return URLDecoder.decode(s, "UTF-8");
-        } catch (UnsupportedEncodingException e) {
-            throw new IllegalStateException("UTF-8 not supported", e);
-        }
+    public void setBody(byte[] body){
+        this.body = body;
     }
 }