[인프런/스프링 MVC 2편] 7. 로그인 처리2

Spring

[인프런/스프링 MVC 2편] 7. 로그인 처리2 - 필터, 인터셉터

주니어주니 2023. 5. 26. 15:24

1. 서블릿 필터

1-1. 소개

서블릿 필터
- 공통 관심사 처리 - 서블릿 필터, 스프링 인터셉터
- HttpServletRequest를 통해 HTTP의 헤더, URL 정보 사용
- 로그인 된 사용자만 특정 페이지에 접근할 수 있도록 로그인 확인 (공통 관심사) 필터 개발!

필터의 흐름

HTTP 요청 -> WAS -> 필터 -> 서블릿 -> 컨트롤러

필터 호출 -> 서블릿 호출

필터 제한

HTTP 요청 -> WAS -> 필터 -> 서블릿 -> 컨트롤러 // 로그인 사용자
HTTP 요청 -> WAS -> 필터(적절하지 않은 요청 -> 서블릿 호출 X // 비 로그인 사용자

필터 인터페이스
- 필터 인터페이스 구현하고 등록 -> 서블릿 컨테이너가 필터를 싱글톤 객체로 생성, 관리
- init() : 필터 초기화 메소드, 서블릿 컨테이너 생성될 때 호출
- doFilter() : 고객의 요청이 올 때마다 해당 메소드 호출. 필터의 로직 구현
- destroy() : 필터 종료 메소드, 서블릿 컨테이너 종료될 때 호출

public interface Filter {

    public default void init(FilterConfig filterConfig) throws ServletException {}
    
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;
    
    public default void destroy() {}
}

1-2. 요청 로그

필터가 정말 수문장 역할을 하는지 확인 -> 모든 요청을 로그로 남기는 필터 개발

1) 로그 필터 생성 - LogFilter

package hello.login.web.filter;

import lombok.extern.slf4j.Slf4j;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.UUID;

@Slf4j
public class LogFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("log filter init");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        log.info("log filter doFilter");

        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String requestURI = httpRequest.getRequestURI();

        String uuid = UUID.randomUUID().toString();

        try {
            log.info("REQUEST [{}][{}]", uuid, requestURI);
            chain.doFilter(request, response);
        } catch (Exception e) {
            throw e;
        } finally {
            log.info("RESPONSE [{}][{}]", uuid, requestURI);
        }
    }

    @Override
    public void destroy() {
        log.info("log filter destroy");
    }
}

public class LogFilter implements Filter { }
- 필터를 사용하려면 필터 인터페이스 구현
doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
- HTTP 요청 -> doFilter 호출
- ServletRequest는 HTTP 요청이 아닌 경우까지 고려해서 만든 인터페이스 (기능이 많이 없음)
  -> HttpServletRequest로 다운캐스팅 해서 사용
String uuid = UUID.randomUUID().toString();
- HTTP 요청을 구분하기 위해 요청마다 임의의 uuid 생성
log.info("REUEST [{}][{}]", uuid, requestURI);
- uuid, requestURI 출력
chain.doFilter(request, response);
- 가장 중요한 부분 ( 이 로직을 호출하지 않으면 다음 단계로 진행 X )
- 다음 필터가 있으면 필터 호출, 필터가 없으면 서블릿 호출

2) 필터 설정(등록) - WebConfig

package hello.login;

import hello.login.web.filter.LogFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.servlet.Filter;

@Configuration
public class WebConfig {

    @Bean
    public FilterRegistrationBean logFilter() {
        FilterRegistrationBean<Filter> filterRegistrationBean = new FilterRegistrationBean<>();
        filterRegistrationBean.setFilter(new LogFilter());      // 우리가 만든 필터
        filterRegistrationBean.setOrder(1);
        filterRegistrationBean.addUrlPatterns("/*");

        return filterRegistrationBean;
    }
}

필터를 등록하는 방법은 여러가지지만, 스프링 부트 사용하면 FilterRegistrationBean 사용
(@ServletComponenetScan, @WebFilter(filterName = "logFilter", urlPatterns = "/*") 로 가능하지만 필터 순서 조절 X)
setFilter(new LogFilter()) : 등록할 필터 지정
setOrder(1) : 필터는 체인으로 동작하므로 필터의 순서 지정 필요. 낮을 수록 먼저 동작
addUrlPatterns("/*") : 필터를 적용할 URL 패턴 지정, /* -> 모든 요청에 대해 해당 필터 적용

3) 실행 로그

filter init 실행
doFilter REQUEST [uuid][requestId]

-> 필터의 역할 확인

1-3. 인증 체크

로그인 하지 않은 사용자는 상품관리 페이지 뿐 아니라 미래에 개발될 페이지에도 접근하지 못하도록 하기

1) 인증 체크 필터 생성 - LoginCheckFilter

package hello.login.web.filter;

import hello.login.web.SessionConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.PatternMatchUtils;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

@Slf4j
public class LoginCheckFilter implements Filter {

    private static final String[] whiteList = {"/", "/member/add", "/login", "/logout", "/css/*"};  // 모두 접근 가능

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String requestURI = httpRequest.getRequestURI();

        HttpServletResponse httpResponse = (HttpServletResponse) response;

        try {
            log.info("인증 체크 필터 시작 {}", requestURI);                  // 잘 작동하는지 확인하기 위함

            if (isLoginCheckPath(requestURI)) {
                log.info("인증 체크 로직 실행 {}", requestURI);             // 요청 URI가 인증 체크 로직에 포함되는지

                HttpSession session = httpRequest.getSession(false);
                if (session == null || session.getAttribute(SessionConst.LOGIN_MEMBER) == null) {
                    log.info("미인증 사용자 요청 {}", requestURI);

                    // 로그인으로 redirect (로그인 후 요청했던 페이지로 다시 돌아가기)
                    httpResponse.sendRedirect("/login?redirectURL=" + requestURI);
                    return;
                }
            }
            chain.doFilter(request, response);  // 체크해야 되는 경로가 아니면(whiteList) 다음 단계
        } catch (Exception e) {
            throw e;   			 	// 예외 로깅 가능하지만, 톰캣(WAS)까지 예외를 보내줘야 함
        } finally {
            log.info("인증 체크 필터 종료 {}", requestURI);
        }

    }

    /**
     * 화이트 리스트(whiteList)의 경우 인증 체크 X
     */
    private boolean isLoginCheckPath(String requestURI) {
        return !PatternMatchUtils.simpleMatch(whiteList, requestURI);   // 화이트 리스트를 제외한 모든 경우에 인증 체크 로직 적용
    }
}

init(), destroy() : default -> 구현 안해도 됨
whitelist = {"/", "/members/add", "/login", "/logout","/css/*"};
- 인증 필터를 적용해도 홈, 회원가입, 로그인, css 같은 리소스에는 접근 가능 해야 함
- 화이트 리스트 경로 : 인증과 무관하게 항상 허용
- 화이트 리스트를 제외한 나머지 모든 경로에는 인증 체크 로직 적용
isLoginCheckPath(requestURI)
- 화이트 리스트를 제외한 모든 경우에 인증 체크 로직 적용
httpResponse.sendRedirect("/login?redirectURL=" + requestURI);
- 미인증 사용자는 로그인 화면으로 리다이렉트
- 현재 요청한 경로인 requestURI를 /login에 쿼리 파라미터로 함께 전달
  -> 로그인 성공 시 해당 경로로 이동
return;
- 미인증 사용자 -> 로그인 화면으로 리다이렉트 응답 -> 필터 진행 중지 (서블릿, 컨트롤러도 호출 X)
chain.doFilter(request, response)
- 이게 있어야 다음단계로 가능 !
- 이 때 request, response 말고 다른 객체를 넘겨줄 수도 있음
  -> 이런 경우 빼고는 서블릿 필터 말고 스프링 인터셉터 사용 권장

2) 필터 추가 (등록) - WebConfig

@Bean
public FilterRegistrationBean loginCheckFilter() {
    FilterRegistrationBean<Filter> filterRegistrationBean = new FilterRegistrationBean<>();
    filterRegistrationBean.setFilter(new LoginCheckFilter());      // 우리가 만든 필터
    filterRegistrationBean.setOrder(2);
    filterRegistrationBean.addUrlPatterns("/*");

    return filterRegistrationBean;
}

setFilter(new LoginCheckFilter()) : 로그인 필터 등록
setOrder(2) : 순서를 2번째로 설정 (로그 필터 -> 로그인 필터)
addUrlPatterns("/*") : 모든 요청에 로그인 필터 적용
addUrlPattens("i/tems/*") 이런식으로 접근 가능한 페이지를 모두 추가해도 되지만,
미래에 새로운 기능이 만들어지면 그것도 다 추가해야 함
-> 반대로 안되는 것들만 whitelist로 뺌

3) RedirectURL 처리 - LoginController

로그인 성공시 처음 요청한 URL로 이동

@PostMapping("/login")
public String loginV4(@Validated @ModelAttribute LoginForm loginForm, BindingResult bindingResult,
                      @RequestParam(defaultValue = "/") String redirectURL,
                      HttpServletRequest request) {
    if (bindingResult.hasErrors()) {
        return "login/loginForm";
    }

    Member loginMember = loginService.login(loginForm.getLoginId(), loginForm.getPassword());

    if (loginMember == null) {
        bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다.");
        return "login/loginForm";
    }

    // 로그인 성공 처리

    // 세션이 있으면 있는 세션 반환, 없으면 신규 세션 생성
    HttpSession session = request.getSession();
    // 세션에 로그인 회원 정보 보관
    session.setAttribute(SessionConst.LOGIN_MEMBER, loginMember);

    return "redirect:" + redirectURL;
}

@RequestParam(defaultValue = "/") String redirectURL
- 로그인 하지 않은 상태로 items 페이지 접근 시 경로
  : /login?redirectURL=/items
- redirectURL 변수에 요청파라미터의 "/items" 가 담김
  -> 로그인 성공시 해당 경로로 redirect
- 요청파라미터가 없으면 "/"

4) 실행

localhost:8080/items

로그인 하지 않은 상태로 items (상품목록) 페이지 접근 시

로그인으로 redirect -> 로그인 성공 시 items(상품 목록) 페이지

5) 정리

서블릿 필터 -> 로그인 하지 않은 사용자는 나머지 경로에 접근 X

2. 스프링 인터셉터

서블릿 필터 : 서블릿이 제공

스프링 인터셉터 : 스프링 MVC가 제공 -> 스프링 MVC 구조에 특화된 필터 기능 제공

2-1. 소개

스프링 인터셉터의 흐름
- 디스패처 서블릿과 컨트롤러 사이에서 컨트롤러 호출 직전에 호출
- 스프링 MVC가 제공하는 기능이기 때문에 디스패처 서블릿 이후에 등장

HTTP 요청 -> WAS -> 필터 -> 서블릿(디스패처 서블릿) -> 스프링 인터셉터 -> 컨트롤러

스프링 인터셉터 제한

HTTP 요청 -> WAS -> 필터 -> 서블릿 -> 스프링 인터셉터 -> 컨트롤러 // 로그인 사용자
HTTP 요청 -> WAS -> 필터 -> 서블릿 -> 스프링 인터셉터(적절하지 않은 요청 -> 컨트롤러 호출 X // 비 로그인 사용자

스프링 인터셉터 인터페이스 (HandlerInterceptor)
- 서블릿 필터 -> doFilter() 하나만 제공
  인터셉터 -> preHandle(컨트롤러 호출 전), postHandle(호출 후), afterCompletion(요청 완료 이후)
- 서블릿 필터 -> request, response만 제공
  인터셉터 -> 어떤 컨트롤러(handler)가 호출되는지 호출 정보, 어떤 modelAndView가 반환되는지 응답 정보도 제공

public interface HandlerInterceptor {

    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {}
    
    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {}
   
    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {}
    
}

스프링 인터셉터 호출 흐름
- preHandle : 컨트롤러 호출 전에 호출 (핸들러 어댑터 호출 전)
  - preHandle의 응답값이 true -> 다음으로 진행
    preHandle의 응답값이 false -> 나머지 인터셉터, 핸들러 어댑터도 호출 X
- postHandle : 컨트롤러 호출 후에 호출 (핸들러 어댑터 호출 후)
- afterCompletion : 뷰가 렌더링 된 이후 호출

스프링 인터셉터 예외 상황 (postHandle, afterCompletion의 차이)
- preHandle : 컨트롤러 호출 전에 호출
- postHandle : 컨트롤러에서 예외 발생 시 postHandle 호출 X
- afterCompletion : 예외 발생하든말든 항상 호출 (예외를 파라미터로 받아서 어떤 예외가 발생했는지 로그로 출력 가능)
  -> 예외와 무관하게 공통 처리를 하려면 afterCompletion() 사용

2-2. 요청 로그

1) 요청 로그 인터셉터 생성 - LogInterceptor

package hello.login.web.interceptor;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.UUID;

@Slf4j
public class LogInterceptor implements HandlerInterceptor {

    public static final String LOG_ID = "logId";

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        String requestURI = request.getRequestURI();
        String uuid = UUID.randomUUID().toString();

        request.setAttribute(LOG_ID, uuid);                 // afterCompletion 메소드에서 uuid를 사용하기 위함

        // @RequestMapping 사용하는 경우 : HandlerMethod 사용
        // 정적 리소스 사용하는 경우 : ResourceHttpRequestHandler 사용
        if (handler instanceof HandlerMethod) {
            HandlerMethod hm = (HandlerMethod) handler;     // 호출할 컨트롤러 메소드의 모든 정보가 포함되어 있음
        }

        log.info("REQUEST [{}][{}][{}]", uuid, requestURI, handler);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.info("postHandle [{}]", modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        String requestURI = request.getRequestURI();
        String logId = (String) request.getAttribute(LOG_ID);
        log.info("RESPONSE [{}][{}][{}]", logId, requestURI, handler);

        if (ex != null) {
            log.error("afterCompletion error!!", ex);
        }

    }
}

String uuid = UUID.randomUUID().toString()
- 요청 로그를 구분하기 위한 uuid 생성
request.setAttribute(LOG_ID, uuid)
- uuid를 해당 메소드 뿐 아니라 afterCompletion 메소드에서도 사용
  -> 서블릿 필터에서는 지역변수로 해결 가능했지만,
  스프링 인터셉터는 호출 시점이 완전히 분리
  -> LogInterceptor 가 싱글톤처럼 사용 -> 지역변수는 위험함 (겹칠 수 있음)
  -> request에 uuid 값을 담음
return true
- true -> 정상 호출 -> 다음 인터셉터나 컨트롤러 호출

if (handler instanceof HandlerMethod) {
	HandlerMethod hm = (HandlerMethod) handler; // 호출할 컨트롤러 메서드의 모든 정보가 포함되어 있다.
}

HandlerMethod
- @Controller, @RequestMapping을 활용한 핸들러 매핑 사용할 경우 -> HandlerMethod가 핸들러 정보로 넘어옴
ResourceHttpRequestHandler
- /resources/static 등의 정적 리소스 호출 -> ResourceHttpRequestHandler가 핸들러 정보로 넘어옴

postHandle, afterCompletion
- 종료 로그를 postHandle이 아니라 afterCompletion에서 실행한 이유
  : 예외가 발생한 경우 postHandle이 호출되지 X
  afterCompletion은 예외가 발생해도 호출

2) 인터셉터 등록 - WebConfig

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LogInterceptor())
                .order(1)
                .addPathPatterns("/**")
                .excludePathPatterns("/css/**", "/*.ico", "/error");
    }

인터셉터 등록 : WebMvcConfigurer가 제공하는 addInterceptors()를 사용해서 인터셉터 등록
registry.addInterceptor(new LogInterceptor()) : 인터셉터 등록
order(1) : 인터셉터의 호출 순서 지정 (필터 -> 인터셉터1 -> 인터셉터2 )
addPathPatterns("/**") : 인터셉터를 적용할 URL 패턴 지정
excludePathPatterns("/css/**", "/*.ico", "/error") : 인터셉터에서 제외할 패턴 지정

-> 필터와 달리 매우 정밀하게 URL 패턴 지정 가능
-> 공식 문서
https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/util/pattern/PathPattern.html

3) 실행 로그

홈(" / ") 요청

LogFilter -> LoginCheckFilter -> LogInterceptor -> LoginCheckFilter -> LogFilter
LogInterceptor
- REQUEST [uuid] [requestURI] [handler]
  REQUEST [2a492257-e0b8-4ef9-b3c5-0c9254576e90] [/] [hello.login.web.HomeController#homeLoginV3Spring(Member, Model)]
- postHandle [modelAndView]
  postHandle [ModelAndView [view="home"; model={}]]
- RESPONSE [logId] [requestURI] [handler]
  RESPONSE [2a492257-e0b8-4ef9-b3c5-0c9254576e90] [/] [hello.login.web.HomeController#homeLoginV3Spring(Member, Model)]

2-3. 인증 체크

1) 로그인체크 인터셉터 생성 - LoginCheckInterceptor

인증 -> 컨트롤러 호출 전에만 호출 되면 됨 -> preHandle만 구현 (모두 default - 하고싶은 것만 구현 가능)

package hello.login.web.interceptor;

import hello.login.web.SessionConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@Slf4j
public class LoginCheckInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        String requestURI = request.getRequestURI();
        log.info("인증 체크 인터셉터 실행 {}", requestURI);

        // 로그인한 사용자인지 확인
        HttpSession session = request.getSession();

        if (session == null || session.getAttribute(SessionConst.LOGIN_MEMBER) == null) {
            log.info("미인증 사용자 요청");
            // 로그인으로 redirect
            response.sendRedirect("/login?redirectURL=" + requestURI);
            return false;   // 여기서 끝냄 !
        }

        return true;
    }

}

2) 인터셉터 등록 - WebConfig

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LogInterceptor())
                .order(1)
                .addPathPatterns("/**")
                .excludePathPatterns("/css/**", "/*.ico", "/error");

        registry.addInterceptor(new LoginCheckInterceptor())
                .order(2)
                .addPathPatterns("/**")
                .excludePathPatterns("/", "/members/add", "/login", "/logout", "/css/**", "/*.ico", "/error");
    }

3) 실행 로그

/items 요청 시

로그인 전

로그인 후

==> 서블릿 필터 <<<< 스프링 인터셉터

3. ArgumentResolver 활용

MVC1편 6. 스프링 MVC - 기본기능 -> 요청 매핑 핸들러 어댑터 구조의 ArgumentResolver 활용

-> argument (매개변수)에 대해 내가 직접 뭔가를 할거야

1) 홈 컨트롤러 - HomeController

@Login
- @Login 어노테이션이 있으면 직접 만든 ArgumentResolver가 동작해서
  세션에 있는 로그인 회원을 찾아주고, 세션에 없으면 null 반환하도록 개발

@GetMapping("/")
public String homeLoginV3ArgumentResolver(@Login Member loginMember, Model model) {

    // 세션에 회원 데이터가 없으면 home
    if (loginMember == null) {
        return "home";
    }

    // 세션이 유지되면 로그인으로 이동
    model.addAttribute("member", loginMember);
    return "loginHome";
}

2) @Login 어노테이션 생성

@Target(ElementType.PARAMETER) : 파라미터에만 사용
@Retention(RetentionPolicy.RUNTIME) : 실행되는 동안 어노테이션 정보가 남아있음

package hello.login.web.argumentresolver;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface Login {
}

3) HandlerMethodArgumentResolver 구현 - LoginMemberArgumentResolver 생성

package hello.login.web.argumentresolver;

import hello.login.domain.member.Member;
import hello.login.web.SessionConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

@Slf4j
public class LoginMemberArgumentResolver implements HandlerMethodArgumentResolver {

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        log.info("supportsParameter 실행");

        // @Login 붙어있는지
        boolean hasLoginAnnotation = parameter.hasParameterAnnotation(Login.class);
        // @Login 붙어있는게 Member 타입인지
        boolean hasMemberType = Member.class.isAssignableFrom(parameter.getParameterType());

        // 둘다 만족해야 다음 메소드 실행
        return hasLoginAnnotation && hasMemberType;
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

        log.info("resolveArgument 실행");

        // argument가 실행될 때 파라미터에 어떤 값이 들어가게 할 것인지
        HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
        HttpSession session = request.getSession(false);
        if (session == null) {
            return null;
        }

        return session.getAttribute(SessionConst.LOGIN_MEMBER);
    }
}

supportsParameter() : @Login 어노테이션 있음 + Memeber 타입 => 해당 ArgumentResolver 사용
resolveArgument() : 컨트롤러 호출 직전에 호출되어서 필요한 파라미터 정보 생성
- 세션에 있는 로그인 회원 정보인 member 객체 찾아서 반환

4) WebConfig에 설정 추가

개발한 LoginMemberArgumentResolver 등록

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(new LoginMemberArgumentResolver());
    }

==> 공통 작업 (로그인 체크 등)이 필요할 때 컨트롤러를 편리하게 사용

저작자표시 비영리 변경금지 (새창열림)