[톰캣 구현하기 - 3, 4단계] 에단(김석호) 미션 제출합니다.

study/src/main/java/cache/com/example/cachecontrol/CacheInterceptor.java

@@ -0,0 +1,21 @@
+package cache.com.example.cachecontrol;
+
+import com.google.common.net.HttpHeaders;
+import org.springframework.http.CacheControl;
+import org.springframework.web.servlet.HandlerInterceptor;
+import org.springframework.web.servlet.ModelAndView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+public class CacheInterceptor implements HandlerInterceptor {
+
+    @Override
+    public void postHandle(final HttpServletRequest request, final HttpServletResponse response, final Object handler, final ModelAndView modelAndView) throws Exception {
+        final String cacheControlValue = CacheControl.noCache()
+                .cachePrivate()
+                .getHeaderValue();
+
+        response.addHeader(HttpHeaders.CACHE_CONTROL, cacheControlValue);
+    }
+}

study/src/main/java/cache/com/example/cachecontrol/CacheWebConfig.java

@@ -9,5 +9,7 @@ public class CacheWebConfig implements WebMvcConfigurer {
 
     @Override
     public void addInterceptors(final InterceptorRegistry registry) {
+        registry.addInterceptor(new CacheInterceptor())
+                .excludePathPatterns("/resources/**");
     }
 }

study/src/main/java/cache/com/example/etag/EtagFilterConfiguration.java

@@ -1,12 +1,19 @@
 package cache.com.example.etag;
 
+import org.springframework.boot.web.servlet.FilterRegistrationBean;
+import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.web.filter.ShallowEtagHeaderFilter;
 
 @Configuration
 public class EtagFilterConfiguration {
 
-//    @Bean
-//    public FilterRegistrationBean<ShallowEtagHeaderFilter> shallowEtagHeaderFilter() {
-//        return null;
-//    }
+    @Bean
+    public FilterRegistrationBean<ShallowEtagHeaderFilter> shallowEtagHeaderFilter() {
+        final FilterRegistrationBean<ShallowEtagHeaderFilter> shallowEtagHeaderFilterFilterRegistrationBean
+                = new FilterRegistrationBean<>(new ShallowEtagHeaderFilter());
+        shallowEtagHeaderFilterFilterRegistrationBean.addUrlPatterns("/etag", "/resources/*");
+        shallowEtagHeaderFilterFilterRegistrationBean.setName("etagFilter");
+        return shallowEtagHeaderFilterFilterRegistrationBean;
+    }
 }

study/src/main/java/cache/com/example/version/CacheBustingWebConfig.java

@@ -2,24 +2,28 @@
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.http.CacheControl;
 import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
+import java.util.concurrent.TimeUnit;
+
 @Configuration
 public class CacheBustingWebConfig implements WebMvcConfigurer {
 
     public static final String PREFIX_STATIC_RESOURCES = "/resources";
+    private static final Long MAX_AGE = 365L;
 
     private final ResourceVersion version;
 
     @Autowired
-    public CacheBustingWebConfig(ResourceVersion version) {
+    public CacheBustingWebConfig(final ResourceVersion version) {
         this.version = version;
     }
 
     @Override
     public void addResourceHandlers(final ResourceHandlerRegistry registry) {
         registry.addResourceHandler(PREFIX_STATIC_RESOURCES + "/" + version.getVersion() + "/**")
-                .addResourceLocations("classpath:/static/");
+                .setCacheControl(CacheControl.maxAge(MAX_AGE, TimeUnit.DAYS).cachePublic()).addResourceLocations("classpath:/static/");
     }
 }

study/src/main/resources/application.yml

@@ -4,6 +4,10 @@ handlebars:
 server:
   tomcat:
     accept-count: 1
-    max-connections: 1
+    max-connections: 2
     threads:
       max: 2
+
+  compression:
+    enabled: true
+    min-response-size: 10

study/src/test/java/thread/stage0/SynchronizationTest.java

@@ -41,7 +41,7 @@ private static final class SynchronizedMethods {
 
         private int sum = 0;
 
-        public void calculate() {
+        public synchronized void calculate() {
             setSum(getSum() + 1);
         }
 

study/src/test/java/thread/stage0/ThreadPoolsTest.java

@@ -31,8 +31,8 @@ void testNewFixedThreadPool() {
         executor.submit(logWithSleep("hello fixed thread pools"));
 
         // 올바른 값으로 바꿔서 테스트를 통과시키자.
-        final int expectedPoolSize = 0;
-        final int expectedQueueSize = 0;
+        final int expectedPoolSize = 2;
+        final int expectedQueueSize = 1;
 
         assertThat(expectedPoolSize).isEqualTo(executor.getPoolSize());
         assertThat(expectedQueueSize).isEqualTo(executor.getQueue().size());
@@ -46,7 +46,7 @@ void testNewCachedThreadPool() {
         executor.submit(logWithSleep("hello cached thread pools"));
 
         // 올바른 값으로 바꿔서 테스트를 통과시키자.
-        final int expectedPoolSize = 0;
+        final int expectedPoolSize = 3;
         final int expectedQueueSize = 0;
 
         assertThat(expectedPoolSize).isEqualTo(executor.getPoolSize());

study/src/test/java/thread/stage1/UserServlet.java

@@ -11,7 +11,7 @@ public void service(final User user) {
         join(user);
     }
 
-    private void join(final User user) {
+    private synchronized void join(final User user) {
         if (!users.contains(user)) {
             users.add(user);
         }

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

@@ -1,11 +1,13 @@
 package nextstep;
 
+import nextstep.jwp.controller.FrontHandler;
 import org.apache.catalina.startup.Tomcat;
+import org.apache.coyote.http.session.SessionManager;
 
 public class Application {
 
-    public static void main(String[] args) {
-        final var tomcat = new Tomcat();
+    public static void main(final String[] args) {
+        final var tomcat = new Tomcat(new FrontHandler(new SessionManager()));
         tomcat.start();
     }
 }

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

@@ -0,0 +1,37 @@
+package nextstep.jwp.controller;
+
+import org.apache.coyote.controller.Controller;
+import org.apache.coyote.controller.RequestHandler;
+import org.apache.coyote.http.LoginManager;
+import org.apache.coyote.http.request.HttpRequest;
+import org.apache.coyote.http.response.HttpResponse;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Set;
+
+import static nextstep.jwp.controller.Path.NOT_FOUND;
+
+public class FrontHandler implements RequestHandler {
+
+    private final Set<Controller> requestControllers = new HashSet<>();
+
+    public FrontHandler(final LoginManager loginManager) {
+        requestControllers.add(new HomePageController());
+        requestControllers.add(new StaticFileController());
+        requestControllers.add(new LoginController(loginManager));
+        requestControllers.add(new RegisterController());
+    }
+
+    @Override
+    public void handle(final HttpRequest request, final HttpResponse response) throws IOException {
+        for (final Controller controller : requestControllers) {
+            if (controller.supports(request)) {
+                controller.service(request, response);
+                return;
+            }
+        }
+
+        response.mapToRedirect(NOT_FOUND.getValue());
+    }
+}

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

@@ -0,0 +1,33 @@
+package nextstep.jwp.controller;
+
+import org.apache.coyote.http.common.ContentType;
+import org.apache.coyote.http.common.HttpBody;
+import org.apache.coyote.http.request.HttpRequest;
+import org.apache.coyote.http.response.HttpResponse;
+import org.apache.coyote.http.response.StatusCode;
+import org.apache.coyote.http.response.StatusLine;
+
+import static org.apache.coyote.http.common.HttpHeader.CONTENT_TYPE;
+
+public class HomePageController extends RequestController {
+
+    private static final String HOME_MESSAGE = "Hello world!";
+    private static final String TARGET_URI = "/";
+
+    @Override
+    public boolean supports(final HttpRequest httpRequest) {
+        return TARGET_URI.equals(httpRequest.getRequestUri().getRequestUri());
+    }
+
+    @Override
+    protected void doPost(final HttpRequest request, final HttpResponse response) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    protected void doGet(final HttpRequest request, final HttpResponse response) {
+        response.changeStatusLine(StatusLine.from(StatusCode.OK));
+        response.addHeader(CONTENT_TYPE, ContentType.HTML.getValue());
+        response.changeBody(new HttpBody(HOME_MESSAGE));
+    }
+}

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

@@ -0,0 +1,171 @@
+package nextstep.jwp.controller;
+
+import nextstep.jwp.db.InMemoryUserRepository;
+import nextstep.jwp.model.User;
+import org.apache.coyote.http.LoginManager;
+import org.apache.coyote.http.common.ContentType;
+import org.apache.coyote.http.common.HttpBody;
+import org.apache.coyote.http.common.HttpHeader;
+import org.apache.coyote.http.request.HttpCookie;
+import org.apache.coyote.http.request.HttpRequest;
+import org.apache.coyote.http.request.QueryString;
+import org.apache.coyote.http.response.HttpResponse;
+import org.apache.coyote.http.response.StatusCode;
+import org.apache.coyote.http.response.StatusLine;
+import org.apache.coyote.http.session.Session;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.UUID;
+
+import static nextstep.jwp.controller.Path.LOGIN;
+import static nextstep.jwp.controller.Path.MAIN;
+import static nextstep.jwp.controller.Path.UNAUTHORIZED;
+import static org.apache.coyote.http.common.HttpHeader.CONTENT_TYPE;
+import static org.apache.coyote.http.common.HttpHeader.COOKIE;
+
+public class LoginController extends RequestController {
+
+    private static final String TARGET_URI = "login";
+    private static final Logger log = LoggerFactory.getLogger(LoginController.class);
+    private static final String CREDENTIALS = "account";
+    private static final String PASSWORD = "password";
+
+    private final LoginManager loginManager;
+
+    public LoginController(final LoginManager loginManager) {
+        this.loginManager = loginManager;
+    }
+
+    @Override
+    public boolean supports(final HttpRequest httpRequest) {
+        return httpRequest.containsRequestUri(TARGET_URI);
+    }
+
+    @Override
+    protected void doPost(final HttpRequest request, final HttpResponse response) {
+        try {
+            final User user = getValidateUser(request);
+
+            log.info("로그인 성공! user = {}", user);
+            final UUID uuid = createSessionToUser(user);
+
+            setCookieAndRedirectToMain(response, uuid);
+        } catch (final IllegalArgumentException e) {
+            log.warn("login error = {}", e.getMessage());
+            redirectToUnAuthorized(response);
+        }
+    }
+
+    private User getValidateUser(final HttpRequest request) {
+        final Map<String, String> bodyParams = request.getParsedBody();
+        final String account = bodyParams.get(CREDENTIALS);
+        final String password = bodyParams.get(PASSWORD);
+
+        final User user = InMemoryUserRepository.findByAccount(account)
+                .orElseThrow(() -> new IllegalArgumentException("잘못된 계정입니다. 다시 입력해주세요."));
+
+        if (!user.checkPassword(password)) {
+            throw new IllegalArgumentException("잘못된 비밀번호입니다. 다시 입력해주세요.");
+        }
+
+        return user;
+    }
+
+    private UUID createSessionToUser(final User user) {
+        final UUID uuid = UUID.randomUUID();
+
+        final Map<String, String> sessionData = Map.of(CREDENTIALS, user.getAccount());
+        final Session session = new Session(uuid.toString());
+        for (final Map.Entry<String, String> entry : sessionData.entrySet()) {
+            session.add(entry.getKey(), entry.getValue());
+        }
+
+        loginManager.add(session);
+
+        return uuid;
+    }
+
+    private static void setCookieAndRedirectToMain(final HttpResponse response, final UUID uuid) {
+        response.changeStatusLine(StatusLine.from(StatusCode.FOUND));
+        response.addHeader(HttpHeader.LOCATION, MAIN.getValue());
+        response.addHeader(HttpHeader.SET_COOKIE, "JSESSIONID=" + uuid);
+        response.changeBody(HttpBody.empty());
+    }
+
+    @Override
+    protected void doGet(final HttpRequest request, final HttpResponse response) throws IOException {
+        if (isAlreadyLogined(request)) {
+            redirectToMain(response);
+            return;
+        }
+
+        if (wantToLogin(request)) {
+            doLoginProcess(request, response);
+            return;
+        }
+
+        redirectToLoginPage(response);
+    }
+
+    private boolean isAlreadyLogined(final HttpRequest request) {
+        if (!request.containsHeader(COOKIE)) {
+            return false;
+        }
+
+        final HttpCookie cookies = HttpCookie.from(request.getHeader(COOKIE));
+
+        return checkLogin(cookies.get("JSESSIONID"));
+    }
+
+    private void redirectToMain(final HttpResponse response) {
+        response.mapToRedirect(MAIN.getValue());
+    }
+
+    private boolean wantToLogin(final HttpRequest request) {
+        return request.hasQueryString();
+    }
+
+    private void doLoginProcess(final HttpRequest request, final HttpResponse response) {
+        final QueryString queryString = request.getQueryString();
+
+        final String account = queryString.get(CREDENTIALS);
+        final String password = queryString.get(PASSWORD);
+
+        try {
+            validateUserCredentials(account, password);
+            log.info("로그인 성공! account = {}", account);
+        } catch (final IllegalArgumentException e) {
+            log.warn("login error = {}", e.getMessage());
+            redirectToUnAuthorized(response);
+            return;
+        }
+
+        redirectToMain(response);
+    }
+
+    private void redirectToUnAuthorized(final HttpResponse response) {
+        response.mapToRedirect(UNAUTHORIZED.getValue());
+    }
+
+    private void validateUserCredentials(final String account, final String password) {
+        final User user = InMemoryUserRepository.findByAccount(account)
+                .orElseThrow(() -> new IllegalArgumentException("잘못된 계정입니다. 다시 입력해주세요."));
+
+        if (!user.checkPassword(password)) {
+            throw new IllegalArgumentException("잘못된 비밀번호입니다. 다시 입력해주세요.");
+        }
+    }
+
+    private boolean checkLogin(final String jSessionId) {
+        return loginManager.isAlreadyLogined(jSessionId);
+    }
+
+    private void redirectToLoginPage(final HttpResponse response) throws IOException {
+        response.changeStatusLine(StatusLine.from(StatusCode.OK));
+        response.addHeader(CONTENT_TYPE, ContentType.HTML.getValue());
+        response.changeBody(HttpBody.file(LOGIN.getValue()));
+    }
+}