[1,2단계 - Tomcat 구현하기] 몰리(김지민) 미션 제출합니다.

study/build.gradle

@@ -19,10 +19,10 @@ repositories {
 dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-web'
     implementation 'org.springframework.boot:spring-boot-starter-webflux'
-    implementation 'ch.qos.logback:logback-classic:1.5.7'
     implementation 'org.apache.commons:commons-lang3:3.14.0'
     implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.1'
     implementation 'pl.allegro.tech.boot:handlebars-spring-boot-starter:0.4.1'
+    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
 
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'org.assertj:assertj-core:3.26.0'

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

@@ -1,13 +1,21 @@
 package cache.com.example.cachecontrol;
 
 import org.springframework.context.annotation.Configuration;
+import org.springframework.http.CacheControl;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+import org.springframework.web.servlet.mvc.WebContentInterceptor;
 
 @Configuration
 public class CacheWebConfig implements WebMvcConfigurer {
 
     @Override
     public void addInterceptors(final InterceptorRegistry registry) {
+        CacheControl cacheControl = CacheControl.noCache().cachePrivate();
+
+        WebContentInterceptor webContentInterceptor = new WebContentInterceptor();
+        webContentInterceptor.addCacheMapping(cacheControl, "/**");
+
+        registry.addInterceptor(webContentInterceptor);
     }
 }

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

@@ -1,12 +1,20 @@
 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;
+
+import cache.com.example.version.CacheBustingWebConfig;
 
 @Configuration
 public class EtagFilterConfiguration {
 
-//    @Bean
-//    public FilterRegistrationBean<ShallowEtagHeaderFilter> shallowEtagHeaderFilter() {
-//        return null;
-//    }
+    @Bean
+    public FilterRegistrationBean<ShallowEtagHeaderFilter> shallowEtagHeaderFilter() {
+        FilterRegistrationBean<ShallowEtagHeaderFilter> filter = new FilterRegistrationBean<>();
+        filter.setFilter(new ShallowEtagHeaderFilter());
+        filter.addUrlPatterns("/etag", CacheBustingWebConfig.PREFIX_STATIC_RESOURCES + "/*");
+        return filter;
+    }
 }

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

@@ -1,7 +1,10 @@
 package cache.com.example.version;
 
+import java.time.Duration;
+
 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;
 
@@ -20,6 +23,7 @@ public CacheBustingWebConfig(ResourceVersion version) {
     @Override
     public void addResourceHandlers(final ResourceHandlerRegistry registry) {
         registry.addResourceHandler(PREFIX_STATIC_RESOURCES + "/" + version.getVersion() + "/**")
-                .addResourceLocations("classpath:/static/");
+                .addResourceLocations("classpath:/static/")
+                .setCacheControl(CacheControl.maxAge(Duration.ofDays(365)).cachePublic());
     }
 }

study/src/main/resources/application.yml

@@ -2,8 +2,12 @@ handlebars:
   suffix: .html
 
 server:
+  compression:
+    enabled: true
+    min-response-size: 10
   tomcat:
     accept-count: 1
     max-connections: 1
     threads:
+      min-spare: 2
       max: 2

tomcat/src/main/java/org/apache/catalina/Manager.java → tomcat/src/main/java/org/apache/catalina/session/Manager.java

@@ -1,6 +1,4 @@
-package org.apache.catalina;
-
-import jakarta.servlet.http.HttpSession;
+package org.apache.catalina.session;
 
 import java.io.IOException;
 
@@ -29,7 +27,7 @@ public interface Manager {
      *
      * @param session Session to be added
      */
-    void add(HttpSession session);
+    void add(Session session);
 
     /**
      * Return the active Session, associated with this Manager, with the
@@ -45,12 +43,12 @@ public interface Manager {
      * @return the request session or {@code null} if a session with the
      *         requested ID could not be found
      */
-    HttpSession findSession(String id) throws IOException;
+    Session findSession(String id) throws IOException;
 
     /**
      * Remove this Session from the active Sessions for this Manager.
      *
      * @param session Session to be removed
      */
-    void remove(HttpSession session);
+    void remove(Session session);
 }

tomcat/src/main/java/org/apache/catalina/session/Session.java

@@ -0,0 +1,35 @@
+package org.apache.catalina.session;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Session {
+
+    private final String id;
+    private final Map<String, Object> values = new HashMap<>();
+
+    public Session(final String id) {
+        this.id = id;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public Object getAttribute(final String name) {
+        return values.entrySet()
+                .stream()
+                .filter(entry -> entry.getKey().equals(name))
+                .map(Map.Entry::getValue)
+                .findFirst()
+                .orElse(null);
+    }
+
+    public Map<String, Object> getValues() {
+        return values;
+    }
+
+    public void setAttribute(String name, Object value) {
+        values.put(name, value);
+    }
+}

tomcat/src/main/java/org/apache/catalina/session/SessionManager.java

@@ -0,0 +1,35 @@
+package org.apache.catalina.session;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class SessionManager implements Manager {
+    private static final Map<String, Session> SESSIONS = new HashMap<>();
+    private static final SessionManager INSTANCE = new SessionManager();
+
+    private SessionManager() {}
+
+    public static SessionManager getInstance() {
+        return INSTANCE;
+    }
+
+    public boolean existsById(final String id) {
+        return SESSIONS.containsKey(id);
+    }
+
+    @Override
+    public void add(Session session) {
+        SESSIONS.put(session.getId(), session);
+    }
+
+    @Override
+    public Session findSession(final String id) {
+        return SESSIONS.get(id);
+    }
+
+    @Override
+    public void remove(Session session) {
+        SESSIONS.remove(session.getId());
+    }
+}
+

tomcat/src/main/java/org/apache/coyote/HandlerMapping.java

@@ -0,0 +1,59 @@
+package org.apache.coyote;
+
+import org.apache.coyote.handler.Handler;
+import org.apache.coyote.handler.LoginHandler;
+import org.apache.coyote.handler.RegisterHandler;
+import org.apache.coyote.handler.RootEndPointHandler;
+import org.apache.coyote.handler.StaticResourceHandler;
+import org.apache.coyote.handler.exception.InternalServerErrorHandler;
+import org.apache.coyote.handler.exception.NotFoundHandler;
+import org.apache.coyote.handler.exception.UnAuthorizationHandler;
+import org.apache.http.request.HttpRequest;
+
+
+public class HandlerMapping {
+
+    private static final HandlerMapping INSTANCE = new HandlerMapping();
+    private static final String PATH_DELIMITER = "/";
+
+    private HandlerMapping() {
+    }
+
+    public static HandlerMapping getInstance() {
+        return INSTANCE;
+    }
+
+    public Handler getHandler(final HttpRequest httpRequest) {
+        return getHandlerByEndPoint(httpRequest);
+    }
+
+    private Handler getHandlerByEndPoint(final HttpRequest httpRequest) {
+        final String path = httpRequest.getPath();
+
+        if (path.equals(PATH_DELIMITER)) {
+            return RootEndPointHandler.getInstance();
+        }
+
+        if (path.contains("login")) {
+            return LoginHandler.getInstance();
+        }
+
+        if (path.contains("register")) {
+            return RegisterHandler.getInstance();
+        }
+
+        return StaticResourceHandler.getInstance();
+    }
+
+    public Handler getHandlerByException(final Exception exception) {
+        if (exception instanceof NotFoundException) {
+            return NotFoundHandler.getInstance();
+        }
+
+        if (exception instanceof UnauthorizedException) {
+            return UnAuthorizationHandler.getInstance();
+        }
+
+        return InternalServerErrorHandler.getInstance();
+    }
+}

tomcat/src/main/java/org/apache/coyote/NotFoundException.java

@@ -0,0 +1,7 @@
+package org.apache.coyote;
+
+public class NotFoundException extends RuntimeException {
+    public NotFoundException(String message) {
+        super(message);
+    }
+}

tomcat/src/main/java/org/apache/coyote/UnauthorizedException.java

@@ -0,0 +1,7 @@
+package org.apache.coyote;
+
+public class UnauthorizedException extends RuntimeException {
+    public UnauthorizedException(String message) {
+        super(message);
+    }
+}

tomcat/src/main/java/org/apache/coyote/handler/Handler.java

@@ -0,0 +1,8 @@
+package org.apache.coyote.handler;
+
+import org.apache.http.request.HttpRequest;
+
+public abstract class Handler {
+    // TODO: 반환타입 HttpResponse로 변경
+    public abstract String handle(HttpRequest httpRequest);
+}

tomcat/src/main/java/org/apache/coyote/handler/LoginHandler.java

@@ -0,0 +1,74 @@
+package org.apache.coyote.handler;
+
+import java.util.Optional;
+import java.util.UUID;
+
+import org.apache.catalina.session.SessionManager;
+import org.apache.http.HttpCookie;
+import org.apache.http.HttpMethod;
+import org.apache.catalina.session.Session;
+import org.apache.http.header.StandardHttpHeader;
+import org.apache.http.request.HttpRequest;
+import org.apache.http.response.HttpResponseGenerator;
+
+import com.techcourse.db.InMemoryUserRepository;
+import com.techcourse.model.User;
+
+public class LoginHandler extends Handler {
+
+    private static final LoginHandler INSTANCE = new LoginHandler();
+    private final SessionManager sessionManager = SessionManager.getInstance();
+
+    private LoginHandler() {
+    }
+
+    public static LoginHandler getInstance() {
+        return INSTANCE;
+    }
+
+    @Override
+    public String handle(final HttpRequest httpRequest) {
+        if (httpRequest.isSameMethod(HttpMethod.GET)) {
+            return processLoginGetRequest(httpRequest);
+        }
+
+        if (httpRequest.isSameMethod(HttpMethod.POST)) {
+            return processLoginPostRequest(httpRequest);
+        }
+
+        return StaticResourceHandler.getInstance().handle(new HttpRequest("GET", "/404.html", "HTTP/1.1", null, null));
+
+    }
+
+    private String processLoginGetRequest(final HttpRequest httpRequest) {
+        HttpCookie httpCookie = httpRequest.getHttpCookie();
+        if (httpCookie == null || ! sessionManager.existsById(httpCookie.getValue("JSESSIONID"))) {
+            return StaticResourceHandler.getInstance().handle(new HttpRequest("GET", "/login.html", "HTTP/1.1", null, null));
+        }
+
+        return HttpResponseGenerator.getFoundResponse("/index.html");
+    }
+
+    private String processLoginPostRequest(final HttpRequest httpRequest) {
+        final String account = httpRequest.getFormBody("account");
+        final String password = httpRequest.getFormBody("password");
+
+        final Optional<User> userOptional = InMemoryUserRepository.findByAccount(account);
+        if (userOptional.isEmpty() || !userOptional.get().checkPassword(password)) {
+            return StaticResourceHandler.getInstance().handle(new HttpRequest("GET", "/401.html", "HTTP/1.1", null, null));
+        }
+
+        final Session session = new Session(UUID.randomUUID().toString());
+        session.setAttribute("user", userOptional.get());
+        sessionManager.add(session);
+        return addCookie(
+                HttpResponseGenerator.getFoundResponse("/index.html"),
+                HttpCookie.of("JSESSIONID=" + session.getId()));
+    }
+
+    private String addCookie(final String response, final HttpCookie cookie) {
+        return response
+                .concat("\n")
+                .concat(StandardHttpHeader.SET_COOKIE.getValue() + ": " + cookie.toString());
+    }
+}

tomcat/src/main/java/org/apache/coyote/handler/RegisterHandler.java

@@ -0,0 +1,41 @@
+package org.apache.coyote.handler;
+
+import org.apache.http.HttpMethod;
+import org.apache.http.request.HttpRequest;
+import org.apache.http.response.HttpResponseGenerator;
+
+import com.techcourse.db.InMemoryUserRepository;
+import com.techcourse.model.User;
+
+public class RegisterHandler extends Handler {
+
+    private static final RegisterHandler INSTANCE = new RegisterHandler();
+
+    private RegisterHandler() {
+    }
+
+    public static RegisterHandler getInstance() {
+        return INSTANCE;
+    }
+
+    public String handle(final HttpRequest httpRequest) {
+        if (httpRequest.isSameMethod(HttpMethod.GET)) {
+            return StaticResourceHandler.getInstance().handle(new HttpRequest("GET", "/register.html", "HTTP/1.1", null, null));
+        }
+
+        if (httpRequest.isSameMethod(HttpMethod.POST)) {
+            return processRegisterPostRequest(httpRequest);
+        }
+
+        return StaticResourceHandler.getInstance().handle(new HttpRequest("GET", "/401.html", "HTTP/1.1", null, null));
+    }
+
+    private String processRegisterPostRequest(final HttpRequest httpRequest) {
+        String[] body = httpRequest.getBody().split("&");
+        String account = body[0].split("=")[1];
+        String email = body[1].split("=")[1];
+        String password = body[2].split("=")[1];
+        InMemoryUserRepository.save(new User(account, password, email));
+        return HttpResponseGenerator.getFoundResponse("/index.html");
+    }
+}