[강의] 스프링 MVC 2편 - 백엔드 웹 개발 핵심 기술 5

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-mvc-2

스프링 MVC 2편 - 백엔드 웹 개발 활용 기술 - 인프런 | 강의

6. 로그인 처리1 - 쿠키, 세션

- 로그인 요구 사항

• 홈 화면 - 로그인 전
  • 회원 가입
  • 로그인
• 홈 화면 - 로그인 후
  • 본인 이름(누구님 환영합니다.)
  • 상품 관리
  • 로그 아웃
• 보안 요구사항
  • 로그인 사용자만 상품에 접근하고, 관리할 수 있음
  • 로그인 하지 않은 사용자가 상품 관리에 접근하면 로그인 화면으로 이동
  • 회원 가입, 상품 관리

- 프로젝트 생성

• 의존관계는 단방향으로 흘러야 한다
  도메인이 가장 중요하므로 웹이 도메인을 참조하도록 해야한다.
  웹을 들어내서 코드를 다 갈아 엎어도 도메인에는 아무 문제가 생기지 않도록

- 회원 가입

• 로그인 폼 html 추가

• 로그인 레포 추가(List를 이용해 임시 레포, 테스트용 데이터 넣는 코드도 함께)
• 로그인 컨트롤러

@Controller
@RequiredArgsConstructor
@RequestMapping("/members")
public class MemberController {
    private final MemberRepository memberRepository;

    @GetMapping("/add")
    public String addForm(@ModelAttribute("member") Member member) {
        return "members/addMemberForm";
    }
    
    @PostMapping("/add")
    public String save(@Valid @ModelAttribute Member member, BindingResult result) {
        if (result.hasErrors()) {
            return "members/addMemberForm";
        }
        memberRepository.save(member);
        return "redirect:/";
    }

- 로그인 기능

• LoginService 도메인에 추가, 비즈니스 로직 , 아이디 비밀번호 맞는지 확인

@Service
@RequiredArgsConstructor
public class LoginService {
    private final MemberRepository memberRepository;

    public Member login(String loginId, String password) {
        return memberRepository.findByLoginId(loginId)
                .filter(m -> m.getPassword().equals(password))
                .orElse(null);
    }
}

• 로그인 폼 html 추가

• 로그인 폼 dto 추가
• 로그인 Controller

@Slf4j
@Controller
@RequiredArgsConstructor
public class LoginController {
    private final LoginService loginService;
    @GetMapping("/login")
    public String loginForm(@ModelAttribute("loginForm") LoginForm form) {
        return "login/loginForm";
    }

    @PostMapping("/login")
    public String login(@Valid @ModelAttribute LoginForm form, BindingResult
            bindingResult) {
        if (bindingResult.hasErrors()) {
            return "login/loginForm";
        }
        Member loginMember = loginService.login(form.getLoginId(),
                form.getPassword());
        log.info("login? {}", loginMember);
        if (loginMember == null) {
            bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다.");
            return "login/loginForm";
        }
        //로그인 성공 처리 TODO
        return "redirect:/";
    }

 

- 로그인 처리하기 - 쿠키 사용

로그인 -> 로그인 성공

           <- 쿠키 만들어서 보내줌

모든 요청에 쿠키 자동 포함

쿠키에는 영속, 세션 쿠키가 있는데 로그인은 브라우저 종료 시까지만 유지되면 되므로 세션 방식을 선택한다.

@PostMapping("/login")
public String login(@Valid @ModelAttribute LoginForm form, BindingResult bindingResult
, HttpServletResponse response) {
    if (bindingResult.hasErrors()) {
        return "login/loginForm";
    }
    Member loginMember = loginService.login(form.getLoginId(),
            form.getPassword());
    log.info("login? {}", loginMember);
    if (loginMember == null) {
        bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다.");
        return "login/loginForm";
    }
    
    //로그인 성공 처리
    Cookie idCookie = new Cookie("memberId",
            String.valueOf(loginMember.getId()));
    response.addCookie(idCookie);

    return "redirect:/";
}


@PostMapping("/logout")
public String logout(HttpServletResponse response) {
    expireCookie(response, "memberId");
    return "redirect:/";
}
private void expireCookie(HttpServletResponse response, String cookieName) {
    Cookie cookie = new Cookie(cookieName, null);
    cookie.setMaxAge(0);
    response.addCookie(cookie);
}

테스트 결과

home에서도 로그인이 유지될 수 있도록 만들기/ 로그아웃 만들기

@GetMapping("/")
public String homeLogin(@CookieValue(name = "memberId", required = false) Long memberId, Model model) {
    if (memberId == null) {
        return "home";
    }

    //로그인
    Member loginMember = memberRepository.findById(memberId);
    if (loginMember == null) {
        return "home";
    }
    model.addAttribute("member", loginMember);
    return "loginHome";
}

로그인 후에는 홈 화면이 이렇게 바뀌며 브라우저를 껐다가 켜면 사라진다.

 

- 쿠키와 보안 문제

쿠키는 사실 클라이언트에서 임의로 보낼 수 있다 -> 다른 사용자들의 개인정보가 다 털린다

해커가 쿠키를 훔쳐서 악용할 수도 있다

-> 대안

쿠키에 시간제한을 준다

예측 불가능한 임의의 토큰을 준다

해킹이 의심되는 경우 쿠키를 직접 제거한다

 

- 로그인 처리하기 - 세션 동작 방식

쿠키의 중요한 정보를 보관하고 연결 유지하는 방법 : 세션

쿠키 값을 변조 - 예상 불가능한 복잡한 세션 id

털려도 복잡하므로 알기 어렵다

 

- 로그인 처리하기 - 세션 직접 만들기

@Component
public class SessionManager {
    public static final String SESSION_COOKIE_NAME = "mySessionId";
    private Map<String, Object> sessionStore = new ConcurrentHashMap<>();
    /**
     * 세션 생성
     */
    public void createSession(Object value, HttpServletResponse response) {
        //세션 id를 생성하고, 값을 세션에 저장
        String sessionId = UUID.randomUUID().toString();
        sessionStore.put(sessionId, value);
        //쿠키 생성
        Cookie mySessionCookie = new Cookie(SESSION_COOKIE_NAME, sessionId);
        response.addCookie(mySessionCookie);
    }
    /**
     * 세션 조회
     */
    public Object getSession(HttpServletRequest request) {
        Cookie sessionCookie = findCookie(request, SESSION_COOKIE_NAME);
        if (sessionCookie == null) {
            return null;
        }
        return sessionStore.get(sessionCookie.getValue());
    }
    /**
     * 세션 만료
     */
    public void expire(HttpServletRequest request) {
        Cookie sessionCookie = findCookie(request, SESSION_COOKIE_NAME);
        if (sessionCookie != null) {
            sessionStore.remove(sessionCookie.getValue());
        }
    }
    
    private Cookie findCookie(HttpServletRequest request, String cookieName) {
        if (request.getCookies() == null) {
            return null;
        }
        return Arrays.stream(request.getCookies())
                .filter(cookie -> cookie.getName().equals(cookieName))
                .findAny()
                .orElse(null);
    }

class SessionManagerTest {
    SessionManager sessionManager = new SessionManager();

    @Test
    void sessionTest() {

        //세션 생성
        //테스트용 가짜 Mock 제공
        MockHttpServletResponse response = new MockHttpServletResponse();
        Member member = new Member();
        sessionManager.createSession(member, response);

        //요청에 응답 쿠키 저장
        MockHttpServletRequest request = new MockHttpServletRequest();
        request.setCookies(response.getCookies());

        //세션 조회
        Object result = sessionManager.getSession(request);
        assertThat(result).isEqualTo(member);
        
        //세션 만료
        sessionManager.expire(request);
        Object expired = sessionManager.getSession(request);
        assertThat(expired).isNull();
    }

Key : UUID

Value : member id로  

UUID를 통해 member id에 접근

 

- 로그인 처리하기 - 직접 만든 세션 적용

@PostMapping("/login")
public String loginV2(@Valid @ModelAttribute LoginForm form, BindingResult bindingResult, HttpServletResponse response) {
    if (bindingResult.hasErrors()) {
        return "login/loginForm";
    }

    Member loginMember = loginService.login(form.getLoginId(),
            form.getPassword());
    log.info("login? {}", loginMember);

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

    //로그인 성공 처리
    sessionManager.createSession(loginMember, response);

    return "redirect:/";
}

@PostMapping("/logout")
public String logoutV2(HttpServletRequest request) {
    sessionManager.expire(request);
    return "redirect:/";
}

@GetMapping("/")
public String homeLoginV2(HttpServletRequest request, Model model) {
    Member member = (Member)sessionManager.getSession(request);

    if (member == null) {
        return "home";
    }

    //로그인
    model.addAttribute("member", member);
    return "loginHome";
}

sessionManager를 사용하는 방식으로 모두 수정한다.

이렇게 일일히 개발해야 되는 세션을 서블릿에서 지원해준다.

쿠키가 저장된 모습

- 로그인 처리하기 - 서블릿 HTTP 세션1

기본으로 내장된 기능 사용

@PostMapping("/login")
public String loginV3(@Valid @ModelAttribute LoginForm form, BindingResult bindingResult, HttpServletRequest request) {
    if (bindingResult.hasErrors()) {
        return "login/loginForm";
    }

    Member loginMember = loginService.login(form.getLoginId(), form.getPassword());
    log.info("login? {}", loginMember);

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

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

    return "redirect:/";
}

request.getSession(), (true)  -> 세션이 있으면 세션 반환, 없으면 생성

                                   (false) -> 있으면 똑같이, 없으면 null

@PostMapping("/logout")
public String logoutV3(HttpServletRequest request) {
    HttpSession session = request.getSession(false);
    if (session != null) {
        session.invalidate();
    }
    return "redirect:/";
}

@GetMapping("/")
public String homeLoginV3(HttpServletRequest request, Model model) {
    HttpSession session = request.getSession(false);
    if(session == null)
        return "home";


    Member loginMember = (Member)session.getAttribute(SessionConst.LOGIN_MEMBER);

    if (loginMember == null) {
        return "home";
    }

    //로그인
    model.addAttribute("member", loginMember);
    return "loginHome";
}

JSESSIONID라는 이름으로 쿠키가 적절하게 생성된다

- 로그인 처리하기 - 서블릿 HTTP 세션2

• @SessionAttribute

@GetMapping("/")
public String homeLoginV3Spring(
        @SessionAttribute(name = SessionConst.LOGIN_MEMBER, required = false) Member loginMember, Model model) {

    if (loginMember == null) {
        return "home";
    }

    //로그인
    model.addAttribute("member", loginMember);
    return "loginHome";
}

@SessionAttribute로 코드를 간단하게 줄일 수 있다.

세션을 찾아온다(생성하지는 않는다.)

 

• TrakingModes

쿠키를 지원하지 않는 경우, URL을 이용해서 유지시킨다. 처음에 판단이 불가능하기 때문

지저분하다.

이를 끄는 방법은

server.servlet.session.tracking-modes=cookie

를 추가해주면 끌 수 있다. 

 

- 세션 정보와 타임아웃 설정

@Slf4j
@RestController
public class SessionInfoController {
    
    @GetMapping("/session-info")
    public String sessionInfo(HttpServletRequest request) {
        HttpSession session = request.getSession(false);
        if (session == null) {
            return "세션이 없습니다.";
        }
        
        //세션 데이터 출력
        session.getAttributeNames().asIterator()
                .forEachRemaining(name -> log.info("session name={}, value={}",
                        name, session.getAttribute(name)));
        log.info("sessionId={}", session.getId());
        log.info("maxInactiveInterval={}", session.getMaxInactiveInterval());
        log.info("creationTime={}", new Date(session.getCreationTime()));
        log.info("lastAccessedTime={}", new
                Date(session.getLastAccessedTime()));
        log.info("isNew={}", session.isNew());
        return "세션 출력";
    }
}

 

세션의 정보들을 본다.

세션은 사용자가 로그아웃을 직접 호출할 때만 삭제된다.

하지만 대부분의 사용자들은 이를 선택하지 않고, HTTP는 비연결성이므로 서버 입장에서는 사용자가 웹 브라우저를 종료한 것인지 아닌지 인식할 수 없다.

서버에서 세션 데이터를 언제 삭제해야될까? - 일단 무한정은 안됨, 보안상/ 메모리상 

메모리에 데이터가 우두두 쌓이면 문제가 발생할 가능성이 매우 높다.

-> 세션에선 최소한의 데이터만 보관해야한다.

-> 사용자가 서버에 최근에 요청한 시간을 기준으로 30분을 유지해주면 어떨까?

• 글로벌설정

server.servlet.session.timeout=60

• 세션 단위로 설정

session.setMaxInactiveInterval(1800);

• 세션 타임아웃 발생

세션 타임아웃 시간은 해당 세션과 관련된 JSESSIONID를 전달하는 HTTP  요청이 있을 때마다 초기화시킨다.

LastAccessedTime(session.getLastAccessedTime()) 이후로 timeout 시간이 지나면 WAS가 내부에서 해당 세션을 제거

 

7. 로그인 처리2 - 필터, 인터셉터

- 서블릿 필터 - 소개

URL로 막 여기저기 들어갈 수 있으면 로그인 되지 않은 사용자가 들어가면 안되는 곳까지 들어가진다 = 문제

이를 

 

필터 : 서블릿이

인터셉터 : 스프링이 제공하는 기능

 

로그인 여부 체크를 매 api 호출 때마다 하도록 코드를 작성하는 것은 별로다.

이런 공통관심사는 스프링 AOP로도 해결할 수 있지만, 웹과 관련한 공통 관심사는 서블릿 필터, 스프링 인터셉터를 사용하는 것이 좋다.(HttpServletRequest를 제공하기 때문)

 

서블릿 필터 : 서블릿이 지원하는 수문장

URL 패턴별로 적용할 수 있음(/* = 모든 요청)

 

필터 흐름

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

 

필터 인터페이스를 구현, 등록하면

서블릿 컨테이너가 싱글톤 객체로 생성하고 관리함.

init(): 필터 초기화 메서드, 서블릿 컨테이너가 생성될 때 호출된다.
doFilter(): 고객의 요청이 올 때 마다 해당 메서드가 호출된다. 필터의 로직을 구현하면 된다.
destroy(): 필터 종료 메서드, 서블릿 컨테이너가 종료될 때 호출된다.

 

- 서블릿 필터 - 요청 로그

@Slf4j
public class LogFilter implements Filter {

    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("log filter init");
    }

    //HTTP 요청이 올 때마다 호출
    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        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");
    }
}

ServletRequest request 는 HTTP 요청이 아닌 경우까지 고려해서 만든 인터페이스이다. HTTP를
사용하면 HttpServletRequest httpRequest = (HttpServletRequest) request; 와 같이 다운 케스팅 하면 된다.

 

String uuid = UUID.randomUUID().toString();
HTTP 요청을 구분하기 위해 요청당 임의의 uuid 를 생성해둔다.

 

chain.doFilter(request, response);
다음 필터가 있으면 필터를 호출하고, 필터가 없으면 서블릿을 호출한다.
만약 이 로직을 호출하지 않으면 다음 단계로 진행되지 않는다.

@Configuration
public class WebConfig {
    @Bean
    public FilterRegistrationBean logFilter() {
        FilterRegistrationBean<Filter> filterRegistrationBean 
                = new FilterRegistrationBean<>();
        filterRegistrationBean.setFilter(new LogFilter());
        //필터는 체인으로 동작한다. 따라서 순서가 필요하다. 낮을 수록 먼저 동작한다.
        filterRegistrationBean.setOrder(1);
        filterRegistrationBean.addUrlPatterns("/*");
        return filterRegistrationBean;
    }
}

 

- 서블릿 필터 - 인증 체크

@Slf4j
public class LoginCheckFilter implements Filter {

    //풀어줄 url 리스트
    private static final String[] whitelist = {"/", "/members/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);
                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);
        } catch (Exception e) {
            throw e; //예외 로깅 가능 하지만, 톰캣까지 예외를 보내주어야 함
        } finally {
            log.info("인증 체크 필터 종료 {}", requestURI);
        }
    }

    /**
     * 화이트 리스트의 경우 인증 체크X
     */
    private boolean isLoginCheckPath(String requestURI) {
        return !PatternMatchUtils.simpleMatch(whitelist, requestURI);
    }
}

webconfig에 등록

@Bean
public FilterRegistrationBean loginCheckFilter() {
    FilterRegistrationBean<Filter> filterRegistrationBean = new FilterRegistrationBean<>();
    filterRegistrationBean.setFilter(new LoginCheckFilter());
    filterRegistrationBean.setOrder(2);
    filterRegistrationBean.addUrlPatterns("/*");
    
    return filterRegistrationBean;
}

-> 아무리 다른 페이지르 들어가려해도 로그인 페이지로 밖에 들어갈 수 없다.

@PostMapping("/login")
public String loginV4(@Valid @ModelAttribute LoginForm form, BindingResult bindingResult,
                      @RequestParam(defaultValue = "/") String redirectURL,
                      HttpServletRequest request) {
    /*생략*/
    return "redirect:" + redirectURL;
}

이렇게 하면 원래 가려던 페이지로 돌아갈 수 있다.

 

- 스프링 인터셉터 - 소개

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

서블릿 필터에 비해 정밀한 설정이 가능하다

preHandle 

컨트롤러 호출 전에 호출된다. (더 정확히는 핸들러 어댑터 호출 전에 호출된다.)

예외 발생 시에도 컨트롤러 호출 전에 호출된다.
preHandle 의 응답값이 true 이면 다음으로 진행하고, false 이면 더는 진행하지 않는다. false
인 경우 나머지 인터셉터는 물론이고, 핸들러 어댑터도 호출되지 않는다. 그림에서 1번에서 끝이
나버린다.

postHandle

컨트롤러 호출 후에 호출된다. (더 정확히는 핸들러 어댑터 호출 후에 호출된다.)

컨트롤러에서 예외가 발생하면 호출되지 않는다.

afterCompletion

뷰가 렌더링 된 이후에 호출된다.

예외가 발생해도 호출된다.

 

- 스프링 인터셉터 - 요청 로그

@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);

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

        log.info("REQUEST [{}][{}][{}]", uuid, requestURI, handler);
        return true; //false 진행X
    }
    @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);
        if (ex != null) {
            log.error("afterCompletion error!!", ex);
        }
    }
}

@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 LogInterceptor()) : 인터셉터를 등록한다.
order(1) : 인터셉터의 호출 순서를 지정한다. 낮을 수록 먼저 호출된다.
addPathPatterns("/**") : 인터셉터를 적용할 URL 패턴을 지정한다.
excludePathPatterns("/css/**", "/*.ico", "/error") : 인터셉터에서 제외할 패턴을 지정한다.

HandlerMethod
핸들러 정보는 어떤 핸들러 매핑을 사용하는가에 따라 달라진다. 스프링을 사용하면 일반적으로
@Controller , @RequestMapping 을 활용한 핸들러 매핑을 사용하는데, 이 경우 핸들러 정보로
HandlerMethod 가 넘어온다.

ResourceHttpRequestHandler
@Controller 가 아니라 /resources/static 와 같은 정적 리소스가 호출 되는 경우
ResourceHttpRequestHandler 가 핸들러 정보로 넘어오기 때문에 타입에 따라서 처리가 필요하다.

 

postHandle, afterCompletion
종료 로그를 postHandle 이 아니라 afterCompletion 에서 실행한 이유는, 예외가 발생한 경우
postHandle 가 호출되지 않기 때문이다. afterCompletion 은 예외가 발생해도 호출 되는 것을 보장한다.

 

PathPattern  공식 문서

PathPattern (Spring Framework 6.0.4 API)

 

- 스프링 인터셉터 - 인증 체크

@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(false);
        
        if (session == null || session.getAttribute(SessionConst.LOGIN_MEMBER) == null) {
            log.info("미인증 사용자 요청");
            //로그인으로 redirect
            response.sendRedirect("/login?redirectURL=" + requestURI);
            return false;
        }
        return true;
    }
}

@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" //하지만 이건 빼
                );
    }

코드가 서블릿에 비해서 매우 간단하다

특별한 이유가 없다면 이것을 사용하자

 

- ArgumentResolver 활용

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

@Target(ElementType.PARAMETER) : 파라미터에만 사용
@Retention(RetentionPolicy.RUNTIME) : 리플렉션 등을 활용할 수 있도록 런타임까지 애노테이션 정보가 남아있음

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

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

 

@Slf4j
public class LoginMemberArgumentResolver implements HandlerMethodArgumentResolver {

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        log.info("supportsParameter 실행");
        boolean hasLoginAnnotation =
                parameter.hasParameterAnnotation(Login.class);
        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 실행");

        HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
        HttpSession session = request.getSession(false);

        if (session == null) {
            return null;
        }

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

결과는 동일하게, 애노테이션으로 간단하게 해결할 수 있음