[톰캣] - 1,2 단계 박스터 미션 제출합니다

study/src/test/java/study/IOStreamTest.java

@@ -4,19 +4,33 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
-import java.io.*;
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 
 /**
  * 자바는 스트림(Stream)으로부터 I/O를 사용한다.
  * 입출력(I/O)은 하나의 시스템에서 다른 시스템으로 데이터를 이동 시킬 때 사용한다.
- *
+ * <p>
  * InputStream은 데이터를 읽고, OutputStream은 데이터를 쓴다.
  * FilterStream은 InputStream이나 OutputStream에 연결될 수 있다.
  * FilterStream은 읽거나 쓰는 데이터를 수정할 때 사용한다. (e.g. 암호화, 압축, 포맷 변환)
- *
+ * <p>
  * Stream은 데이터를 바이트로 읽고 쓴다.
  * 바이트가 아닌 텍스트(문자)를 읽고 쓰려면 Reader와 Writer 클래스를 연결한다.
  * Reader, Writer는 다양한 문자 인코딩(e.g. UTF-8)을 처리할 수 있다.
@@ -26,7 +40,7 @@ class IOStreamTest {
 
     /**
      * OutputStream 학습하기
-     *
+     * <p>
      * 자바의 기본 출력 클래스는 java.io.OutputStream이다.
      * OutputStream의 write(int b) 메서드는 기반 메서드이다.
      * <code>public abstract void write(int b) throws IOException;</code>
@@ -39,7 +53,7 @@ class OutputStream_학습_테스트 {
          * OutputStream의 서브 클래스(subclass)는 특정 매체에 데이터를 쓰기 위해 write(int b) 메서드를 사용한다.
          * 예를 들어, FilterOutputStream은 파일로 데이터를 쓸 때,
          * 또는 DataOutputStream은 자바의 primitive type data를 다른 매체로 데이터를 쓸 때 사용한다.
-         * 
+         * <p>
          * write 메서드는 데이터를 바이트로 출력하기 때문에 비효율적이다.
          * <code>write(byte[] data)</code>와 <code>write(byte b[], int off, int len)</code> 메서드는
          * 1바이트 이상을 한 번에 전송 할 수 있어 훨씬 효율적이다.
@@ -53,6 +67,7 @@ class OutputStream_학습_테스트 {
              * todo
              * OutputStream 객체의 write 메서드를 사용해서 테스트를 통과시킨다
              */
+            outputStream.write(bytes);
 
             final String actual = outputStream.toString();
 
@@ -63,7 +78,7 @@ class OutputStream_학습_테스트 {
         /**
          * 효율적인 전송을 위해 스트림에서 버퍼링을 사용 할 수 있다.
          * BufferedOutputStream 필터를 연결하면 버퍼링이 가능하다.
-         * 
+         * <p>
          * 버퍼링을 사용하면 OutputStream을 사용할 때 flush를 사용하자.
          * flush() 메서드는 버퍼가 아직 가득 차지 않은 상황에서 강제로 버퍼의 내용을 전송한다.
          * Stream은 동기(synchronous)로 동작하기 때문에 버퍼가 찰 때까지 기다리면
@@ -78,6 +93,7 @@ class OutputStream_학습_테스트 {
              * flush를 사용해서 테스트를 통과시킨다.
              * ByteArrayOutputStream과 어떤 차이가 있을까?
              */
+            outputStream.flush();
 
             verify(outputStream, atLeastOnce()).flush();
             outputStream.close();
@@ -96,19 +112,22 @@ class OutputStream_학습_테스트 {
              * try-with-resources를 사용한다.
              * java 9 이상에서는 변수를 try-with-resources로 처리할 수 있다.
              */
+            try (outputStream) {
+
+            }
 
             verify(outputStream, atLeastOnce()).close();
         }
     }
 
     /**
      * InputStream 학습하기
-     *
+     * <p>
      * 자바의 기본 입력 클래스는 java.io.InputStream이다.
      * InputStream은 다른 매체로부터 바이트로 데이터를 읽을 때 사용한다.
      * InputStream의 read() 메서드는 기반 메서드이다.
      * <code>public abstract int read() throws IOException;</code>
-     * 
+     * <p>
      * InputStream의 서브 클래스(subclass)는 특정 매체에 데이터를 읽기 위해 read() 메서드를 사용한다.
      */
     @Nested
@@ -128,7 +147,7 @@ class InputStream_학습_테스트 {
              * todo
              * inputStream에서 바이트로 반환한 값을 문자열로 어떻게 바꿀까?
              */
-            final String actual = "";
+            final String actual = new String(inputStream.readAllBytes());
 
             assertThat(actual).isEqualTo("🤩");
             assertThat(inputStream.read()).isEqualTo(-1);
@@ -148,14 +167,17 @@ class InputStream_학습_테스트 {
              * try-with-resources를 사용한다.
              * java 9 이상에서는 변수를 try-with-resources로 처리할 수 있다.
              */
+            try (inputStream) {
+
+            }
 
             verify(inputStream, atLeastOnce()).close();
         }
     }
 
     /**
      * FilterStream 학습하기
-     *
+     * <p>
      * 필터는 필터 스트림, reader, writer로 나뉜다.
      * 필터는 바이트를 다른 데이터 형식으로 변환 할 때 사용한다.
      * reader, writer는 UTF-8, ISO 8859-1 같은 형식으로 인코딩된 텍스트를 처리하는 데 사용된다.
@@ -169,12 +191,12 @@ class FilterStream_학습_테스트 {
          * 버퍼 크기를 지정하지 않으면 버퍼의 기본 사이즈는 얼마일까?
          */
         @Test
-        void 필터인_BufferedInputStream를_사용해보자() {
+        void 필터인_BufferedInputStream를_사용해보자() throws IOException {
             final String text = "필터에 연결해보자.";
             final InputStream inputStream = new ByteArrayInputStream(text.getBytes());
-            final InputStream bufferedInputStream = null;
+            final InputStream bufferedInputStream = new BufferedInputStream(inputStream);
 
-            final byte[] actual = new byte[0];
+            final byte[] actual = bufferedInputStream.readAllBytes();
 
             assertThat(bufferedInputStream).isInstanceOf(FilterInputStream.class);
             assertThat(actual).isEqualTo("필터에 연결해보자.".getBytes());
@@ -205,8 +227,14 @@ class InputStreamReader_학습_테스트 {
                     "");
             final InputStream inputStream = new ByteArrayInputStream(emoji.getBytes());
 
+            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
             final StringBuilder actual = new StringBuilder();
-
+            List<String> collect = bufferedReader.lines()
+                    .collect(Collectors.toList());
+            for (String s : collect) {
+                actual.append(s);
+                actual.append("\r\n");
+            }
             assertThat(actual).hasToString(emoji);
         }
     }

tomcat/src/main/java/nextstep/jwp/db/InMemoryUserRepository.java

@@ -15,13 +15,14 @@ public class InMemoryUserRepository {
         database.put(user.getAccount(), user);
     }
 
+    private InMemoryUserRepository() {
+    }
+
     public static void save(User user) {
         database.put(user.getAccount(), user);
     }
 
     public static Optional<User> findByAccount(String account) {
         return Optional.ofNullable(database.get(account));
     }
-
-    private InMemoryUserRepository() {}
 }

tomcat/src/main/java/nextstep/jwp/exception/UserNotFoundException.java

@@ -0,0 +1,8 @@
+package nextstep.jwp.exception;
+
+public class UserNotFoundException extends RuntimeException {
+
+    public UserNotFoundException() {
+        super("사용자를 찾을 수 없습니다.");
+    }
+}

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

@@ -2,6 +2,7 @@
 
 import nextstep.jwp.exception.UncheckedServletException;
 import org.apache.coyote.Processor;
+import org.apache.coyote.http11.request.HttpRequest;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -28,16 +29,10 @@ public void run() {
     public void process(final Socket connection) {
         try (final var inputStream = connection.getInputStream();
              final var outputStream = connection.getOutputStream()) {
-
-            final var responseBody = "Hello world!";
-
-            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);
-
+            var httpRequest = HttpRequest.parse(inputStream);
+            var requestReader = new RequestReader();
+            var responseEntity = requestReader.parse(httpRequest);
+            var response = responseEntity.toString();
             outputStream.write(response.getBytes());
             outputStream.flush();
         } catch (IOException | UncheckedServletException e) {

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

@@ -0,0 +1,83 @@
+package org.apache.coyote.http11;
+
+import nextstep.jwp.db.InMemoryUserRepository;
+import nextstep.jwp.exception.UserNotFoundException;
+import nextstep.jwp.model.User;
+import org.apache.coyote.http11.common.HttpMethod;
+import org.apache.coyote.http11.cookie.HttpCookie;
+import org.apache.coyote.http11.cookie.Session;
+import org.apache.coyote.http11.request.HttpRequest;
+import org.apache.coyote.http11.response.HttpStatusCode;
+import org.apache.coyote.http11.response.ResponseBody;
+import org.apache.coyote.http11.response.ResponseEntity;
+import org.apache.coyote.http11.response.StaticResource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.regex.Pattern;
+
+public class RequestReader {
+
+    private static final Logger log = LoggerFactory.getLogger(RequestReader.class);
+    private static final Pattern FILE_EXTENSION_REGEX = Pattern.compile(".css|.js|.ico|.html");
+    private static final String INDEX_HTML = "/index.html";
+    private static final String LOGIN_HTML = "/login.html";
+    private static final String REGISTER_HTML = "/register.html";
+    private static final String UNAUTHORIZED_HTML = "/401.html";
+
+    public ResponseEntity parse(HttpRequest httpRequest) throws IOException {
+        if (FILE_EXTENSION_REGEX.matcher(httpRequest.getRequestUri()).find() && httpRequest.isMatchMethod(HttpMethod.GET)) {
+            StaticResource staticResource = StaticResource.of(httpRequest.getRequestUri());
+            ResponseBody responseBody = ResponseBody.of(staticResource.fileToString(), staticResource.getFileExtension());
+            return ResponseEntity.of(responseBody, HttpStatusCode.OK);
+        }
+
+        if (httpRequest.getRequestUri().startsWith("/login") && httpRequest.isMatchMethod(HttpMethod.GET)) {
+            if (httpRequest.existsSession()) {
+                Session session = httpRequest.getSession(false);
+                User user = (User) session.getAttribute("user");
+                log.info("user: {}", user);
+                return ResponseEntity.redirect(INDEX_HTML, HttpStatusCode.FOUND);
+            }
+            StaticResource staticResource = StaticResource.of(LOGIN_HTML);
+            ResponseBody responseBody = ResponseBody.of(staticResource.fileToString(), staticResource.getFileExtension());
+            return ResponseEntity.of(responseBody, HttpStatusCode.OK);
+        }
+
+        if (httpRequest.isStartsWith("/login") && httpRequest.isMatchMethod(HttpMethod.POST)) {
+            String account = httpRequest.getBody("account");
+            String password = httpRequest.getBody("password");
+            return redirectLogin(httpRequest, account, password);
+        }
+
+        if (httpRequest.isStartsWith("/register") && httpRequest.isMatchMethod(HttpMethod.GET)) {
+            StaticResource staticResource = StaticResource.of(REGISTER_HTML);
+            ResponseBody responseBody = ResponseBody.of(staticResource.fileToString(), staticResource.getFileExtension());
+            return ResponseEntity.of(responseBody, HttpStatusCode.OK);
+        }
+
+        if (httpRequest.isStartsWith("/register") && httpRequest.isMatchMethod(HttpMethod.POST)) {
+            InMemoryUserRepository.save(new User(httpRequest.getBody("account"), httpRequest.getBody("password"), httpRequest.getBody("email")));
+            return ResponseEntity.redirect(INDEX_HTML, HttpStatusCode.FOUND);
+        }
+
+        return ResponseEntity.of(ResponseBody.of("Hello world!", "html"), HttpStatusCode.OK);
+    }
+
+    private ResponseEntity redirectLogin(HttpRequest httpRequest, String account, String password) throws IOException {
+        User user = InMemoryUserRepository.findByAccount(account)
+                .orElseThrow(UserNotFoundException::new);
+        if (!user.checkPassword(password)) {
+            StaticResource staticResource = StaticResource.of(UNAUTHORIZED_HTML);
+            ResponseBody responseBody = ResponseBody.of(staticResource.fileToString(), staticResource.getFileExtension());
+            return ResponseEntity.of(responseBody, HttpStatusCode.UNAUTHORIZED);
+        }
+        log.info("user: {}", user);
+        ResponseEntity responseEntity = ResponseEntity.redirect(INDEX_HTML, HttpStatusCode.FOUND);
+        Session session = httpRequest.getSession(true);
+        session.setAttribute("user", user);
+        responseEntity.addCookie(HttpCookie.jSessionId(session.getId()));
+        return responseEntity;
+    }
+}

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

@@ -0,0 +1,31 @@
+package org.apache.coyote.http11.common;
+
+import java.util.Arrays;
+
+public enum ContentType {
+    HTML("html", "text/html;charset=utf-8"),
+    CSS("css", "text/css"),
+    JS("js", "application/js"),
+    ICO("ico", "image/vnd.microsoft.icon"),
+    SVG("svg", "image/svg+xml"),
+    ;
+
+    private final String fileExtension;
+    private final String name;
+
+    ContentType(String fileExtension, String name) {
+        this.fileExtension = fileExtension;
+        this.name = name;
+    }
+
+    public static ContentType parseContentType(String fileExtension) {
+        return Arrays.stream(values())
+                .filter(contentType -> contentType.fileExtension.equals(fileExtension))
+                .findFirst()
+                .orElse(HTML);
+    }
+
+    public String getName() {
+        return name;
+    }
+}

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

@@ -0,0 +1,24 @@
+package org.apache.coyote.http11.common;
+
+import org.apache.coyote.http11.exception.NotMatchedHttpMethodException;
+
+import java.util.Arrays;
+
+public enum HttpMethod {
+    GET,
+    POST,
+    PUT,
+    DELETE,
+    HEAD,
+    OPTIONS,
+    TRACE,
+    CONNECT,
+    PATCH;
+
+    public static HttpMethod of(String method) {
+        return Arrays.stream(values())
+                .filter(httpMethod -> httpMethod.name().equalsIgnoreCase(method))
+                .findFirst()
+                .orElseThrow(NotMatchedHttpMethodException::new);
+    }
+}

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

@@ -0,0 +1,26 @@
+package org.apache.coyote.http11.common;
+
+import org.apache.coyote.http11.exception.InvalidHttpVersionException;
+
+import java.util.Arrays;
+
+public enum HttpVersion {
+    HTTP_1_1("HTTP/1.1"),
+    ;
+    private final String version;
+
+    HttpVersion(String version) {
+        this.version = version;
+    }
+
+    public static HttpVersion of(String version) {
+        return Arrays.stream(values())
+                .filter(httpVersion -> httpVersion.version.equalsIgnoreCase(version))
+                .findFirst()
+                .orElseThrow(InvalidHttpVersionException::new);
+    }
+
+    public String getVersion() {
+        return version;
+    }
+}