[둔덩] 3단계 - HTTP 웹 서버 리팩터링 미션 제출합니다.

README.md

@@ -30,4 +30,14 @@
 5. Controller 분리
     - [x] Controller 인터페이스
     - [x] AbstractController로 중복 제거
-    - [x] Http Methode에 따라 메서드 분리
+    - [x] Http Methode에 따라 메서드 분리
+
+## 3단계
+1. 로그인 할 수 있다.
+    - [x] 로그인 메뉴 클릭 시  http://localhost:8080/user/login.html 으로 이동해 로그인할 수 있다.
+    - [x] 로그인이 성공하면 index.html로 이동, header의 Cookie header 값이 logined=true
+    - [x] 로그인이 실패하면 /user/login_failed.html로 이동, header의 Cookie header 값이 logined=false
+2. /user/list로 접근할 수 있다.
+    - [x] 로그인 상태일 시 사용자 목록 출력
+    - [x] 로그인 하지 않았으면 로그인 페이지로 이동
+3. 서블릿에서 지원하는 HttpSession API의 일부를 지원    

src/main/java/controller/AbstractController.java

@@ -20,11 +20,11 @@ public void service(HttpRequest httpRequest, HttpResponse httpResponse) {
         httpResponse.sendError(Status.METHOD_NOT_ALLOWED);
     }
 
-    void doGet(HttpRequest httpRequest, HttpResponse httpResponse) {
+    public void doGet(HttpRequest httpRequest, HttpResponse httpResponse) {
         httpResponse.sendError(Status.METHOD_NOT_ALLOWED);
     }
 
-    void doPost(HttpRequest httpRequest, HttpResponse httpResponse) {
+    public void doPost(HttpRequest httpRequest, HttpResponse httpResponse) {
         httpResponse.sendError(Status.METHOD_NOT_ALLOWED);
     }
 }

src/main/java/controller/Controllers.java → src/main/java/controller/ControllerType.java

@@ -3,14 +3,16 @@
 import webserver.request.HttpRequest;
 import webserver.response.HttpResponse;
 
-public enum Controllers {
+public enum ControllerType {
     TEMPLATES_CONTROLLER(new TemplatesController()),
     STATIC_RESOURCE_CONTROLLER(new StaticResourceController()),
-    USER_CONTROLLER(new UserController());
+    USER_CREATE_CONTROLLER(new UserCreateController()),
+    USER_LOGIN_CONTROLLER(new UserLoginController()),
+    USER_LIST_CONTROLLER(new UserListController());
 
     private final Controller controller;
 
-    Controllers(Controller controller) {
+    ControllerType(Controller controller) {
         this.controller = controller;
     }
 

src/main/java/controller/UserController.java → src/main/java/controller/UserCreateController.java

@@ -1,22 +1,25 @@
 package controller;
 
 import domain.user.service.UserService;
+import webserver.ContentType;
 import webserver.EntityHeader;
 import webserver.request.HttpRequest;
 import webserver.response.HttpResponse;
 
-public class UserController extends AbstractController {
+public class UserCreateController extends AbstractController {
+    private static final String PAGE_PREFIX = "./templates";
+    private static final String INDEX_HTML = "/index.html";
 
     @Override
     public void doGet(HttpRequest httpRequest, HttpResponse httpResponse) {
         UserService.createUser(httpRequest);
-        httpResponse.addHeader(EntityHeader.CONTENT_TYPE, "text/html; charset=utf-8");
-        httpResponse.forward("./templates/index.html");
+        httpResponse.addHeader(EntityHeader.CONTENT_TYPE, ContentType.HTML.get());
+        httpResponse.forward(PAGE_PREFIX + INDEX_HTML);
     }
 
     @Override
     public void doPost(HttpRequest httpRequest, HttpResponse httpResponse) {
         UserService.createUser(httpRequest);
-        httpResponse.sendRedirect("/index.html");
+        httpResponse.sendRedirect(INDEX_HTML);
     }
 }

src/main/java/controller/UserListController.java

@@ -0,0 +1,26 @@
+package controller;
+
+import domain.user.dto.UserListResponse;
+import domain.user.service.UserService;
+import utils.TemplateUtils;
+import webserver.request.HttpRequest;
+import webserver.response.HttpResponse;
+import webserver.response.ResponseHeader;
+
+public class UserListController extends AbstractController {
+    private static final String USER_LIST = "user/list";
+    private static final String USER_LOGIN_HTML = "/user/login.html";
+    private static final String LOGIN_FALSE = "logined=false";
+
+    @Override
+    public void doGet(HttpRequest httpRequest, HttpResponse httpResponse) {
+        String cookieValue = httpRequest.getHeader(ResponseHeader.SET_COOKIE.get());
+        if (cookieValue.contains(LOGIN_FALSE)) {
+            httpResponse.forward(USER_LOGIN_HTML);
+            return;
+        }
+        UserListResponse userListResponse = new UserListResponse(UserService.findAll());
+        String profilePage = TemplateUtils.create(USER_LIST, userListResponse);
+        httpResponse.forward(profilePage.getBytes());
+    }
+}

src/main/java/controller/UserLoginController.java

@@ -0,0 +1,33 @@
+package controller;
+
+import domain.user.User;
+import domain.user.service.UserService;
+import utils.UserMapper;
+import webserver.request.HttpRequest;
+import webserver.response.HttpResponse;
+import webserver.response.ResponseHeader;
+
+public class UserLoginController extends AbstractController {
+    private static final String LOGIN_FALSE = "logined=false;";
+    private static final String LOGIN_TRUE = "logined=true;";
+    private static final String PATH = " Path=/";
+    private static final String USER_LOGIN_FAILED_HTML = "/user/login_failed.html";
+    private static final String INDEX_HTML = "/index.html";
+
+    @Override
+    public void doPost(HttpRequest httpRequest, HttpResponse httpResponse) {
+        User requestUser = UserMapper.createUser(httpRequest);
+        User foundUser = UserService.findById(requestUser.getUserId())
+                .orElse(null);
+        if (foundUser == null || foundUser.notMatchPassword(requestUser)) {
+            setCookieAndRedirect(httpResponse, LOGIN_FALSE + PATH, USER_LOGIN_FAILED_HTML);
+            return;
+        }
+        setCookieAndRedirect(httpResponse, LOGIN_TRUE + PATH, INDEX_HTML);
+    }
+
+    private void setCookieAndRedirect(HttpResponse httpResponse, String cookieValue, String path) {
+        httpResponse.addHeader(ResponseHeader.SET_COOKIE, cookieValue);
+        httpResponse.sendRedirect(path);
+    }
+}

src/main/java/domain/user/User.java

@@ -13,6 +13,10 @@ public User(String userId, String password, String name, String email) {
         this.email = email;
     }
 
+    public boolean notMatchPassword(User requestUser) {
+        return !this.password.equals(requestUser.password);
+    }
+
     public String getUserId() {
         return userId;
     }

src/main/java/domain/user/dto/UserListResponse.java

@@ -0,0 +1,17 @@
+package domain.user.dto;
+
+import domain.user.User;
+
+import java.util.Collection;
+
+public class UserListResponse {
+    private Collection<User> users;
+
+    public UserListResponse(Collection<User> users) {
+        this.users = users;
+    }
+
+    public Collection<User> getUsers() {
+        return users;
+    }
+}

src/main/java/domain/user/service/UserService.java

@@ -5,10 +5,25 @@
 import utils.UserMapper;
 import webserver.request.HttpRequest;
 
+import java.util.Collection;
+import java.util.Optional;
+
 public class UserService {
 
     public static void createUser(HttpRequest httpRequest) {
         User user = UserMapper.createUser(httpRequest);
         DataBase.addUser(user);
     }
+
+    public static Optional<User> findById(String id) {
+        User user = DataBase.findUserById(id);
+        if (user == null) {
+            return Optional.empty();
+        }
+        return Optional.of(user);
+    }
+
+    public static Collection<User> findAll() {
+        return DataBase.findAll();
+    }
 }

src/main/java/utils/TemplateUtils.java

@@ -0,0 +1,30 @@
+package utils;
+
+import com.github.jknack.handlebars.Handlebars;
+import com.github.jknack.handlebars.Template;
+import com.github.jknack.handlebars.io.ClassPathTemplateLoader;
+import com.github.jknack.handlebars.io.TemplateLoader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+
+public class TemplateUtils {
+    private static final Logger log = LoggerFactory.getLogger(TemplateUtils.class);
+    private static final String TEMPLATES_PATH = "/templates";
+    private static final String HTML = ".html";
+
+    public static String create(String path, Object object) {
+        TemplateLoader loader = new ClassPathTemplateLoader();
+        loader.setPrefix(TEMPLATES_PATH);
+        loader.setSuffix(HTML);
+        Handlebars handlebars = new Handlebars(loader);
+        try {
+            Template template = handlebars.compile(path);
+            return template.apply(object);
+        } catch (IOException e) {
+            log.error(e.getMessage(), e);
+            throw new RuntimeException("IOException 발생");
+        }
+    }
+}

src/main/java/webserver/ContentType.java

@@ -4,13 +4,15 @@
 import java.util.function.Predicate;
 
 public enum ContentType {
-    HTML("text/html; charset=utf-8", path -> path.contains("html")),
-    ICON("image/x-icon; charset=utf-8", path -> path.contains("ico")),
-    CSS("text/css; charset=utf-8", path -> path.contains("css")),
-    JS("text/javascript; charset=utf-8", path -> path.contains("js")),
-    IMAGE("image/png; charset=utf-8", path -> path.contains("png")),
-    FONT_WOFF("application/x-font-woff; charset=utf-8", path -> path.contains("woff")),
-    FONT_TTF("application/x-font-ttf; charset=utf-8", path -> path.contains("ttf"));
+    HTML("text/html", containsPath("html")),
+    ICON("image/x-icon", containsPath("ico")),
+    CSS("text/css", containsPath("css")),
+    JS("text/javascript", containsPath("js")),
+    IMAGE("image/png", containsPath("png")),
+    FONT_WOFF("application/x-font-woff", containsPath("woff")),
+    FONT_TTF("application/x-font-ttf", containsPath("ttf"));
+
+    private static final String CHARSET = "charset=utf-8";
 
     private final String contentType;
     private final Predicate<String> predicate;
@@ -27,7 +29,11 @@ public static ContentType form(String path) {
                 .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 ContentType" + path));
     }
 
+    private static Predicate<String> containsPath(String type) {
+        return path -> path.contains(type);
+    }
+
     public String get() {
-        return contentType;
+        return String.format("%s; %s", contentType, CHARSET);
     }
 }

src/main/java/webserver/WebServer.java

@@ -26,7 +26,7 @@ public static void main(String args[]) throws Exception {
             logger.info("Web Application Server started {} port.", port);
             // 클라이언트가 연결될때까지 대기한다.
             Socket connection;
-            ExecutorService executor = Executors.newWorkStealingPool();
+            ExecutorService executor = Executors.newCachedThreadPool();
             while ((connection = listenSocket.accept()) != null) {
                 executor.submit(new RequestHandler(connection));
             }

src/main/java/webserver/request/HandlerMapping.java

@@ -1,22 +1,24 @@
 package webserver.request;
 
-import controller.Controllers;
+import controller.ControllerType;
 import webserver.response.HttpResponse;
 
 import java.util.Arrays;
 import java.util.List;
 
 public enum HandlerMapping {
-    TEMPLATES(Arrays.asList(".html", ".ico"), Controllers.TEMPLATES_CONTROLLER),
-    STATIC(Arrays.asList("/css", "/js", "/fonts"), Controllers.STATIC_RESOURCE_CONTROLLER),
-    USER_CREATE(Arrays.asList("/user/create"), Controllers.USER_CONTROLLER);
+    TEMPLATES(Arrays.asList(".html", ".ico"), ControllerType.TEMPLATES_CONTROLLER),
+    STATIC(Arrays.asList("/css", "/js", "/fonts"), ControllerType.STATIC_RESOURCE_CONTROLLER),
+    USER_CREATE(Arrays.asList("/user/create"), ControllerType.USER_CREATE_CONTROLLER),
+    USER_LOGIN(Arrays.asList("/user/setCookieAndRedirect"), ControllerType.USER_LOGIN_CONTROLLER),
+    USER_LIST(Arrays.asList("/user/list"), ControllerType.USER_LIST_CONTROLLER);
 
     private final List<String> paths;
-    private final Controllers controllers;
+    private final ControllerType controllerType;
 
-    HandlerMapping(List<String> paths, Controllers controllers) {
+    HandlerMapping(List<String> paths, ControllerType controllerType) {
         this.paths = paths;
-        this.controllers = controllers;
+        this.controllerType = controllerType;
     }
 
     public static HandlerMapping from(HttpRequest httpRequest) {
@@ -27,6 +29,6 @@ public static HandlerMapping from(HttpRequest httpRequest) {
     }
 
     public void service(HttpRequest httpRequest, HttpResponse httpResponse) {
-        this.controllers.service(httpRequest, httpResponse);
+        this.controllerType.service(httpRequest, httpResponse);
     }
 }

src/main/java/webserver/response/HttpResponse.java

@@ -40,6 +40,9 @@ public void sendError(Status status) {
     public void sendRedirect(String location) {
         try {
             processStatusLine(Status.FOUND);
+            if (headers.containsKey(ResponseHeader.SET_COOKIE)) {
+                processHeader(ResponseHeader.SET_COOKIE, headers.get(ResponseHeader.SET_COOKIE));
+            }
             processHeader(ResponseHeader.LOCATION, location);
             dos.flush();
         } catch (IOException e) {
@@ -57,6 +60,15 @@ public void forward(String path) {
         }
     }
 
+    public void forward(byte[] body) {
+        try {
+            response200Header(body);
+            responseBody(body);
+        } catch (IOException e) {
+            logger.error(e.getMessage());
+        }
+    }
+
     private void response200Header(byte[] body) throws IOException {
         processStatusLine(Status.OK);
         processHeader(EntityHeader.CONTENT_TYPE, headers.get(EntityHeader.CONTENT_TYPE));

src/main/java/webserver/response/ResponseHeader.java

@@ -3,7 +3,8 @@
 import webserver.HttpField;
 
 public enum ResponseHeader implements HttpField {
-    LOCATION("Location");
+    LOCATION("Location"),
+    SET_COOKIE("Set-Cookie");
 
     private final String header;
 

src/main/java/webserver/session/HttpSession.java

@@ -0,0 +1,34 @@
+package webserver.session;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class HttpSession {
+    private final String id;
+    private final Map<String, Object> attributes;
+
+    public HttpSession(String id) {
+        this.id = id;
+        this.attributes = new HashMap<>();
+    }
+
+    public String getId() {
+        return this.id;
+    }
+
+    public void setAttribute(String name, Object value) {
+        this.attributes.put(name, value);
+    }
+
+    public Object getAttribute(String name) {
+        return this.attributes.get(name);
+    }
+
+    public void removeAttribute(String name) {
+        this.attributes.remove(name);
+    }
+
+    public void invalidate() {
+        this.attributes.clear();
+    }
+}