[김영한 스프링 MVC 2] 로그인 처리1 - 쿠키, 세션

 

로그인 요구사항

 

• 요구사항

• 홈 화면 - 로그인 전

회원 가입
로그인

 

 

• 홈 화면 - 로그인 후

본인 이름 (00님 환영합니다.)
상품 관리
로그 아웃

 

 

• 보안 요구사항

로그인 사용자만 상품에 접근하고, 관리 가능 (미로그인 시 상품 관리에 접근하면 로그인 화면으로 이동)

 

 

• 회원 가입, 상품 관리

 

 

 

• 패키지 구조 설계

hello.login
  - domain
    -  item
    -  member
    -  login
  -  web
    -  item
    -  member
    -  login

 

 

★ 도메인이 가장 중요

도메인 = 화면, UI, 기술 인프라 등을 제외한 시스템이 구현해야 하는 핵심 비즈니스 업무 영역

 

web을 다른 기술로 바꾸어도 도메인은 그대로 유지할 수 있어야 함
=> web은 domain을 의존하지만, domain은 web을 의존하지 않음

=> web 패키지를 모두 삭제해도 domain에는 전혀 영향이 없도록 함 (= domain은 web을 참조하면 안됨)

 

 

 

 

회원가입

 

• Member

@Data
public class Member {
    private Long id; //db 관리용 ID

    @NotEmpty
    private String loginId; //로그인 ID
    
    @NotEmpty
    private String name; //사용자 이름
    
    @NotEmpty
    private String password;
}

 

 

 

• MemberRepository

@Slf4j
@Repository
public class MemberRepository {

    private static Map<Long, Member> store = new HashMap<>();

    private static long sequence = 0L;

    public Member save(Member member){
        member.setId(++sequence);
        log.info("save : member = {}", member);
        store.put(member.getId(), member);

        return member;
    }

    public Member findById(Long id){
        return store.get(id);
    }

    public Optional<Member> findByLoginId(String loginId){
       /* List<Member> all = findAll();
        for (Member m : all){
            if (m.getLoginId().equals(loginId)){
                return Optional.of(m);
            }
        }
        return Optional.empty();*/

        return findAll().stream()
                .filter(m->m.getLoginId().equals(loginId))
                .findFirst();
    }

    public List<Member> findAll(){
        return new ArrayList<>(store.values());
    }

    public void clearStore(){
        store.clear();
    }

}

 

※ 동시성 문제 고려 X

실무에서는 ConcurrentHashMap, AtomicLong 사용 고려

 

 

 

• MemberController

@Controller
@RequiredArgsConstructor
@RequestMapping("/members")
public class MemberController {

    private final MemberRepository memberRepository;

    @GetMapping("/add")
    public String addForm(@ModelAttribute("member") Member member){ //IDE 인식 문제로 member 속성 작성
        return "members/addMemberForm";
    }

    @PostMapping("/save")
    public String save(@Valid @ModelAttribute Member member, BindingResult bindingResult){
        if (bindingResult.hasErrors()){
            return "members/addMemberForm";
        }

        memberRepository.save(member);

        return "redirect:/";
    }

}

 

 

 

• 테스트 데이터 추가 (TestDataInit)

@Component
@RequiredArgsConstructor
public class TestDataInit {

    private final ItemRepository itemRepository;
    private final MemberRepository memberRepository;

    /**
     * 테스트용 데이터 추가
     */
    @PostConstruct
    public void init() {
        itemRepository.save(new Item("itemA", 10000, 10));
        itemRepository.save(new Item("itemB", 20000, 20));

        Member member = new Member();
        member.setLoginId("test");
        member.setPassword("test!");
        member.setName("테스터");

        memberRepository.save(member);

    }

}

 

 

 

 

로그인 기능

 

• LoginService

@Service
@RequiredArgsConstructor
public class LoginService {

    private final MemberRepository memberRepository;

    /**
     * @return null 로그인 실패
     */
    public Member login(String loginId, String password) {
        /*Optional<Member> foundMemberOptional = memberRepository.findByLoginId(loginId);
        Member member = foundMemberOptional.get();
        if (member.getPassword().equals(password)){
            return member;
        } else {
            return null;
        }*/

        return memberRepository.findByLoginId(loginId)
                .filter(m -> m.getPassword().equals(password))
                .orElse(null);   ////
    }
}

 

 

 

• LoginForm

@Data
public class LoginForm {
    @NotEmpty
    private String loginId;

    @NotEmpty
    private String password;
}

 

 

 

• LoginController

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

        if (loginMember == null){ ////
            // 로그인 실패 시 reject()로 글로벌 오류 생성
            bindingResult.reject("loginFail", "아이디 또는 비밀번호가 일치하지 않습니다."); ////
            return  "login/loginForm";
        }

        //성공 로직
        return "redirect:/";
    }

}

 

 

 

 

로그인 처리 1 - 쿠키 사용

 

• 쿠키 이용한 로그인 

 

서버에서 로그인에 성공 -> HTTP 응답에 쿠키를 담아서 브라우저에 전달 -> 브라우저는 해당 쿠키를 계속 요청에 포함해 전달

 

※

영속 쿠키: (만료 날짜를 입력) 해당 날짜까지 유지
세션 쿠키: (만료 날짜를 생략) 브라우저 종료 전까지만 유지

 

 

• LoginController

@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, 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 static void expireCookie(HttpServletResponse response, String cookieName) {
        Cookie cookie = new Cookie(cookieName, null); ////
        cookie.setMaxAge(0); ////
        response.addCookie(cookie);
    }

}

 

 

• HomeController

@Slf4j
@Controller
@RequiredArgsConstructor
public class HomeController {

    private final MemberRepository memberRepository;

//    @GetMapping("/")
    public String home() {
        return "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){ // db에 없을 때 (오래 전 쿠키)
            return "home";
        }

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

 

 

• loginHome.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="utf-8">
  <link th:href="@{/css/bootstrap.min.css}"
        href="../css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container" style="max-width: 600px">
  <div class="py-5 text-center">
    <h2>홈 화면</h2>
  </div>
  <h4 class="mb-3" th:text="|로그인: ${member.name}|">로그인 사용자 이름</h4> <!-- 사용자이름 표시 -->
  <hr class="my-4">
  <div class="row">
    <div class="col">
      <button class="w-100 btn btn-secondary btn-lg" type="button"
              th:onclick="|location.href='@{/items}'|">
        상품 관리
      </button>
    </div>
    <div class="col">
      <form th:action="@{/logout}" method="post">
        <button class="w-100 btn btn-dark btn-lg" type="submit">
          로그아웃
        </button>
      </form>
    </div>
  </div>
  <hr class="my-4">
</div> <!-- /container -->
</body>
</html>

로그인 시 해당 페이지로 이동

 

 

 

• 보안 문제

1. 쿠키 값은 임의로 변경 가능
클라이언트가 쿠키를 강제로 변경하면 다른 사용자가 될 수 있음

ex. 실제 웹브라우저 개발자모드 Application Cookie => Cookie: memberId=1 -> Cookie: memberId=2 

 

2. 쿠키에 보관된 정보는 도난될 수 있음
쿠키 정보는 웹 브라우저에도 보관되고, 네트워크 요청마다 클라이언트에서 서버로 전달됨
∴ 로컬 PC 또는 네트워크 전송 구간에서 도난 가능

 

3. 해커가 쿠키를 한번 훔쳐가면 평생 사용 가능
훔친 쿠키로 악의적인 요청을 계속 시도할 수 있음

 

 

• 대안

1. 쿠키에 중요한 값 노출 X

사용자별로 예측 불가능한 임의의 토큰(랜덤 값) 노출

-> 서버에서 토큰-사용자 id 매핑해서 인식 & 서버에서 토큰 관리

2. 토큰은 해커가 임의의 값을 넣어도 찾을 수 없도록 예상 불가능해야 함 

ex. UUID

 

3. 만료시간, 강제 제거 설정

해커가 토큰을 훔쳐도 시간이 지나면 사용할 수 없도록 서버에서 해당 토큰의 만료시간을 짧게(ex. 30분) 유지

해킹이 의심되는 경우 서버에서 해당 토큰 강제 제거

 

 

 

 

로그인 처리 2 - 세션 사용

 

• 세션 동작 방식

1. 사용자가 loginId, password 전달 -> 서버는 해당 사용자 인증 확인

2. 확인된 사용자일 시 세션 ID 생성 (추정 불가능한 ID ex.UUID)

3. 생성된 세션 ID와 세션에 보관할 값을 서버의 세션 저장소에 보관

4. 서버는 클라이언트에 mySessionId:세션 ID 쿠키 전달 (세션값, 회원 관련 정보는 전달 안 함)

5. 클라이언트는 쿠키 저장소에 mySessionId 쿠키 보관

 

 

로그인 이후

1. 클라이언트는 요청할 때마다 mySessionId 쿠키 전달

2. 서버는 해당 쿠키 정보로 세션 저장소 조회, 보관한 세션 정보 사용

 

 

 

• 세션 직접 만들기

 

• 세션 관리

1. 세션 생성
sessionId 생성 (임의의 추정 불가능한 랜덤 값)
세션 저장소에 sessionId와 보관할 값 저장
sessionId로 응답 쿠키를 생성해서 클라이언트에 전달

 

2. 세션 조회
클라이언트가 요청한 sessionId 쿠키의 값으로, 세션 저장소에 보관한 값 조회

 

3. 세션 만료
클라이언트가 요청한 sessionId 쿠키의 값으로, 세션 저장소에 보관한 sessionId와 값 제거

 

 

• SessionManager

/**
 * 세션 관리
 */
@Component
public class SessionManager {

    public static final String SESSION_COOKIE_NAME = "mySessionId";
    private Map<String, Object> sessionStore = new ConcurrentHashMap<>(); ////HashMap과 달리 동시 요청에 안전

    /**
     * 세션 생성
     */
    public void createSession(Object value, HttpServletResponse response){
        //sessionId 생성, 값을 세션에 저장
        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 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);
    }

    public void expire(HttpServletRequest request){
        Cookie sessionCookie = findCookie(request, SESSION_COOKIE_NAME);

        if (sessionCookie != null){
            sessionStore.remove(sessionCookie.getValue()); //해당 값 가진 세션 행 삭제
        }
    }

}

 

 

• SessionManagerTest

class SessionManagerTest {

    SessionManager sessionManager = new SessionManager();

    @Test
    void sessionTest(){
        // 세션 생성
        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();
    }

}

 

 

 

• 직접 만든 세션 적용

 

• LoginController

@Slf4j
@Controller
@RequiredArgsConstructor
public class LoginController {
    private final LoginService loginService;
    private final SessionManager sessionManager; ////

    @GetMapping("/login")
    public String loginForm(@ModelAttribute("loginForm") LoginForm form) {
        return "login/loginForm";
    }

    //@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("/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";
        }

        // 로그인 성공 처리
        // 세션 생성, 세션 저장소에 세션 id 및 회원 데이터 저장
        sessionManager.createSession(loginMember, response); ////

        return "redirect:/";
    }

    //@PostMapping("/logout")
    public String logout(HttpServletResponse response){
        expireCookie(response, "memberId");

        return "redirect:/";
    }

    private static void expireCookie(HttpServletResponse response, String cookieName) {
        Cookie cookie = new Cookie(cookieName, null);
        cookie.setMaxAge(0);
        response.addCookie(cookie);
    }

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

        return "redirect:/";
    }

}

 

 

• HomeController

@Slf4j
@Controller
@RequiredArgsConstructor
public class HomeController {

    private final MemberRepository memberRepository;
    private final SessionManager sessionManager;

    @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";
    }
    
}

 

 

 

• 서블릿 HTTP 세션 1

서블릿이 제공하는 HttpSession 사용하기

Cookie : JSESSIONID=8297349827392378

 

 

• SessionConst

public interface SessionConst {

    String LOGIN_MEMBER = "loginMember";
    
}

 

HttpSession에 데이터 보관/조회할 때 같은 이름 중복 사용 => 상수 정의

 

 

• LoginController

    @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(); //// == request.getSession(true)

        // 세션에 로그인한 회원 정보 보관
        session.setAttribute(SessionConst.LOGIN_MEMBER, loginMember); ////

        return "redirect:/";
    }

    @PostMapping("/logout")
    public String logoutV3(HttpServletRequest request){
        HttpSession session = request.getSession(false); // *세션 없으면 null로 반환*

        if (session != null) session.invalidate(); //// 세션 제거

        return "redirect:/";
    }

 

※ 

request.getSession(true) = request.getSession()
세션이 있으면 기존 세션 반환
세션이 없으면 새로운 세션을 생성해서 반환

 

request.getSession(false)
세션이 있으면 기존 세션 반환
세션이 없으면 새로운 세션을 생성하지 않고 null  반환

 

 

• HomeController

    @GetMapping("/")
    public String homeLoginV3(HttpServletRequest request, Model model){
        HttpSession session = request.getSession(false); // 홈 화면 처음 들어온 사용자 고려, 의미없는 세션 생성하지 않음
        
        // 세션 없으면 home
        if (session == null) return "home";

        // 세션에 회원데이터 없으면 home
        Member loginMember = (Member) session.getAttribute(SessionConst.LOGIN_MEMBER);
        if (loginMember == null) return "home";

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

 

 

 

• 서블릿 HTTP 세션 2

@SessionAttribute

 

• HomeController

    @GetMapping("/")
    public String homeLoginV3(@SessionAttribute(name = SessionConst.LOGIN_MEMBER, required = false) Member loginMember, Model model){ ////
        // 세션에 회원데이터 없으면 home
        if (loginMember == null) return "home";

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

 

@SessionAttribute(name = "loginMember", required = false) Member loginMember

=> loginMember라는 이름을 가진 세션을 찾음 (필수값 X)

 

 

• application.properties

server.servlet.session.tracking-modes=cookie

 

=> URL 전달 방식 끄고 항상 쿠키로만 세션 유지

 

※ 로그인 첫 시도 시 URL이 JSESSIONID 포함함

서버 => 웹 브라우저의 쿠키 지원 여부를 최초에 판단하지 못함 -> 쿠키 값 & URL에 jsessionid 함께 전달

cf) 타임리프는 엔진을 통해서 링크를 걸면 jsessionid를 URL에 자동으로 포함해줌

 

※ 스프링 최신 매핑 전략

JSESSIONID URL 매핑 시 404 오류 발생 가능

∴ 쿠키 사용

∴ 만약 URL 매핑을 꼭 사용해야 한다면 application.properties에 옵션 추가

spring.mvc.pathmatch.matching-strategy=ant_path_matcher

 

 

 

• 세션 정보

 

• SessionInfoController

@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 "세션 출력";
    }

}

 

sessionId : 세션 Id (JSESSIONID의 값) ex) 34B14F008AA3527C9F8ED620EFD7A4E1
maxInactiveInterval : 세션의 유효 시간, ex) 1800초 (30분)
creationTime : 세션 생성일시
lastAccessedTime : 세션과 연결된 사용자가 최근에 서버에 접근한 시간 (클라이언트에서 서버로 sessionId (JSESSIONID)를 요청한 경우 => 요청이 발생한 가장 최근 시간)
isNew : 새로 생성된 세션인지 / 이미 과거에 만들어졌고, 클라이언트에서 서버로 sessionId(JSESSIONID)를 요청해서 조회된 세션인지

 

 

 

• 세션 타임아웃

일반적인 세션 삭제 로직 : 사용자가 로그아웃을 직접 호출 →  session.invalidate() 호출 → 세션 삭제

 

 

• 문제 발생

1. 대부분 사용자는 로그아웃하지 않고 웹 브라우저를 종료함

HTTP의 비 연결성(ConnectionLess)으로 서버는 사용자가 웹 브라우저를 종료한 것인지 아닌지 인식 불가

서버는 세션 데이터를 언제 삭제해야 하는지 판단하기 어려움

2. 남아있는 세션을 무한정 보관 시 문제 발생

- 세션과 관련된 쿠키(JSESSIONID)를 탈취당하면, 오랜 후에도 해당 쿠키로 악의적으로 요청 가능
- 세션은 서버 메모리에 생성됨 → 메모리 크기가 무한하지 않으므로 꼭 필요한 경우에만 생성해서 사용해야 함 (실무에서는 member 객체 전체 X 필요한 정보 담은 객체만 O)

 

 

• 세션의 종료 시점

세션 생성 시점으로부터 30분 지정 시 30분마다 계속 로그인해야 하는 번거로움 발생

∴ 세션 생성 시점이 아니라 사용자가 서버에 최근에 요청한 시간을 기준으로 30분 유지해야 함

=> 사용자가 서비스를 사용하고 있으면, 세션의 생존 시간이 30분으로 계속 늘어남

=> HttpSession 사용 방식

 

 

• 세션 타임아웃 설정

1. 스프링 부트로 글로벌 설정
application.properties

server.servlet.session.timeout=60 //60초(기본은 1800(30분))

글로벌 설정은 분 단위로 설정해야 함 ex. 60(1분), 120(2분), ..

 

2. 특정 세션 단위로 시간 설정

session.setMaxInactiveInterval(1800); //1800초

 

 

• 세션 타임아웃 발생

JSESSIONID를 전달하는 HTTP 요청이 있으면, LastAcessedTime은 현재 시간으로 다시 초기화됨

→ 세션 타임아웃으로 설정한 시간동안 세션을 추가 사용할 수 있음

 

session.getLastAccessedTime() //최근 세션 접근 시간

LastAccessedTime 이후로 timeout 시간이 지나면, WAS가 내부에서 해당 세션 제거

 

 

• 정리

세션에는 최소한의 데이터만 보관해야 함

보관한 데이터 용량 * 사용자 수 => 세션의 메모리 사용량이 급격하게 늘어나 장애로 이어질 수 있음

세션의 시간을 너무 길게 가져가면 메모리 사용이 계속 누적 될 수 있음 (기본: 30분)