[Web-Filter] 필터 및 필터체인 개발

src/main/java/bootstrap/WebServer.java

@@ -5,15 +5,19 @@
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
-import config.DependencyLoader;
+import config.AppConfig;
+import config.FilterConfig;
+import config.SecurityConfig;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import web.dispatch.ConnectionHandler;
 
 public class WebServer {
     private static final Logger logger = LoggerFactory.getLogger(WebServer.class);
     private static final int DEFAULT_PORT = 8080;
-    private static final DependencyLoader LOADER = new DependencyLoader();
+    private static final AppConfig LOADER = new AppConfig();
+    private static final SecurityConfig securityConfig = new SecurityConfig();
+    private static final FilterConfig filterConfig = new FilterConfig();
     private static final ExecutorService executor = Executors.newFixedThreadPool(32);
 
     public static void main(String args[]) throws Exception {
@@ -23,6 +27,7 @@ public static void main(String args[]) throws Exception {
         } else {
             port = Integer.parseInt(args[0]);
         }
+        config();
 
         // 서버소켓을 생성한다. 웹서버는 기본적으로 8080번 포트를 사용한다.
         try (ServerSocket listenSocket = new ServerSocket(port)) {
@@ -33,14 +38,20 @@ public static void main(String args[]) throws Exception {
             while ((connection = listenSocket.accept()) != null) {
                 Socket singleConnection = connection;
                 executor.submit(() -> {
-                    ConnectionHandler connectionHandler = new ConnectionHandler(LOADER.dispatcher,
-                            LOADER.exceptionHandlerMapping,
-                            LOADER.httpResponseConverter,
-                            LOADER.httpRequestConverter,
+                    ConnectionHandler connectionHandler = new ConnectionHandler(
+                            LOADER.filterChainContainer(),
+                            LOADER.exceptionHandlerMapping(),
+                            LOADER.httpResponseConverter(),
+                            LOADER.httpRequestConverter(),
                             singleConnection);
                     connectionHandler.run();
                 });
             }
         }
     }
+
+    private static void config(){
+        securityConfig.config();
+        filterConfig.config();
+    }
 }

src/main/java/config/AppConfig.java

@@ -18,6 +18,9 @@
 import web.dispatch.argument.ArgumentResolver;
 import web.dispatch.argument.resolver.HttpRequestResolver;
 import web.dispatch.argument.resolver.QueryParamsResolver;
+import web.filter.AccessLogFilter;
+import web.filter.FilterChainContainer;
+import web.filter.RestrictedFilter;
 import web.handler.StaticContentHandler;
 import web.handler.WebHandler;
 import web.renderer.HttpResponseRenderer;
@@ -209,4 +212,20 @@ public ErrorExceptionHandler errorExceptionHandler() {
                 ErrorExceptionHandler::new
         );
     }
+
+    /**
+     * ===== Filter =====
+     */
+    public FilterChainContainer filterChainContainer(){
+        return getOrCreate("filterChainContainer",
+                () -> new FilterChainContainer(dispatcher()));
+    }
+
+    public AccessLogFilter accessLogFilter(){
+        return getOrCreate("accessLogFilter", AccessLogFilter::new);
+    }
+
+    public RestrictedFilter restrictedFilter(){
+        return getOrCreate("restrictedFilter", RestrictedFilter::new);
+    }
 }

src/main/java/config/FilterConfig.java

@@ -0,0 +1,56 @@
+package config;
+
+import exception.ErrorException;
+import web.filter.ServletFilter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FilterConfig extends SingletonContainer {
+    private final AppConfig appConfig = new AppConfig();
+    private int callCount = 0;
+
+    public void config(){
+        if(callCount>0) throw new ErrorException("FilterConfig::set: Duplicated call");
+        setFilterChains();
+        callCount++;
+    }
+
+    private void setFilterChains(){
+        appConfig.filterChainContainer()
+                .addFilterList(FilterType.ALL, getFilterListByAuthorityType(FilterType.ALL))
+                .addFilterList(FilterType.PUBLIC, getFilterListByAuthorityType(FilterType.PUBLIC))
+                .addFilterList(FilterType.AUTHENTICATED, getFilterListByAuthorityType(FilterType.AUTHENTICATED))
+                .addFilterList(FilterType.RESTRICT, getFilterListByAuthorityType(FilterType.RESTRICT));
+    }
+
+    private List<ServletFilter> commonFrontFilter(){
+        return getOrCreate("commonFrontFilter",
+                () -> List.of(
+                        appConfig.accessLogFilter()
+                ));
+    }
+
+    private List<ServletFilter> commonBackFilter(){
+        return getOrCreate("commonBackFilter",
+                () -> List.of());
+    }
+
+    private List<ServletFilter> getFilterListByAuthorityType(FilterType type) {
+        List<ServletFilter> servletFilterList = new ArrayList<>();
+        servletFilterList.addAll(commonFrontFilter());
+        servletFilterList.addAll(authorizedFilterList(type));
+        servletFilterList.addAll(commonBackFilter());
+        return servletFilterList;
+    }
+
+    private List<ServletFilter> authorizedFilterList(FilterType type) {
+        return switch (type) {
+            case ALL -> List.of();
+            case PUBLIC -> List.of();
+            case AUTHENTICATED -> List.of();
+            case RESTRICT -> List.of(appConfig.restrictedFilter());
+            case LOG_IN -> List.of();
+        };
+    }
+}

src/main/java/config/FilterType.java

@@ -0,0 +1,9 @@
+package config;
+
+public enum FilterType {
+    ALL,
+    PUBLIC,
+    AUTHENTICATED,
+    RESTRICT,
+    LOG_IN
+}

src/main/java/config/SecurityConfig.java

@@ -0,0 +1,23 @@
+package config;
+
+import exception.ErrorException;
+
+public class SecurityConfig extends SingletonContainer {
+    private final AppConfig appConfig = new AppConfig();
+    private int callCount;
+
+    public void config(){
+        if(callCount>0) throw new ErrorException("SecurityConfig::setPaths: Duplicated call");
+        setPaths();
+        callCount++;
+    }
+
+    public void setPaths(){
+        appConfig.filterChainContainer()
+                .addPath(FilterType.AUTHENTICATED, "/mypage/**")
+                .addPath(FilterType.ALL, "/user/**")
+                .addPath(FilterType.PUBLIC, "/**");
+    }
+
+
+}

src/main/java/http/HttpStatus.java

@@ -1,6 +1,8 @@
 package http;
 
 public enum HttpStatus {
+    NONE(0),
+
     OK(200),
     CREATED(201),
     ACCEPTED(202),

src/main/java/http/request/HttpRequest.java

@@ -7,10 +7,7 @@
 
 import java.net.InetAddress;
 import java.net.URI;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
 
 public class HttpRequest {
     private final HttpMethod method;
@@ -20,6 +17,7 @@ public class HttpRequest {
     private final URI uri;
     private String contentType;
     private byte[] body;
+    private UUID rid;
 
     private InetAddress requestAddress;
 
@@ -102,4 +100,14 @@ public InetAddress getRequestAddress() {
     public void setBody(byte[] body){
         this.body = body;
     }
+
+    public String getOrGenerateRid(){
+        if(this.rid == null)
+            this.rid = UUID.randomUUID();
+        return this.rid.toString();
+    }
+
+    public UUID getRid() {
+        return rid;
+    }
 }

src/main/java/http/response/HttpResponse.java

@@ -12,8 +12,8 @@
 import java.util.Map;
 
 public class HttpResponse {
-    private final HttpStatus status;
     private final Map<String, List<String>> headers;
+    private HttpStatus status;
     private byte[] body;
 
     private HttpResponse (HttpStatus status){
@@ -28,6 +28,14 @@ public static HttpResponse of (HttpStatus status){
         return new HttpResponse(status);
     }
 
+    public static HttpResponse of (){
+        return new HttpResponse(HttpStatus.NONE);
+    }
+
+    public void setStatus(HttpStatus status) {
+        this.status = status;
+    }
+
     public HttpStatus getStatus() {
         return status;
     }

src/main/java/web/dispatch/ConnectionHandler.java

@@ -5,22 +5,23 @@
 import http.request.HttpRequestConverter;
 import http.request.HttpRequest;
 import http.response.HttpResponse;
+import web.filter.FilterChainContainer;
 
 import java.net.Socket;
 
 public class ConnectionHandler implements Runnable{
     private final Socket connection;
+    private final FilterChainContainer filterChainContainer;
     private final HttpRequestConverter requestConverter;
     private final HttpResponseConverter responseConverter;
     private final ExceptionHandlerMapping exceptionHandlerMapping;
-    private final Dispatcher dispatcher;
 
-    public ConnectionHandler(Dispatcher dispatcher,
+    public ConnectionHandler(FilterChainContainer filterChainContainer,
                              ExceptionHandlerMapping exceptionHandlerMapping,
                              HttpResponseConverter responseConverter,
                              HttpRequestConverter requestConverter,
                              Socket connection) {
-        this.dispatcher = dispatcher;
+        this.filterChainContainer = filterChainContainer;
         this.exceptionHandlerMapping = exceptionHandlerMapping;
         this.responseConverter = responseConverter;
         this.requestConverter = requestConverter;
@@ -30,22 +31,23 @@ public ConnectionHandler(Dispatcher dispatcher,
     @Override
     public void run() {
 
+        HttpResponse response = HttpResponse.of();
         try {
 
             HttpRequest request = requestConverter.parseRequest(connection);
-            HttpResponse response = dispatcher.handle(request);
+            filterChainContainer.runFilterChain(request,response);
             responseConverter.sendResponse(response, connection);
 
-        } catch (Exception e){
+        } catch (Throwable t){
             /**
              * TODO:
              * ExceptionHandler 또한 HttpResponse를 반환하게 하고
              * finally에 `responseConverter.sendResponse(response, connection);` 를 넣어
              * socket에 write를 하는 포인트를 단일 포인트로 관리
              */
-            exceptionHandlerMapping.handle(e, connection);
+            exceptionHandlerMapping.handle(t, connection);
         } finally {
-            try { connection.close(); } catch (Exception ignore) {}
+            try { connection.close(); } catch (Throwable ignore) {}
         }
     }
 }

src/main/java/web/dispatch/Dispatcher.java

@@ -28,7 +28,7 @@ public Dispatcher(List<WebHandler> handlerMapping, List<HandlerAdapter> adapterL
         handlerMapping.forEach(hm -> this.handlerMapping.get(hm.getMethod()).add(hm));
     }
 
-    public HttpResponse handle(HttpRequest request){
+    public HttpResponse handle(HttpRequest request, HttpResponse response){
         logger.debug("{}: {} - {} from {}",
                 request.getMethod(), request.getPath(), request.getQueryString(), request.getRequestAddress());
 
@@ -41,11 +41,11 @@ public HttpResponse handle(HttpRequest request){
         HandlerAdapter adapter = adapterList.stream().filter(ha -> ha.support(handler))
                 .findFirst().orElseThrow(() -> new ErrorException("DispatcherError: No adapter matched"));
 
-        HandlerResponse response = adapter.handle(request, handler);
+        HandlerResponse handlerResponse = adapter.handle(request, handler);
 
         HttpResponseRenderer responseHandler = responseHandlerList.stream()
-                .filter(rh -> rh.supports(response))
-                .findFirst().orElseThrow(()-> new ErrorException("Post handler not exists"));
-        return responseHandler.handle(response);
+                .filter(rh -> rh.supports(handlerResponse))
+                .findFirst().orElseThrow(()-> new ErrorException("Renderer not exists"));
+        return responseHandler.handle(response, handlerResponse);
     }
 }

src/main/java/web/filter/AccessLogFilter.java

@@ -0,0 +1,21 @@
+package web.filter;
+
+import http.request.HttpRequest;
+import http.response.HttpResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class AccessLogFilter implements ServletFilter {
+
+    private static final Logger log = LoggerFactory.getLogger(AccessLogFilter.class);
+
+    @Override
+    public void runFilter(HttpRequest request, HttpResponse response, FilterChainContainer.FilterChainEngine chain) {
+        chain.doFilter();
+        log.info("rid-{}: {} {} from {}",
+                request.getOrGenerateRid(),
+                request.getMethod(),
+                request.getPath(),
+                request.getRequestAddress());
+    }
+}