[톰캣 구현하기 1, 2단계] 로이(김덕우) 미션 제출합니다. (#396)

* test: IOStream 학습 테스트

* test: File 학습 테스트

* feat: Request 구성 요소 구현

* feat: HttpRequest 구현

* feat: Response 구성 요소 구현

* feat: HttpResponse 구현

* feat: HttpProcessor 구현

* refactor: HttpRequest 관련 로직 구조 변경

* feat: 정적 리소스 관련 controller 구현

* feat: 로그인 및 회원가입 관련 controller 구현

* feat: 쿠키 및 세션 구현

* feat: Request 매핑 및 쿼리 파라미터 파싱 로직 구현

* refactor: processor 로직 수정

Author: the9kim

study/src/test/java/study/FileTest.java

@@ -3,9 +3,17 @@
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStreamReader;
+import java.net.URISyntaxException;
+import java.net.URL;
 import java.nio.file.Path;
 import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -28,7 +36,8 @@ class FileTest {
         final String fileName = "nextstep.txt";
 
         // todo
-        final String actual = "";
+        final URL url = getClass().getClassLoader().getResource(fileName);
+        final String actual = url.getPath();
 
         assertThat(actual).endsWith(fileName);
     }
@@ -40,14 +49,18 @@ class FileTest {
      * File, Files 클래스를 사용하여 파일의 내용을 읽어보자.
      */
     @Test
-    void 파일의_내용을_읽는다() {
+    void 파일의_내용을_읽는다() throws URISyntaxException, FileNotFoundException {
         final String fileName = "nextstep.txt";
 
         // todo
-        final Path path = null;
+        final URL url = getClass().getClassLoader().getResource(fileName);
+        final Path path = Path.of(url.toURI());
 
         // todo
-        final List<String> actual = Collections.emptyList();
+        final File file = path.toFile();
+        final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
+
+        final List<String> actual = reader.lines().collect(Collectors.toUnmodifiableList());
 
         assertThat(actual).containsOnly("nextstep");
     }

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

@@ -5,18 +5,19 @@
 import org.junit.jupiter.api.Test;
 
 import java.io.*;
+import java.util.stream.Stream;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.*;
 
 /**
  * 자바는 스트림(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 +27,7 @@ class IOStreamTest {
 
     /**
      * OutputStream 학습하기
-     *
+     * <p>
      * 자바의 기본 출력 클래스는 java.io.OutputStream이다.
      * OutputStream의 write(int b) 메서드는 기반 메서드이다.
      * <code>public abstract void write(int b) throws IOException;</code>
@@ -39,7 +40,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,7 +54,7 @@ class OutputStream_학습_테스트 {
              * todo
              * OutputStream 객체의 write 메서드를 사용해서 테스트를 통과시킨다
              */
-
+            outputStream.write(bytes);
             final String actual = outputStream.toString();
 
             assertThat(actual).isEqualTo("nextstep");
@@ -63,7 +64,7 @@ class OutputStream_학습_테스트 {
         /**
          * 효율적인 전송을 위해 스트림에서 버퍼링을 사용 할 수 있다.
          * BufferedOutputStream 필터를 연결하면 버퍼링이 가능하다.
-         * 
+         * <p>
          * 버퍼링을 사용하면 OutputStream을 사용할 때 flush를 사용하자.
          * flush() 메서드는 버퍼가 아직 가득 차지 않은 상황에서 강제로 버퍼의 내용을 전송한다.
          * Stream은 동기(synchronous)로 동작하기 때문에 버퍼가 찰 때까지 기다리면
@@ -79,6 +80,7 @@ class OutputStream_학습_테스트 {
              * ByteArrayOutputStream과 어떤 차이가 있을까?
              */
 
+            outputStream.flush();
             verify(outputStream, atLeastOnce()).flush();
             outputStream.close();
         }
@@ -96,19 +98,23 @@ class OutputStream_학습_테스트 {
              * try-with-resources를 사용한다.
              * java 9 이상에서는 변수를 try-with-resources로 처리할 수 있다.
              */
+            final byte[] bytes = {110, 101, 120, 116, 115, 116, 101, 112};
+            try (outputStream) {
+                outputStream.write(bytes);
+            }
 
             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 +134,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 +154,17 @@ class InputStream_학습_테스트 {
              * try-with-resources를 사용한다.
              * java 9 이상에서는 변수를 try-with-resources로 처리할 수 있다.
              */
+            try (inputStream){
+                inputStream.readAllBytes();
+            }
 
             verify(inputStream, atLeastOnce()).close();
         }
     }
 
     /**
      * FilterStream 학습하기
-     *
+     * <p>
      * 필터는 필터 스트림, reader, writer로 나뉜다.
      * 필터는 바이트를 다른 데이터 형식으로 변환 할 때 사용한다.
      * reader, writer는 UTF-8, ISO 8859-1 같은 형식으로 인코딩된 텍스트를 처리하는 데 사용된다.
@@ -172,9 +181,14 @@ class FilterStream_학습_테스트 {
         void 필터인_BufferedInputStream를_사용해보자() {
             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;
+            try (bufferedInputStream) {
+                actual = bufferedInputStream.readAllBytes();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
 
             assertThat(bufferedInputStream).isInstanceOf(FilterInputStream.class);
             assertThat(actual).isEqualTo("필터에 연결해보자.".getBytes());
@@ -204,9 +218,17 @@ class InputStreamReader_학습_테스트 {
                     "😋😛😝😜🤪🤨🧐🤓😎🥸🤩",
                     "");
             final InputStream inputStream = new ByteArrayInputStream(emoji.getBytes());
+            final BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
 
             final StringBuilder actual = new StringBuilder();
 
+            try (bufferedReader) {
+                final Stream<String> lines = bufferedReader.lines();
+                lines.forEach(line -> actual.append(line).append("\r\n"));
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+
             assertThat(actual).hasToString(emoji);
         }
     }

tomcat/src/main/java/nextstep/jwp/controller/AbstractController.java

@@ -0,0 +1,38 @@
+package nextstep.jwp.controller;
+
+import org.apache.coyote.http11.request.HttpMethod;
+import org.apache.coyote.http11.request.HttpRequest;
+import org.apache.coyote.http11.response.ContentType;
+import org.apache.coyote.http11.response.HttpResponse;
+import org.apache.coyote.http11.response.HttpStatus;
+import org.apache.coyote.http11.util.PathFinder;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public abstract class AbstractController implements Controller {
+
+    @Override
+    public HttpResponse service(HttpRequest request) throws Exception {
+        if (request.getHttpMethod() == HttpMethod.GET) {
+            return doGet(request);
+        }
+        return doPost(request);
+    }
+
+    protected HttpResponse doGet(HttpRequest request) throws Exception {
+        return defaultInternalServerErrorPage();
+    }
+
+    protected HttpResponse doPost(HttpRequest request) throws Exception {
+        return defaultInternalServerErrorPage();
+    }
+
+    private HttpResponse defaultInternalServerErrorPage() throws URISyntaxException, IOException {
+        final Path path = PathFinder.findPath("/500.html");
+        final String responseBody = new String(Files.readAllBytes(path));
+        return new HttpResponse(HttpStatus.INTERNAL_SERVER_ERROR, responseBody, ContentType.HTML);
+    }
+}

tomcat/src/main/java/nextstep/jwp/controller/Controller.java

@@ -0,0 +1,9 @@
+package nextstep.jwp.controller;
+
+import org.apache.coyote.http11.request.HttpRequest;
+import org.apache.coyote.http11.response.HttpResponse;
+
+public interface Controller {
+
+    HttpResponse service(HttpRequest request) throws Exception;
+}

tomcat/src/main/java/nextstep/jwp/controller/FileController.java

@@ -0,0 +1,27 @@
+package nextstep.jwp.controller;
+
+import org.apache.coyote.http11.request.HttpRequest;
+import org.apache.coyote.http11.response.ContentType;
+import org.apache.coyote.http11.response.HttpResponse;
+import org.apache.coyote.http11.response.HttpStatus;
+import org.apache.coyote.http11.util.PathFinder;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public class FileController extends AbstractController {
+
+    private static final int CONTENT_TYPE_START_INDEX = 1;
+
+    @Override
+    protected HttpResponse doGet(HttpRequest request) throws Exception {
+        String requestUrl = request.getRequestUrl();
+        Path path = PathFinder.findPath(requestUrl);
+
+        String extension = requestUrl.split("\\.")[CONTENT_TYPE_START_INDEX];
+        var responseBody = new String(Files.readAllBytes(path));
+        ContentType contentType = ContentType.findContentType(extension);
+
+        return new HttpResponse(HttpStatus.OK, responseBody, contentType);
+    }
+}

tomcat/src/main/java/nextstep/jwp/controller/HelloController.java

@@ -0,0 +1,15 @@
+package nextstep.jwp.controller;
+
+import org.apache.coyote.http11.request.HttpRequest;
+import org.apache.coyote.http11.response.ContentType;
+import org.apache.coyote.http11.response.HttpResponse;
+import org.apache.coyote.http11.response.HttpStatus;
+
+public class HelloController extends AbstractController {
+
+    @Override
+    protected HttpResponse doGet(HttpRequest request) {
+        String responseBody = "Hello world!";
+        return new HttpResponse(HttpStatus.OK, responseBody, ContentType.HTML);
+    }
+}

tomcat/src/main/java/nextstep/jwp/controller/LoginController.java

@@ -0,0 +1,88 @@
+package nextstep.jwp.controller;
+
+import nextstep.jwp.db.InMemoryUserRepository;
+import nextstep.jwp.model.User;
+import org.apache.coyote.http11.request.HttpRequest;
+import org.apache.coyote.http11.response.ContentType;
+import org.apache.coyote.http11.response.HttpResponse;
+import org.apache.coyote.http11.response.HttpStatus;
+import org.apache.coyote.http11.session.Session;
+import org.apache.coyote.http11.session.SessionManager;
+import org.apache.coyote.http11.util.PathFinder;
+import org.apache.coyote.http11.util.QueryParamsParser;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+public class LoginController extends AbstractController {
+
+    private static final Logger log = LoggerFactory.getLogger(LoginController.class);
+
+    @Override
+    protected HttpResponse doGet(HttpRequest request) throws Exception {
+        Path path = PathFinder.findPath("/login.html");
+        String responseBody = new String(Files.readAllBytes(path));
+        Optional<User> loginUser = request.findUserByJSessionId();
+        if (loginUser.isPresent()) {
+            return redirectByAlreadyLogin(responseBody);
+        }
+        return new HttpResponse(HttpStatus.OK, responseBody, ContentType.HTML);
+    }
+
+    private HttpResponse redirectByAlreadyLogin(String responseBody) {
+        return new HttpResponse(HttpStatus.FOUND, responseBody, ContentType.HTML, "/index.html");
+    }
+
+    @Override
+    protected HttpResponse doPost(HttpRequest request) throws Exception {
+        HashMap<String, String> loginData = QueryParamsParser.parseByBody(request.getRequestBody());
+        Path path = PathFinder.findPath("/login.html");
+        String responseBody = new String(Files.readAllBytes(path));
+        return makeLoginResponse(loginData, responseBody);
+    }
+
+    private HttpResponse makeLoginResponse(Map<String, String> loginData, final String responseBody) {
+        String account = loginData.get("account");
+        String password = loginData.get("password");
+        if (loginData.isEmpty() || !isSuccessLogin(account, password)) {
+            log.info("로그인에 실패했습니다.");
+            return failLoginResponse(responseBody);
+        }
+        User user = new User(account, password);
+        return successLoginResponse(responseBody, user);
+    }
+
+    private HttpResponse successLoginResponse(String responseBody, User user) {
+        HttpResponse httpResponse =
+                new HttpResponse(HttpStatus.FOUND, responseBody, ContentType.HTML, "/index.html");
+        Session session = new Session();
+        session.setAttribute("user", user);
+        SessionManager.add(session);
+        httpResponse.addJSessionId(session);
+        return httpResponse;
+    }
+
+    private HttpResponse failLoginResponse(String responseBody) {
+        log.info("로그인 계정 정보가 이상합니다. responseBody={}", responseBody);
+        return new HttpResponse(HttpStatus.FOUND, responseBody, ContentType.HTML, "/401.html");
+    }
+
+    private boolean isSuccessLogin(String account, String password) {
+        Optional<User> accessUser = InMemoryUserRepository.findByAccount(account);
+        return accessUser.filter(user -> checkPassword(password, user))
+                .isPresent();
+    }
+
+    private boolean checkPassword(String password, User accessUser) {
+        if (!accessUser.checkPassword(password)) {
+            return false;
+        }
+        log.info("user = {}", accessUser);
+        return true;
+    }
+}