[tomcat 구현 미션 - 현재 한 부분까지]

tomcat/build.gradle

@@ -17,8 +17,8 @@ dependencies {
 
     implementation 'org.apache.commons:commons-lang3:3.12.0'
 
-    implementation 'org.projectlombok:lombok:1.18.22'
-    annotationProcessor 'org.projectlombok:lombok:1.18.22'
+    annotationProcessor 'org.projectlombok:lombok:1.18.20'
+    compileOnly 'org.projectlombok:lombok:1.18.20'
 
     testImplementation 'org.assertj:assertj-core:3.22.0'
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'

tomcat/src/main/java/nextstep/Application.java

@@ -1,16 +1,25 @@
 package nextstep;
 
 import org.apache.catalina.startup.Tomcat;
+import org.apache.coyote.http11.scanner.ControllerScanner;
+import org.apache.coyote.http11.scanner.MethodScanner;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class Application {
 
-    private static final Logger log = LoggerFactory.getLogger(Application.class);
+	private static final String BASE_PACKAGE = "org.apache.coyote.http11.controller";
 
-    public static void main(String[] args) {
-        log.info("web server start.");
-        final var tomcat = new Tomcat();
-        tomcat.start();
-    }
+	private static final Logger log = LoggerFactory.getLogger(Application.class);
+
+	public static void main(String[] args) {
+		log.info("web server start.");
+		ControllerScanner controllerScanner = new ControllerScanner(BASE_PACKAGE);
+		MethodScanner methodScanner = MethodScanner.getInstance();
+		methodScanner.scanMethods(controllerScanner.getControllerClasses());
+		methodScanner.mapMethodsWithHttpMethod();
+		log.info("methodMapByHttpMethod: {}", methodScanner.getMethodMapByHttpMethod());
+		final var tomcat = new Tomcat();
+		tomcat.start();
+	}
 }

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

@@ -1,46 +1,47 @@
 package org.apache.coyote.http11;
 
-import nextstep.jwp.exception.UncheckedServletException;
+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.handler.RequestHandler;
+import org.apache.coyote.http11.httprequest.HttpRequest;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
-import java.net.Socket;
+import nextstep.jwp.exception.UncheckedServletException;
 
 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 final Socket connection;
+	public Http11Processor(final Socket connection) {
+		this.connection = connection;
+	}
 
-    public Http11Processor(final Socket connection) {
-        this.connection = connection;
-    }
+	@Override
+	public void run() {
+		process(connection);
+	}
 
-    @Override
-    public void run() {
-        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 bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
 
-            final var responseBody = "Hello world!";
+			HttpRequest httpRequest = HttpRequest.from(bufferedReader);
+			RequestHandler requestHandler = RequestHandler.of(httpRequest);
 
-            final var response = String.join("\r\n",
-                    "HTTP/1.1 200 OK ",
-                    "Content-Type: text/html;charset=utf-8 ",
-                    "Content-Length: " + responseBody.getBytes().length + " ",
-                    "",
-                    responseBody);
+			outputStream.flush();
+		} catch (IOException | UncheckedServletException e) {
+			log.error(e.getMessage(), e);
+		}
+	}
 
-            outputStream.write(response.getBytes());
-            outputStream.flush();
-        } catch (IOException | UncheckedServletException e) {
-            log.error(e.getMessage(), e);
-        }
-    }
 }

tomcat/src/main/java/org/apache/coyote/http11/annotation/Controller.java

@@ -0,0 +1,11 @@
+package org.apache.coyote.http11.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface Controller {
+}

tomcat/src/main/java/org/apache/coyote/http11/annotation/GetMapping.java

@@ -0,0 +1,12 @@
+package org.apache.coyote.http11.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface GetMapping {
+	String value();
+}

tomcat/src/main/java/org/apache/coyote/http11/annotation/PostMapping.java

@@ -0,0 +1,12 @@
+package org.apache.coyote.http11.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface PostMapping {
+	String value();
+}

tomcat/src/main/java/org/apache/coyote/http11/annotation/RequestMapping.java

@@ -0,0 +1,12 @@
+package org.apache.coyote.http11.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+public @interface RequestMapping {
+	String value();
+}

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

@@ -0,0 +1,33 @@
+package org.apache.coyote.http11.common;
+
+import java.util.Arrays;
+
+import lombok.Getter;
+
+public enum ContentType {
+
+	HTML("html", "text/html;charset=utf-8"),
+	CSS("css", "text/css;charset=utf-8"),
+	JS("js", "application/javascript;charset=utf-8"),
+	PNG("png", "image/png"),
+	JPG("jpg", "image/jpeg"),
+	JPEG("jpeg", "image/jpeg"),
+	GIF("gif", "image/gif"),
+	DEFAULT("", "text/plain;charset=utf-8");
+
+	private final String extension;
+	@Getter
+	private final String mimeType;
+
+	ContentType(String extension, String mimeType) {
+		this.extension = extension;
+		this.mimeType = mimeType;
+	}
+
+	public static ContentType findByExtension(String extension) {
+		return Arrays.stream(values())
+			.filter(mimeType -> mimeType.extension.equalsIgnoreCase(extension))
+			.findFirst()
+			.orElse(DEFAULT);
+	}
+}

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

@@ -0,0 +1,10 @@
+package org.apache.coyote.http11.common;
+
+public enum HttpMethod {
+
+	GET,
+	POST,
+	PUT,
+	DELETE;
+
+}

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

@@ -0,0 +1,28 @@
+package org.apache.coyote.http11.common;
+
+public enum HttpStatus {
+
+	OK(200, "OK"),
+	CREATED(201, "Created"),
+	FOUND(302, "Found"),
+	NOT_FOUND(404, "Not Found"),
+	UNAUTHORIZED(401, "Unauthorized"),
+	INTERNAL_SERVER_ERROR(500, "Internal Server Erro"),
+	BAD_REQUEST(400, "Bad Request");
+
+	private final int code;
+	private final String status;
+
+	HttpStatus(int code, String status) {
+		this.code = code;
+		this.status = status;
+	}
+
+	public int getCode() {
+		return code;
+	}
+
+	public String getStatus() {
+		return status;
+	}
+}

tomcat/src/main/java/org/apache/coyote/http11/controller/IndexPageController.java

@@ -0,0 +1,14 @@
+package org.apache.coyote.http11.controller;
+
+import org.apache.coyote.http11.annotation.Controller;
+import org.apache.coyote.http11.annotation.GetMapping;
+
+@Controller
+public class IndexPageController {
+
+	@GetMapping("/")
+	public String showIndexPage() {
+		return "hello world !!";
+	}
+
+}

tomcat/src/main/java/org/apache/coyote/http11/handler/RequestHandler.java

@@ -0,0 +1,35 @@
+package org.apache.coyote.http11.handler;
+
+import java.lang.reflect.Method;
+import java.util.Map;
+
+import org.apache.coyote.http11.common.HttpMethod;
+import org.apache.coyote.http11.httprequest.HttpRequest;
+import org.apache.coyote.http11.scanner.MethodScanner;
+
+public class RequestHandler {
+
+	private HttpRequest httpRequest;
+	private Map<HttpMethod, Map<String, Method>> methodMapByHttpMethod;
+
+	private RequestHandler(HttpRequest httpRequest) {
+		this.httpRequest = httpRequest;
+		this.methodMapByHttpMethod = MethodScanner.getInstance().getMethodMapByHttpMethod();
+	}
+
+	public static RequestHandler of(HttpRequest httpRequest) {
+		return new RequestHandler(httpRequest);
+	}
+
+	private Method findMethod(HttpRequest httpRequest) {
+		Map<String, Method> methodsForHttpMethod = methodMapByHttpMethod.get(httpRequest.getHttpMethod());
+		return methodsForHttpMethod.get(httpRequest.getUri());
+	}
+
+	private void invokeMethod(Method method, HttpRequest httpRequest) throws Exception {
+		Class<?> controllerClass = method.getDeclaringClass();
+		Object controllerInstance = controllerClass.getDeclaredConstructor().newInstance();
+		Object invokedMethodResult = method.invoke(controllerInstance, httpRequest);
+
+	}
+}

tomcat/src/main/java/org/apache/coyote/http11/httprequest/HttpRequest.java

@@ -0,0 +1,94 @@
+package org.apache.coyote.http11.httprequest;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.apache.coyote.http11.common.HttpMethod;
+
+import lombok.Getter;
+
+@Getter
+public class HttpRequest {
+
+	private static final String CRLF = "\r\n";
+	private static final String REGEX_CRLF = "\\r?\\n";
+	private static final String BLANK_SPACE = " ";
+	private static final String CONTENT_LENGTH = "Content-Length";
+	private static final String TRANSFER_ENCODING = "Transfer-Encoding";
+	private static final String CHUNKED = "chunked";
+	private HttpMethod httpMethod;
+	private String uri;
+	private String httpVersion;
+	private Map<String, String> requestHeaders;
+	private String requestBody = null;
+
+	private HttpRequest(BufferedReader bufferedReader) throws IOException {
+		parseRequestLine(bufferedReader);
+		parseRequestHeaders(bufferedReader);
+		if (requestHeaders.containsKey(CONTENT_LENGTH)) {
+			parseContentLengthRequestBody(bufferedReader);
+		} else if (requestHeaders.containsKey(TRANSFER_ENCODING)) {
+			parseTransferEncodingRequestBody(bufferedReader);
+		}
+	}
+
+	public static HttpRequest from(BufferedReader bufferedReader) throws IOException {
+		return new HttpRequest(bufferedReader);
+	}
+
+	private static String getRequestLine(BufferedReader bufferedReader) throws IOException {
+		return bufferedReader.readLine();
+	}
+
+	private void parseRequestLine(BufferedReader bufferedReader) throws IOException {
+		String requestLine = getRequestLine(bufferedReader);
+		String[] splittedRequestLine = requestLine.split(BLANK_SPACE);
+		this.httpMethod = HttpMethod.valueOf(splittedRequestLine[0]);
+		this.uri = splittedRequestLine[1];
+		this.httpVersion = splittedRequestLine[2];
+	}
+
+	private static String getRequestHeader(BufferedReader bufferedReader) throws IOException {
+		StringBuilder requestHeaderBuilder = new StringBuilder();
+		String headerLine;
+		while ((headerLine = bufferedReader.readLine()) != null && !headerLine.isEmpty()) {
+			requestHeaderBuilder.append(headerLine).append(CRLF);
+		}
+		return requestHeaderBuilder.toString();
+	}
+
+	private void parseRequestHeaders(BufferedReader bufferedReader) throws IOException {
+		String requestHeader = getRequestHeader(bufferedReader);
+		this.requestHeaders = Arrays.stream(requestHeader.split(REGEX_CRLF))
+			.filter(line -> line.contains(":"))
+			.map(line -> line.split(":", 2))
+			.collect(Collectors.toMap(
+				arr -> arr[0].trim(),
+				arr -> arr[1].trim(),
+				(value1, value2) -> value1));
+	}
+
+	private void parseContentLengthRequestBody(BufferedReader bufferedReader) throws IOException {
+		int contentLength = Integer.parseInt(requestHeaders.get(CONTENT_LENGTH));
+		char[] charRequestBody = new char[contentLength];
+		int bytesRead = bufferedReader.read(charRequestBody, 0, contentLength);
+		this.requestBody = new String(charRequestBody, 0, bytesRead);
+	}
+
+	private void parseTransferEncodingRequestBody(BufferedReader bufferedReader) throws IOException {
+		StringBuilder requestBodyBuilder = new StringBuilder();
+		String chunkSizeLine;
+		while (!(chunkSizeLine = bufferedReader.readLine()).equals("0")) {
+			int chunkSize = Integer.parseInt(chunkSizeLine, 16);
+			char[] chunkData = new char[chunkSize];
+			int bytesRead = bufferedReader.read(chunkData, 0, chunkSize);
+			requestBodyBuilder.append(chunkData, 0, bytesRead);
+			bufferedReader.readLine();
+		}
+		bufferedReader.readLine();
+		this.requestBody = requestBodyBuilder.toString();
+	}
+}