[톰캣 구현하기 - 3단계] 안나(김민겸) 미션 제출합니다.

tomcat/src/main/java/com/techcourse/model/User.java

@@ -1,5 +1,7 @@
 package com.techcourse.model;
 
+import java.util.Objects;
+
 public class User {
 
     private final Long id;
@@ -27,12 +29,18 @@ public String getAccount() {
     }
 
     @Override
-    public String toString() {
-        return "User{" +
-                "id=" + id +
-                ", account='" + account + '\'' +
-                ", email='" + email + '\'' +
-                ", password='" + password + '\'' +
-                '}';
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        User user = (User)o;
+        return Objects.equals(account, user.account) && Objects.equals(password, user.password)
+            && Objects.equals(email, user.email);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(account, password, email);
     }
 }

tomcat/src/main/java/org/apache/catalina/connector/Connector.java

@@ -8,24 +8,29 @@
 import java.io.UncheckedIOException;
 import java.net.ServerSocket;
 import java.net.Socket;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 public class Connector implements Runnable {
 
     private static final Logger log = LoggerFactory.getLogger(Connector.class);
 
     private static final int DEFAULT_PORT = 8080;
-    private static final int DEFAULT_ACCEPT_COUNT = 100;
+	private static final int DEFAULT_ACCEPT_COUNT = 100;
+	private static final int DEFAULT_THREAD_COUNT = 250;
 
     private final ServerSocket serverSocket;
     private boolean stopped;
+	private final ExecutorService executorService;
 
     public Connector() {
-        this(DEFAULT_PORT, DEFAULT_ACCEPT_COUNT);
+        this(DEFAULT_PORT, DEFAULT_ACCEPT_COUNT, DEFAULT_THREAD_COUNT);
     }
 
-    public Connector(final int port, final int acceptCount) {
+    public Connector(final int port, final int acceptCount, final int maxThreads) {
         this.serverSocket = createServerSocket(port, acceptCount);
         this.stopped = false;
+		this.executorService = Executors.newFixedThreadPool(maxThreads);
     }
 
     private ServerSocket createServerSocket(final int port, final int acceptCount) {
@@ -67,7 +72,7 @@ private void process(final Socket connection) {
             return;
         }
         var processor = new Http11Processor(connection);
-        new Thread(processor).start();
+		this.executorService.execute(processor);
     }
 
     public void stop() {

tomcat/src/main/java/org/apache/coyote/http11/Http11Processor.java

@@ -1,62 +1,47 @@
 package org.apache.coyote.http11;
 
-
-import com.techcourse.db.InMemoryUserRepository;
-import com.techcourse.exception.UncheckedServletException;
-import com.techcourse.model.User;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.Socket;
 
 import org.apache.coyote.Processor;
 import org.apache.coyote.http11.request.HttpRequest;
-import org.apache.coyote.http11.request.RequestHandler;
-import org.apache.coyote.http11.session.SessionManager;
+import org.apache.coyote.http11.response.HttpResponse;
+import org.apache.coyote.http11.response.ResponsePrinter;
+import org.apache.coyote.http11.servlet.ServletContainer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.net.Socket;
-import java.net.URL;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-
 public class Http11Processor implements Runnable, Processor {
+	private static final Logger log = LoggerFactory.getLogger(Http11Processor.class);
 
-    private static final Logger log = LoggerFactory.getLogger(Http11Processor.class);
-
-    private final Socket connection;
-    private static final Map<String, String> httpRequestHeader = new HashMap<>();
-    private static final String sessionId = "JSESSIONID=sessionId";
+	private final Socket connection;
 
-    public Http11Processor(final Socket connection) {
-        this.connection = connection;
-    }
+	public Http11Processor(final Socket connection) {
+		this.connection = connection;
+	}
 
-    @Override
-    public void run() {
-        log.info("connect host: {}, port: {}", connection.getInetAddress(), connection.getPort());
-        process(connection);
-    }
+	@Override
+	public void run() {
+		log.info("connect host: {}, port: {}", connection.getInetAddress(), connection.getPort());
+		process(connection);
+	}
 
-    @Override
-    public void process(final Socket connection) {
-        try (final var inputStream = connection.getInputStream();
-             final var outputStream = connection.getOutputStream()) {
+	@Override
+	public void process(final Socket connection) {
+		try (final var inputStream = connection.getInputStream();
+			 final var outputStream = connection.getOutputStream()) {
 
-            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
-            HttpRequest httpRequest = new HttpRequest(reader);
+			BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
+			HttpRequest request = new HttpRequest(reader);
+			HttpResponse response = new HttpResponse();
 
-            RequestHandler requestHandler = new RequestHandler(httpRequest, outputStream);
-            requestHandler.handleRequest();
+			new ServletContainer().invoke(request, response);
 
-        } catch (IOException e) {
-            log.error(e.getMessage(), e);
-        }
-    }
+			new ResponsePrinter(outputStream).print(response);
+		} catch (IOException e) {
+			log.error(e.getMessage(), e);
+		}
+	}
 }

tomcat/src/main/java/org/apache/coyote/http11/common/Body.java

@@ -0,0 +1,42 @@
+package org.apache.coyote.http11.common;
+
+import static org.apache.coyote.http11.common.HttpDelimiter.*;
+import static org.apache.coyote.http11.common.HeaderKey.*;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public record Body(String value) {
+	public static Body parseRequestBody(Headers headers, BufferedReader reader) throws IOException {
+		return new Body(parseBody(headers, reader));
+	}
+
+	private static String parseBody(Headers headers, BufferedReader reader) throws IOException {
+		String contentLength = headers.getValue(CONTENT_LENGTH);
+		if (contentLength == null) {
+			return null;
+		}
+
+		int length = Integer.parseInt(contentLength);
+		if (length > 0) {
+			char[] body = new char[length];
+			reader.read(body, 0, length);
+			return new String(body);
+		} else if (length < 0) {
+			throw new IOException("Invalid Content-Length: " + length);
+		}
+		return null;
+	}
+
+	public int getContentLength() {
+		return this.value.getBytes().length;
+	}
+
+	public Properties parseProperty() {
+		Properties properties = new Properties();
+		Arrays.asList(value.split(BODY_PROPERTY_DELIMITER.getValue()))
+			.forEach(properties::add);
+		return properties;
+	}
+}

tomcat/src/main/java/org/apache/coyote/http11/common/ContentType.java

@@ -0,0 +1,32 @@
+package org.apache.coyote.http11.common;
+
+public enum ContentType {
+	APPLICATION_JSON("application/json"),
+	TEXT_CSS("text/css"),
+	TEXT_HTML("text/html"),
+	TEXT_JAVASCRIPT("text/javascript"),
+	;
+
+	private final String value;
+
+	ContentType(String value) {
+		this.value = value;
+	}
+
+	public static ContentType fromPath(String path) {
+		if (path.endsWith(".css")) {
+			return ContentType.TEXT_CSS;
+		}
+		if (path.endsWith(".js")) {
+			return ContentType.APPLICATION_JSON;
+		}
+		if (path.endsWith(".html")) {
+			return ContentType.TEXT_HTML;
+		}
+		return ContentType.APPLICATION_JSON;
+	}
+
+	public String getValue() {
+		return value;
+	}
+}

tomcat/src/main/java/org/apache/coyote/http11/common/HeaderKey.java

@@ -0,0 +1,20 @@
+package org.apache.coyote.http11.common;
+
+public enum HeaderKey {
+	CONTENT_LENGTH("Content-Length"),
+	CONTENT_TYPE("Content-Type"),
+	COOKIE("Cookie"),
+	SET_COOKIE("Set-Cookie"),
+	LOCATION("Location")
+	;
+
+	private final String value;
+
+	HeaderKey(String value) {
+		this.value = value;
+	}
+
+	public String getValue() {
+		return value;
+	}
+}

tomcat/src/main/java/org/apache/coyote/http11/common/Headers.java

@@ -0,0 +1,40 @@
+package org.apache.coyote.http11.common;
+
+import static org.apache.coyote.http11.common.HttpDelimiter.*;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public record Headers(Map<String, String> headers) {
+	public Headers() {
+		this(new HashMap<>());
+	}
+
+	public static Headers parseRequestHeader(BufferedReader reader) throws IOException {
+		HashMap<String, String> headers = new HashMap<>();
+		String line;
+		while ((line = reader.readLine()) != null && !line.isEmpty()) {
+			String[] header = line.split(HEADER_KEY_VALUE_DELIMITER.getValue());
+			headers.put(header[0].trim(), header[1].trim());
+		}
+		return new Headers(headers);
+	}
+
+	public void add(HeaderKey key, String value) {
+		headers.put(key.getValue(), value);
+	}
+
+	public String getValue(HeaderKey headerKey) {
+		return headers.get(headerKey.getValue());
+	}
+
+	public String generatePlainText() {
+		StringBuilder sb = new StringBuilder();
+		headers().forEach((key, value) -> {
+			sb.append(String.format("%s: %s \r\n", key, value));
+		});
+		return sb.toString();
+	}
+}

tomcat/src/main/java/org/apache/coyote/http11/common/HttpDelimiter.java

@@ -0,0 +1,20 @@
+package org.apache.coyote.http11.common;
+
+public enum HttpDelimiter {
+	REQUEST_LINE_DELIMITER(" "),
+	BODY_PROPERTY_DELIMITER("&"),
+	BODY_KEY_VALUE_DELIMITER("="),
+	SESSION_DELIMITER("; "),
+	HEADER_KEY_VALUE_DELIMITER(":")
+	;
+
+	private final String value;
+
+	HttpDelimiter(String value) {
+		this.value = value;
+	}
+
+	public String getValue() {
+		return value;
+	}
+}

tomcat/src/main/java/org/apache/coyote/http11/common/Properties.java

@@ -0,0 +1,27 @@
+package org.apache.coyote.http11.common;
+
+import static org.apache.coyote.http11.common.HttpDelimiter.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Properties {
+	private static final int KEY_INDEX_OF_PROPERTY = 0;
+	private static final int VALUE_INDEX_OF_PROPERTY = 1;
+
+	private final Map<String, String> properties;
+
+	public Properties() {
+		this.properties = new HashMap<>();
+	}
+
+	public void add(String rawProperty) {
+		String key = rawProperty.split(BODY_KEY_VALUE_DELIMITER.getValue())[KEY_INDEX_OF_PROPERTY];
+		String value = rawProperty.split(BODY_KEY_VALUE_DELIMITER.getValue())[VALUE_INDEX_OF_PROPERTY];
+		this.properties.put(key, value);
+	}
+
+	public String get(String key) {
+		return properties.get(key);
+	}
+}

tomcat/src/main/java/org/apache/coyote/http11/common/VersionOfProtocol.java

@@ -0,0 +1,30 @@
+package org.apache.coyote.http11.common;
+
+import static org.apache.coyote.http11.common.HttpDelimiter.*;
+
+import java.util.Objects;
+
+public record VersionOfProtocol(String value) {
+	private static final int INDEX_OF_VERSION_OF_PROTOCOL = 2;
+
+	public static VersionOfProtocol parseReqeustToVersionOfProtocol(String requestLine) {
+		return new VersionOfProtocol(requestLine.split(REQUEST_LINE_DELIMITER.getValue())[INDEX_OF_VERSION_OF_PROTOCOL]);
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (o == null || getClass() != o.getClass()) {
+			return false;
+		}
+		VersionOfProtocol that = (VersionOfProtocol)o;
+		return Objects.equals(value, that.value);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hashCode(value);
+	}
+}