[톰캣 구현하기 - 1, 2단계] 푸우(백승준) 미션 제출합니다. (#311)

* test: IOStreamTest 작성

* test: FileTest 작성

* docs: 기능 목록 작성

* feat: index.html 파일 반환 구현

* feat: 정적 파일을 반환하는 ResourceProvider 생성

* feat: CSS 파일 반환 구현

* feat: Method 구현

* feat: RequestLine 객체화

* fix: 디렉터리 조회시 파일을 반환하지 않도록 변경

* feat: Http11Processor 가 RequestLine 사용하도록 변경

* fix: ? 를 contatins 과 split 사용에 따라 분리한다

* style: 패키지 변경

* feat: 컨트롤러 정의

* feat: 1. 정적파일을 찾은 후 2. 컨트롤러를 찾고 3. 못 찾았다면 Not Found page 반환

* fix: queryParam 이 없더라도 login page 를 반환하도록 변경

* docs: 추가 기능 목록 추가

* feat: Response 객체 생성

* feat: Redirect 기능 구현

* feat: Request 객체 구현

* feat: 회원가입 구현 및 로그인 post 변경

* feat: Cookie 객체 생성

* feat: 로그인 혹은 회원가입 시 cookie 발급

* feat: Session, SessionManager 생성

* feat: LoginService 가 유저를 세션에 저장한다

* feat: 로그인 되어 Session 에 저장된 유저라면 login, register 요청은 index 로 리다이렉션 한다.

* style: 쿠키 객체 이름 변경

* refactor: 파일을 Files 를 이용해 읽어온다.

* refactor: 로그인 검증을 SessionManager 가 담당하도록 변경

* fix: 세션 쿠키가 없을 경우 empty 를 반환한다.

* refactor: sonarLint 반영

* refactor: sonarLint 반영

* refactor: Session 객체를 상속 받지 않도록 변경

* style: Request, Response, HttpResponse, Method-> HttpRequest, HttpResponse, HttpStatusCode HttpMethod 변경

* refactor: processor 에서 null 대신 예외를 반환하도록 변경

* refactor: HttpRequest 생성을 HttpRequest 에게 위임

* style: processor 메서드 순서 변경

* feat: RequestHeaders 필드 private 화

* refactor: HttpRequest 의 불필요한 메서드 지역 변수 제거 및 null 대신 예외를 발생시키도록 변경

* refactor: HttpResponse 가 기본 상태코드를 가지지 않도록 변경 및 인스턴스 변수의 final 화

* refactor: Cookie 변환 로직을 Cookies 에게 위임

* fix: headers 재활용을 위해 메서드 지역 변수 생성

* refactor: RequestHeaders 가 Cookies 를 가지고 있도록 변경

* refactor: Session 생성 책임을 SessionManger 에게 할당

* refactor: 정적 파일 response 반환 책임을 ResourceProvider 에게 위임, 컨트롤러 response 반환 책임을 HandlerMapper 에게 위임

* style: HandlerMapper 오타 수정

* style: handler 반환 메서드 private

* fix: 잘못 수정된 html method 수정

* refactor: 잘못된 Class 명명 수정 및 Body 값에 대한 Optional 처리

* refactor: toURI -> getFile 을 통한 exception handling 과정 삭제

* refactor: css 반환 헤더에 utf-8 적용 및 text/plain header 추가

* refactor: ResourceProvider 에서 존재하지 않는 파일을 읽는다면 null 대신 예외를 발생시키도록 변경

* style: HandlerMapper 에서 body 없는 응답 작성 메서드 네이밍 변경

* chore: 정적 필드와 인스턴스 필드 간의 공백추가

* refactor: Enum 의 name method 를 통해 HttpMethod 를 반환하도록 변경

* fix: Option.get 호출 전 isEmpty 를 호출하도록 변경

Author: BGuga

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

@@ -1,54 +1,59 @@
 package study;
 
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
 
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.Collections;
 import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.stream.Collectors;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
 
 /**
- * 웹서버는 사용자가 요청한 html 파일을 제공 할 수 있어야 한다.
- * File 클래스를 사용해서 파일을 읽어오고, 사용자에게 전달한다.
+ * 웹서버는 사용자가 요청한 html 파일을 제공 할 수 있어야 한다. File 클래스를 사용해서 파일을 읽어오고, 사용자에게 전달한다.
  */
 @DisplayName("File 클래스 학습 테스트")
 class FileTest {
 
     /**
      * resource 디렉터리 경로 찾기
-     *
-     * File 객체를 생성하려면 파일의 경로를 알아야 한다.
-     * 자바 애플리케이션은 resource 디렉터리에 HTML, CSS 같은 정적 파일을 저장한다.
-     * resource 디렉터리의 경로는 어떻게 알아낼 수 있을까?
+     * <p>
+     * File 객체를 생성하려면 파일의 경로를 알아야 한다. 자바 애플리케이션은 resource 디렉터리에 HTML, CSS 같은 정적 파일을 저장한다. resource 디렉터리의 경로는 어떻게 알아낼 수
+     * 있을까?
      */
     @Test
-    void resource_디렉터리에_있는_파일의_경로를_찾는다() {
+    void resource_디렉터리에_있는_파일의_경로를_찾는다() throws URISyntaxException {
         final String fileName = "nextstep.txt";
 
         // todo
-        final String actual = "";
+        File file = new File(getClass().getClassLoader().getResource("nextstep.txt").toURI());
+        final String actual = file.getName();
 
         assertThat(actual).endsWith(fileName);
     }
 
     /**
      * 파일 내용 읽기
-     *
-     * 읽어온 파일의 내용을 I/O Stream을 사용해서 사용자에게 전달 해야 한다.
-     * File, Files 클래스를 사용하여 파일의 내용을 읽어보자.
+     * <p>
+     * 읽어온 파일의 내용을 I/O Stream을 사용해서 사용자에게 전달 해야 한다. File, Files 클래스를 사용하여 파일의 내용을 읽어보자.
      */
     @Test
-    void 파일의_내용을_읽는다() {
+    void 파일의_내용을_읽는다() throws IOException {
         final String fileName = "nextstep.txt";
 
         // todo
-        final Path path = null;
+        String file = getClass().getClassLoader().getResource(fileName).getFile();
+        Path path = Path.of(file);
 
         // todo
-        final List<String> actual = Collections.emptyList();
+        BufferedReader bufferedReader = Files.newBufferedReader(path);
+        final List<String> actual = bufferedReader.lines().collect(Collectors.toList());
 
+        // then
         assertThat(actual).containsOnly("nextstep");
     }
 }

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

@@ -0,0 +1,20 @@
+## Mission 1 : HTTP 서버 구현하기
+
+1. [x] Get /index.html 응답하기
+2. [x] CSS 지원하기
+    - [x] 정적 파일을 지원하는 ResourceProvider 를 생성한다.
+        - [x] 해당 정적 파일을 읽어온다.
+        - [x] 해당 정적 파일의 타입을 반환한다.
+3. [x] Query String 파싱
+    - [x] 먼저 정적 파일을 찾는다.
+    - [x] 요청을 handle 할 수 있는 핸들러를 찾는다.
+    - [x] 아무것도 못 찾았다면 not Found 페이지 반환.
+
+## Mission 2 : 로그인 구현하기
+
+1. [x] HTTP Status Code 302
+2. [x] POST 방식으로 회원가입 및 로그인
+   - [x] Request 를 생성한다
+   - [x] 요청을 해결할 수 있는 Contoller 를 Mapper 로 엮어둔다.
+3. [x] Cookie에 JSESSIONID 값 저장하기
+4. [x] Session 구현하기

tomcat/README.md

@@ -1,27 +1,29 @@
 package nextstep.jwp.db;
 
-import nextstep.jwp.model.User;
-
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
+import nextstep.jwp.model.User;
 
 public class InMemoryUserRepository {
 
     private static final Map<String, User> database = new ConcurrentHashMap<>();
+    private static Long publishedId = 1L;
 
     static {
         final User user = new User(1L, "gugu", "password", "[email protected]");
         database.put(user.getAccount(), user);
     }
 
-    public static void save(User user) {
-        database.put(user.getAccount(), user);
+    private InMemoryUserRepository() {
     }
 
     public static Optional<User> findByAccount(String account) {
         return Optional.ofNullable(database.get(account));
     }
 
-    private InMemoryUserRepository() {}
+    public static void save(User user) {
+        User saveUser = new User(++publishedId, user.getAccount(), user.getPassword(), user.getEmail());
+        database.put(saveUser.getAccount(), saveUser);
+    }
 }

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

@@ -22,17 +22,29 @@ public boolean checkPassword(String password) {
         return this.password.equals(password);
     }
 
+    public Long getId() {
+        return id;
+    }
+
     public String getAccount() {
         return account;
     }
 
+    public String getPassword() {
+        return password;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
     @Override
     public String toString() {
         return "User{" +
-                "id=" + id +
-                ", account='" + account + '\'' +
-                ", email='" + email + '\'' +
-                ", password='" + password + '\'' +
-                '}';
+            "id=" + id +
+            ", account='" + account + '\'' +
+            ", email='" + email + '\'' +
+            ", password='" + password + '\'' +
+            '}';
     }
 }

tomcat/src/main/java/nextstep/jwp/model/User.java

@@ -1,21 +1,28 @@
 package org.apache.coyote.http11;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.Socket;
 import nextstep.jwp.exception.UncheckedServletException;
 import org.apache.coyote.Processor;
+import org.apache.coyote.http11.controller.HandlerMapper;
+import org.apache.coyote.http11.request.HttpRequest;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
-import java.net.Socket;
-
 public class Http11Processor implements Runnable, Processor {
 
     private static final Logger log = LoggerFactory.getLogger(Http11Processor.class);
 
     private final Socket connection;
+    private final ResourceProvider resourceProvider;
+    private final HandlerMapper handlerMapper;
 
     public Http11Processor(final Socket connection) {
         this.connection = connection;
+        this.resourceProvider = new ResourceProvider();
+        this.handlerMapper = new HandlerMapper(this.resourceProvider);
     }
 
     @Override
@@ -26,22 +33,29 @@ public void run() {
 
     @Override
     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);
-
+        try (final var inputReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
+            final var outputStream = connection.getOutputStream()) {
+            HttpRequest httpRequest = HttpRequest.makeRequest(inputReader);
+            String response = getResponse(httpRequest);
             outputStream.write(response.getBytes());
             outputStream.flush();
         } catch (IOException | UncheckedServletException e) {
             log.error(e.getMessage(), e);
         }
     }
+
+    private String getResponse(HttpRequest httpRequest) {
+        if (resourceProvider.haveResource(httpRequest.getRequestLine().getPath())) {
+            return resourceProvider.staticResourceResponse(httpRequest.getRequestLine().getPath());
+        }
+        if (handlerMapper.haveAvailableHandler(httpRequest)) {
+            return handlerMapper.controllerResponse(httpRequest);
+        }
+        return String.join("\r\n",
+            "HTTP/1.1 200 OK ",
+            "Content-Type: text/html;charset=utf-8 ",
+            "Content-Length: 12 ",
+            "",
+            "Hello world!");
+    }
 }

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

@@ -0,0 +1,69 @@
+package org.apache.coyote.http11;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.util.Optional;
+
+public class ResourceProvider {
+
+    public boolean haveResource(String resourcePath) {
+        return findFileURL(resourcePath).isPresent();
+    }
+
+    public String resourceBodyOf(String resourcePath) {
+        try {
+            Optional<URL> fileURL = findFileURL(resourcePath);
+            if (fileURL.isPresent()) {
+                URL url = fileURL.get();
+                return new String(Files.readAllBytes(new File(url.getFile()).toPath()));
+            }
+            throw new IllegalArgumentException("파일이 존재하지 않습니다.");
+        } catch (IOException e) {
+            throw new IllegalArgumentException("존재하지 않는 파일 입니다.");
+        }
+    }
+
+    private Optional<URL> findFileURL(String resourcePath) {
+        URL resourceURL = getClass().getClassLoader().getResource("static" + resourcePath);
+        if (resourceURL == null) {
+            return Optional.empty();
+        }
+        if (new File(resourceURL.getFile()).isDirectory()) {
+            return Optional.empty();
+        }
+        return Optional.of(resourceURL);
+    }
+
+    public String contentTypeOf(String resourcePath) {
+        File file = getFile(resourcePath);
+        String fileName = file.getName();
+        if (fileName.endsWith(".js")) {
+            return "Content-Type: text/javascript ";
+        }
+        if (fileName.endsWith(".css")) {
+            return "Content-Type: text/css;charset=utf-8";
+        }
+        if (fileName.endsWith(".html")) {
+            return "Content-Type: text/html;charset=utf-8 ";
+        }
+        return "Content-Type: text/plain";
+    }
+
+    private File getFile(String resourcePath) {
+        return new File(
+            findFileURL(resourcePath).orElseThrow((() -> new IllegalArgumentException("파일이 존재하지 않습니다.")))
+                .getFile());
+    }
+
+    public String staticResourceResponse(String resourcePath) {
+        String responseBody = resourceBodyOf(resourcePath);
+        return String.join("\r\n",
+            "HTTP/1.1 200 OK ",
+            contentTypeOf(resourcePath),
+            "Content-Length: " + responseBody.getBytes().length + " ",
+            "",
+            responseBody);
+    }
+}

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

@@ -0,0 +1,9 @@
+package org.apache.coyote.http11.controller;
+
+import org.apache.coyote.http11.request.HttpRequest;
+import org.apache.coyote.http11.response.HttpResponse;
+
+public interface Controller {
+
+    HttpResponse<? extends Object> handle(HttpRequest httpRequest);
+}