[Authentication] 로그인 필터 및 핸들러 개발

src/main/java/app/db/Database.java

@@ -3,18 +3,27 @@
 import app.model.User;
 
 import java.util.Collection;
-import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicLong;
 
 public class Database {
-    private static Map<String, User> users = new HashMap<>();
+    private static Map<Long, User> users = new ConcurrentHashMap<>();
+    private static AtomicLong sequentialId = new AtomicLong(0);
 
     public static void addUser(User user) {
-        users.put(user.getUserId(), user);
+        long id = sequentialId.getAndIncrement();
+        user.setUserId(id);
+        users.put(id, user);
     }
 
-    public static User findUserById(String userId) {
-        return users.get(userId);
+    public static Optional<User> findUserById(Long userId) {
+        return Optional.ofNullable(users.get(userId));
+    }
+
+    public static Optional<User> findUserByEmail(String email){
+        return users.values().stream().filter(u -> u.getEmail().equals(email)).findAny();
     }
 
     public static Collection<User> findAll() {

src/main/java/app/handler/LoginWithPost.java

@@ -0,0 +1,54 @@
+package app.handler;
+
+import app.db.Database;
+import app.model.User;
+import config.VariableConfig;
+import exception.ErrorCode;
+import exception.ServiceException;
+import http.HttpMethod;
+import http.response.CookieBuilder;
+import web.dispatch.argument.QueryParameters;
+import web.handler.SingleArgHandler;
+import web.response.HandlerResponse;
+import web.response.RedirectResponse;
+import web.session.SessionEntity;
+import web.session.SessionStorage;
+
+public class LoginWithPost extends SingleArgHandler<QueryParameters> {
+    private final SessionStorage sessionManager;
+
+    public LoginWithPost(SessionStorage sessionManager) {
+        super(HttpMethod.POST, "/user/login");
+        this.sessionManager = sessionManager;
+    }
+
+    @Override
+    public HandlerResponse handle(QueryParameters params) {
+        String email = params.getQueryValue("email")
+                .orElseThrow(() -> new ServiceException(ErrorCode.LOGIN_FAILED, "email required"));
+
+        String password = params.getQueryValue("password")
+                .orElseThrow(() -> new ServiceException(ErrorCode.LOGIN_FAILED, "password required"));
+
+        User user = Database.findUserByEmail(email)
+                .orElseThrow(() -> new ServiceException(ErrorCode.LOGIN_FAILED));
+
+        if (!user.getPassword().equals(password)) {
+            throw new ServiceException(ErrorCode.LOGIN_FAILED);
+        }
+
+        SessionEntity session = sessionManager.create(
+                user.getUserId(),
+                user.getUserRole());
+
+        RedirectResponse res = RedirectResponse.to("/");
+        res.setCookie(
+                CookieBuilder.of("SID", session.getId())
+                        .path("/")
+                        .httpOnly()
+                        .sameSite(CookieBuilder.SameSite.LAX)
+                        .maxAge(VariableConfig.ABSOLUTE_MS)
+        );
+        return res;
+    }
+}

src/main/java/app/handler/RegisterWithGet.java

@@ -8,6 +8,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import web.dispatch.argument.QueryParameters;
+import web.filter.authentication.UserRole;
 import web.handler.SingleArgHandler;
 import web.response.HandlerResponse;
 import web.response.StaticViewResponse;
@@ -22,12 +23,11 @@ public RegisterWithGet() {
 
     @Override
     public HandlerResponse handle(QueryParameters params) {
-        String userId = params.getQueryValue("userId").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "userId required"));
-        String password = params.getQueryValue("password").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "password required"));
-        String name = params.getQueryValue("name").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "name required"));
         String email = params.getQueryValue("email").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "email required"));
-        Database.addUser(new User(userId, password, name, email));
-        log.info("Registered - userId:{}, password:{}, name:{}, email:{}", userId, password, name, email);
+        String password = params.getQueryValue("password").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "password required"));
+        String nickname = params.getQueryValue("nickname").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "nickname required"));
+        Database.addUser(new User(password, nickname, email, UserRole.MEMBER.toString()));
+        log.info("Registered - password:{}, nickname:{}, email:{}", password, nickname, email);
         return StaticViewResponse.of("/login");
     }
 }

src/main/java/app/handler/RegisterWithPost.java

@@ -8,6 +8,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import web.dispatch.argument.QueryParameters;
+import web.filter.authentication.UserRole;
 import web.handler.SingleArgHandler;
 import web.response.HandlerResponse;
 import web.response.StaticViewResponse;
@@ -21,12 +22,11 @@ public RegisterWithPost() {
 
     @Override
     public HandlerResponse handle(QueryParameters params) {
-        String userId = params.getQueryValue("userId").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "userId required"));
-        String password = params.getQueryValue("password").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "password required"));
-        String name = params.getQueryValue("name").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "name required"));
         String email = params.getQueryValue("email").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "email required"));
-        Database.addUser(new User(userId, password, name, email));
-        log.info("Registered - userId:{}, password:{}, name:{}, email:{}", userId, password, name, email);
+        String nickname = params.getQueryValue("nickname").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "nickname required"));
+        String password = params.getQueryValue("password").orElseThrow(()-> new ServiceException(ErrorCode.MISSING_REGISTER_TOKEN, "password required"));
+        Database.addUser(new User(password, nickname, email, UserRole.MEMBER.toString()));
+        log.info("Registered - password:{}, nickname:{}, email:{}", password, nickname, email);
         return StaticViewResponse.of("/login");
     }
 }

src/main/java/app/model/User.java

@@ -1,36 +1,45 @@
 package app.model;
 
 public class User {
-    private String userId;
+    private Long userId;
     private String password;
-    private String name;
+    private String nickname;
     private String email;
+    private String userRole;
 
-    public User(String userId, String password, String name, String email) {
-        this.userId = userId;
+    public User(String password, String nickname, String email, String userRole) {
         this.password = password;
-        this.name = name;
+        this.nickname = nickname;
         this.email = email;
+        this.userRole = userRole;
     }
 
-    public String getUserId() {
+    public Long getUserId() {
         return userId;
     }
 
+    public void setUserId(Long userId){
+        this.userId = userId;
+    }
+
     public String getPassword() {
         return password;
     }
 
-    public String getName() {
-        return name;
+    public String getNickname() {
+        return nickname;
     }
 
     public String getEmail() {
         return email;
     }
 
+    public String getUserRole() {
+        return userRole;
+    }
+
     @Override
     public String toString() {
-        return "User [userId=" + userId + ", password=" + password + ", name=" + name + ", email=" + email + "]";
+        return "User [userId=" + userId + ", password=" + password + ", name=" + nickname + ", email=" + email + "]";
     }
 }

src/main/java/config/AppConfig.java

@@ -1,5 +1,6 @@
 package config;
 
+import app.handler.LoginWithPost;
 import app.handler.RegisterWithGet;
 import app.handler.RegisterWithPost;
 import exception.ExceptionHandlerMapping;
@@ -18,13 +19,13 @@
 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.filter.*;
 import web.handler.StaticContentHandler;
 import web.handler.WebHandler;
 import web.renderer.HttpResponseRenderer;
+import web.renderer.RedirectRenderer;
 import web.renderer.StaticViewRenderer;
+import web.session.SessionStorage;
 
 import java.util.List;
 
@@ -71,7 +72,7 @@ public Dispatcher dispatcher() {
                 () -> new Dispatcher(
                         webHandlerList(),
                         handlerAdapterList(),
-                        webHandlerResponseHandlerList()
+                        httpResponseRendererList()
                 )
         );
     }
@@ -82,11 +83,19 @@ public List<WebHandler> webHandlerList() {
                 () -> List.of(
                         staticContentHandler(),
                         registerWithGet(),
-                        registerWithPost()
+                        registerWithPost(),
+                        loginWithPost()
                 )
         );
     }
 
+    public StaticContentHandler staticContentHandler() {
+        return getOrCreate(
+                "staticContentHandler",
+                StaticContentHandler::new
+        );
+    }
+
     public RegisterWithGet registerWithGet() {
         return getOrCreate(
                 "registerWithGet",
@@ -101,29 +110,34 @@ public RegisterWithPost registerWithPost() {
         );
     }
 
-    public List<HttpResponseRenderer> webHandlerResponseHandlerList() {
+    public LoginWithPost loginWithPost() {
+        return getOrCreate("loginWithPost",
+                () -> new LoginWithPost(sessionStorage()));
+    }
+
+    // ===== Renderer =====
+    public List<HttpResponseRenderer> httpResponseRendererList() {
         return getOrCreate(
-                "webHandlerResponseHandlerList",
+                "httpResponseRendererList",
                 () -> List.of(
-                        staticViewResponseHandler()
+                        staticViewRenderer(),
+                        redirectRenderer()
                 )
         );
     }
 
-    public StaticContentHandler staticContentHandler() {
+    public StaticViewRenderer staticViewRenderer() {
         return getOrCreate(
-                "staticContentHandler",
-                StaticContentHandler::new
+                "staticViewRenderer",
+                StaticViewRenderer::new
         );
     }
 
-    public StaticViewRenderer staticViewResponseHandler() {
-        return getOrCreate(
-                "staticViewResponseHandler",
-                StaticViewRenderer::new
-        );
+    public RedirectRenderer redirectRenderer() {
+        return getOrCreate("redirectRenderer", RedirectRenderer::new);
     }
 
+
     // ===== Adapter =====
     public List<HandlerAdapter> handlerAdapterList() {
         return getOrCreate(
@@ -228,4 +242,24 @@ public AccessLogFilter accessLogFilter(){
     public RestrictedFilter restrictedFilter(){
         return getOrCreate("restrictedFilter", RestrictedFilter::new);
     }
+
+    public AuthenticationFilter authenticationFilter() {
+        return getOrCreate("authenticationFilter",
+                () -> new AuthenticationFilter(sessionStorage()));
+    }
+
+    public MemberAuthorizationFilter memberAuthorizationFilter(){
+        return getOrCreate("memberAuthorizationFilter",
+                MemberAuthorizationFilter::new);
+    }
+
+    public UnanimousAuthorizationFilter unanimousAuthorizationFilter(){
+        return getOrCreate("unanimousAuthorizationFilter",
+                UnanimousAuthorizationFilter::new);
+    }
+
+    public SessionStorage sessionStorage() {
+        return getOrCreate("sessionStorage",
+                SessionStorage::new);
+    }
 }

src/main/java/config/FilterConfig.java

@@ -21,7 +21,8 @@ private void setFilterChains(){
                 .addFilterList(FilterType.ALL, getFilterListByAuthorityType(FilterType.ALL))
                 .addFilterList(FilterType.PUBLIC, getFilterListByAuthorityType(FilterType.PUBLIC))
                 .addFilterList(FilterType.AUTHENTICATED, getFilterListByAuthorityType(FilterType.AUTHENTICATED))
-                .addFilterList(FilterType.RESTRICT, getFilterListByAuthorityType(FilterType.RESTRICT));
+                .addFilterList(FilterType.RESTRICT, getFilterListByAuthorityType(FilterType.RESTRICT))
+                .addFilterList(FilterType.LOG_IN, getFilterListByAuthorityType(FilterType.LOG_IN));
     }
 
     private List<ServletFilter> commonFrontFilter(){
@@ -47,10 +48,16 @@ private List<ServletFilter> getFilterListByAuthorityType(FilterType type) {
     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();
+            case PUBLIC -> List.of(
+                    appConfig.authenticationFilter());
+            case AUTHENTICATED -> List.of(
+                    appConfig.authenticationFilter(),
+                    appConfig.memberAuthorizationFilter());
+            case RESTRICT -> List.of(
+                    appConfig.restrictedFilter());
+            case LOG_IN -> List.of(
+                    appConfig.authenticationFilter(),
+                    appConfig.unanimousAuthorizationFilter());
         };
     }
 }

src/main/java/config/SecurityConfig.java

@@ -15,6 +15,7 @@ public void config(){
     public void setPaths(){
         appConfig.filterChainContainer()
                 .addPath(FilterType.AUTHENTICATED, "/mypage/**")
+                .addPath(FilterType.LOG_IN, "/user/login")
                 .addPath(FilterType.ALL, "/user/**")
                 .addPath(FilterType.PUBLIC, "/**");
     }

src/main/java/config/VariableConfig.java

@@ -6,4 +6,7 @@ public class VariableConfig {
     public static final List<String> STATIC_RESOURCE_ROOTS = List.of(
             "./src/main/resources",
             "./src/main/resources/static");
+
+    public static final long IDLE_MS = 30*60*100;
+    public static final long ABSOLUTE_MS = 180*60*100;
 }

src/main/java/exception/ErrorCode.java

@@ -7,6 +7,8 @@ public enum ErrorCode {
     /* Service Exception */
     MISSING_REGISTER_TOKEN(
             HttpStatus.BAD_REQUEST, "400_MISSING_REGISTER_TOKEN", "회원가입에 필요한 토큰이 누락되었습니다."),
+    LOGIN_FAILED(
+            HttpStatus.BAD_REQUEST, "400_LOGIN_FAILED", "아이디 혹은 비밀번호가 잘못되었습니다."),
 
     /* Internal Error */
     INTERNAL_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "500_INTERNAL", "서버 내부 오류가 발생했습니다."),

src/main/java/http/HttpStatus.java

@@ -8,6 +8,8 @@ public enum HttpStatus {
     ACCEPTED(202),
     NO_CONTENT(204),
 
+    FOUND(302),
+
     BAD_REQUEST(400),
     UNAUTHORIZED(401),
     FORBIDDEN(403),