Spring Login#1 쿠키와 세션

로그인 (LoginForm.html)에서 ID,PW를 받아서 로그인에 성공하면 쿠키를 전송하는 방법으로 구현해보자.

쿠키를 전송하는 과정은 매우 간단하다. 핵심은 쿠키를 이용해서 '어떻게 로그인 상태를 유지할 것인가?' 이다.

과거의 웹 브라우저는 쿠키와 세션을 사용했는데, 어떻게 구현했는지 처음부터 배워보자.

# 로그인 요구사항

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

@ 패키지 구조

도메인은 비즈니스 로직만 존재해야 한다. 웹과 관련된 코드를 사용, 의존하지 않도록 만들자.

📌 Domain = (화면, UI, 기술 인프라가 없는) 핵심 비즈니스 영역
📌 Web = 웹과 관련된 영역

@ 도메인 만들기

한번 더 말하지만, 도메인 객체에는 웹과 관련된 코드(ItemUpdateForm등)가 들어가면 안된다.

📑Member 📑MemberRepository ➡ DB 코드는 간단한 static HashMap<>으로 대체하였다.

 @Data
public class Member {
  private Long id;
 
  @NotEmpty
  private String loginId; //로그인 ID
  @NotEmpty
  private String name; //사용자 이름
  @NotEmpty
  private String password;
}

 @Slf4j
@Repository
public class MemberRepository {
    private static Map<Long, Member> store = new HashMap<>(); //static 사용
    private static long sequence = 0L;//static 사용
 
    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) {
        return findAll().stream()
                .filter(m -> m.getLoginId().equals(loginId))
                .findFirst();
    }
 
    public List<Member> findAll() {
        return new ArrayList<>(store.values());
    }
 
    public void clearStore() {
        store.clear();
    }
}

📑Item 📑ItemRepository ➡ DB 코드는 간단한 static HashMap<>으로 대체하였다.

 @Data
public class Item {
 
  private Long id;
  private String itemName;
  private Integer price;
  private Integer quantity;
 
  public Item() {
  }
}

 @Repository
public class ItemRepository {
 
  private static final Map<Long, Item> store = new HashMap<>(); //static
  private static long sequence = 0L; //static
 
  public Item save(Item item) {
    item.setId(++sequence);
    store.put(item.getId(), item);
    return item;
  }
 
  public Item findById(Long id) {
    return store.get(id);
  }
 
  public List<Item> findAll() {
    return new ArrayList<>(store.values());
  }
 
  public void update(Long itemId, Item updateParam) {
    Item findItem = findById(itemId);
    findItem.setItemName(updateParam.getItemName());
    findItem.setPrice(updateParam.getPrice());
    findItem.setQuantity(updateParam.getQuantity());
  }
 
  public void clearStore() {
    store.clear();
  }
 
}

📑LoginService ➡ 로그인 아이디를 찾아 비밀번호를 비교한다. 아이디가 없다면 null을 반환한다.

 @Service
@RequiredArgsConstructor
public class LoginService {
 
    private final MemberRepository memberRepository;
 
    /**
     * @return null 로그인 실패
     */
    public Member login(String loginId, String password) {
        return memberRepository.findByLoginId(loginId)
                .filter(m -> m.getPassword().equals(password))
                .orElse(null);
    }
}

@ 로그인 페이지, Form 객체, 컨트롤러

🎨loginForm.html ➡ 타임리프 사용. 스타일 관련 코드는 생략

bootstrap.min.css

0.15MB

 <!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="utf-8">
  <!-- 부트스트랩을 다운받아 사용 -->
  <link href="../css/bootstrap.min.css"
        rel="stylesheet" th:href="@{/css/bootstrap.min.css}">
  <style>
    .container {
      max-width: 560px;
    }
 
    .field-error {
      border-color: #dc3545;
      color: #dc3545;
    }
  </style>
</head>

 <body>
<div class="container">
 
  <div class="py-5 text-center">
    <h2>로그인</h2>
  </div>
 
  <form action="item.html" method="post" th:action th:object="${loginForm}">
	<!-- 글로벌 에러 (객체에서 발생한 에러)는 조건으로 확인한다. -->
    <div th:if="${#fields.hasGlobalErrors()}">
      <p class="field-error" th:each="err : ${#fields.globalErrors()}"
         th:text="${err}"> 전체 오류 메시지 </p>
    </div>
 
    <div>
      <label for="loginId">로그인 ID</label>
      <input class="form-control" id="loginId" th:errorclass="field-error" th:field="*{loginId}"
             type="text"> <!-- th:errors는 FieldError가 발생했을 때만 렌더링된다. -->
      <div class="field-error" th:errors="*{loginId}"/>
    </div>
 
    <div>
      <label for="password">비밀번호</label>
      <input class="form-control" id="password" th:errorclass="field-error" th:field="*{password}"
             type="password"> <!-- th:errors는 FieldError가 발생했을 때만 렌더링된다. -->
      <div class="field-error" th:errors="*{password}"/>
    </div>
 
    <hr class="my-4">
 
    <div class="row">
      <div class="col">
        <button class="w-100 btn btn-primary btn-lg" type="submit">로그인</button>
      </div>
 
      <div class="col">
        <button class="w-100 btn btn-secondary btn-lg" onclick="location.href='items.html'"
                th:onclick="|location.href='@{/}'|"
                type="button">취소
        </button>
      </div>
    </div>
 
  </form>
 
</div> <!-- /container -->
</body>
</html>

📑LoginForm, 📑LoginController ➡ LoginForm을 이용한다. 로그인에 성공하면 쿠키를 보내준다.

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

 @Slf4j
@Controller
@RequiredArgsConstructor
public class LoginController {
 
  private final LoginService loginService;
  
  @GetMapping("/login")
  public String loginForm(@ModelAttribute("loginForm") LoginForm form) {
    return "login/loginForm";
  }
  
  @PostMapping("/logout")
  public String logout(HttpServletResponse response) {
    expireCookie(response, "memberId");
    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());
 
    if (loginMember == null) {
      bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다.");
      return "login/loginForm";
    }
 
    //로그인 성공 처리
    //쿠키에 시간 정보를 주지 않으면 세션 쿠키가 됨(브라우저 종료시 모두 종료)
    Cookie idCookie = new Cookie("memberId", String.valueOf(loginMember.getId()));
    response.addCookie(idCookie);
    return "redirect:/";
 
  }
}

# 쿠키를 이용해 로그인 세션 유지하기

위의 코드에서 Login을 성공하면 서버가 브라우저에게 세션쿠키(memberId)를 전송해줬다.

이제 브라우저는 종료하기 전까지 Response에 세션쿠키를 계속해서 전송해준다.

🎨loginhome.html ➡ 로그인에 성공했을 때 보여줄 홈 화면 뷰이다.

bootstrap.min.css

0.15MB

 <!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" onclick="location.href='items.html'" type="submit">
                    로그아웃
                </button>
            </form>
        </div>
    </div>
 
    <hr class="my-4">
 
</div> <!-- /container -->
 
</body>
</html>

이제 모든 건 준비되었다. 브라우저에서 전송하는 쿠키값을 이용해서 로그인 상태를 구현해보자.

@ 로그인 상태유지1 - 단순하고 멍청한 방법

@CookieValue를 이용해서 전송된 쿠키값(memberId)이 있으면 로그인 상태로 판단한다.

 @Slf4j
@Controller
@RequiredArgsConstructor
public class HomeController {
 
  private final MemberRepository memberRepository;
 
  @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"; // 쿠키가 있다면 Login된 홈화면 전송
  }
}

하지만 이렇게 개발했다가는 큰일난다. 브라우저에서 아무리 막아봐야, 쿠키는 직접 생성해서 조작할 수 있다.

다른 사람의 계정을 해킹할 수 있다.
쿠키에 보관된 개인 데이터는 누구나 접근해서 볼 수 있다는 문제가 있다.
➡ 즉 아이디, 이름, 카드정보와 같은 상태 데이터를 그대로 저장해서는 안된다.
쿠키를 암호화 했다고 한들, 쿠키 자체를 몰래 훔쳐서 평생 사용할 수 있다는 문제점이 있다.
➡ 로그인 쿠키의 만료 기한이 필요하다.

@ 로그인 상태유지2 - 서버 세션저장소

사실 첫번째 방법은 너무 멍청한 방법이었다. 위에서 발생할 수 있는 문제점들을 해결하는 코드를 만들어보자.

서버단에서 세션저장소를 만들고 사용자 상태를 관리한다. 쿠키에는 세션인증값(UUID)을 대신 전송한다.
➡ Cookie: mySessionId=zz0101xx-bab9-4b92-9b32-dadb280f4b61
세션 저장소의 키는 만료시간을 짧게(예: 30분) 유지한다. 훔쳐서 나중에 재사용하기 힘들게 만든다.
➡ 해킹이 의심되는 경우 서버에서 강제로 세션을 삭제하는 로직을 만들 수 있다.

이제 상태값을 서버에서 관리하므로, 쿠키에 데이터를 노출시키지 않아도 된다.

세션 생성, 조회, 만료를 담당하는 📑SessionManager 를 만들어보자.

 @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(UUID)를 생성하고, 값을 세션에 저장
    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());
    }
  }
  
  // 서블릿에서 세션 객체(Session)를 제공해주긴 하지만, 이해를 돕기위해 직접 구현해보았다.
  public Cookie findCookie(HttpServletRequest request, String cookieName) {
    if (request.getCookies() == null) { // 쿠키값은 array 또는 null 로 반환된다.
      return null;
    }
    return Arrays.stream(request.getCookies()) // 해당 쿠키이름을 찾아 반환하는 로직
        .filter(cookie -> cookie.getName().equals(cookieName))
        .findAny() // 처음으로 발견된 값 아무거나
        .orElse(null); // 없다면 null 반환
  }
 
}

📑SessionManager 가 잘 작동하는지 확인하기위해 MockResponse 객체를 이용해 테스트 해보자.

 class SessionManagerTest {
 
  SessionManager sessionManager = new SessionManager();
 
  @Test
  @DisplayName("SessionManager 테스트")
  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("/logout")
  public String logoutV2(HttpServletRequest request) {
    sessionManager.expire(request);
    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());
 
    if (loginMember == null) {
      bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다.");
      return "login/loginForm";
    }
 
    //로그인 성공 처리
    //세션 관리자를 통해 세션을 생성하고, 회원 데이터 보관
    sessionManager.createSession(loginMember, response);
 
    return "redirect:/";
  }
}

이제 로그인을 성공했다면, 브라우저에서 세션ID (UUID)를 쿠키로 보내주게 된다.

 @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);
 
    // [세션ID 쿠키]에 해당되는 세션 데이터없음
    if (member == null) { return "home";}
 
    // 세션있음. 로그인상태 유지
    model.addAttribute("member", member);
    return "loginHome";
  }
}

@ 로그인 상태 유지3 - 서블릿 HTTP 세션

매번 SessionManager를 구현하기에는 번거롭다. 그래서 서블릿 스펙에서는 HttpSession 객체를 제공해준다.

스프링은 마법의 도구가 아니다. 결국 스프링 내부에서도 자바 서블릿을 이용하여 웹 서비스를 구현한다.
HttpSession은 HttpServletRequest 에서 받아올 수 있다.
HttpSession은 JSESSIONID 라는 세션ID 쿠키를 생성한다.
➡ Cookie: JSESSIONID=5B78E23B513F50164D6FDD8C97B0AD05

 public class SessionConst {
    public static final String LOGIN_MEMBER = "loginMember";
}

 @PostMapping("/login")
public String login(... HttpServletRequest request){
  // ... 생략 ...
  
  //세션이 있으면 있는 세션 반환, 없으면 신규 세션을 생성
  // request.getSession(false)로 하면 세션이 없다면 null을 반환한다.
  HttpSession session = request.getSession();
  
  //세션에 로그인 회원 정보 보관
  session.setAttribute(SessionConst.LOGIN_MEMBER, loginMember);
}
 
@PostMapping("/logout")
public String logoutV3(HttpServletRequest request) {
  HttpSession session = request.getSession(false);
  if (session != null) {
    session.invalidate(); // 세션 제거
  }
  return "redirect:/";
}

HttpSession 객체를 이용하면 마치 쿠키를 사용하지 않는 것처럼 세션을 추상화하여 사용할 수 있다.

@로그인 상태유지4 - 스프링 서블릿 HTTP 세션

스프링에서는 위와 같은 HttpSession 객체를 @SessionAttribute 어노테이션을 이용해 쉽게 사용할 수 있다.

브라우저에서 전송하는 JSESSIONID를 @SessionAttribute(~) 하나로 받아올 수 있다.

 @Slf4j
@Controller
@RequiredArgsConstructor
public class HomeController {
 
  private final MemberRepository memberRepository;
  private final SessionManager sessionManager;
 
  @GetMapping("/")
  public String homeLoginV3Spring(
      @SessionAttribute(name = SessionConst.LOGIN_MEMBER, required = false) Member loginMember,
      Model model) {
 
    //세션에 회원 데이터가 없으면 home
    if (loginMember == null) { return "home";}
 
    //세션이 유지되면 로그인으로 이동
    model.addAttribute("member", loginMember);
    return "loginHome";
  }
}

@ 참고 - HTTP TrackingModes

과거에 브라우저가 쿠키를 지원하지 않는 경우, URL에 쿠키를 적는 경우가 있었다.

주소 URL에 쿠키값을 포함했던 과거가 있었다. (브라우저에서 쿠키를 지원하지 않는 경우)

그래서 서버에서는 TrackingModes라고 해서 쿠키와 URL 둘 다 보내주는 기능이 있었다. 요즘은 거의 사용하지 않는 기능이므로 필요하지 않다면 스프링 application.properties에서 쿠키만 사용하도록 변경할 수 있다.

 # application.properties
server.servlet.session.tracking-modes=cookie

# HttpSession 정보와 타임아웃 (만료) 설정

예제에서는 세션을 단순 로그인만 가능하도록 만들었는데, HttpSession 객체에는 다양한 기능을 제공해준다.

 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()); // JSESSION ID 값
log.info("getMaxInactiveInterval={}", session.getMaxInactiveInterval());// 유효시간(sec)
log.info("creationTime={}", new Date(session.getCreationTime()));// 세션 생성일시
log.info("lastAccessedTime={}", new Date(session.getLastAccessedTime()));//마지막 사용시간
log.info("isNew={}", session.isNew());//새로 만든 세션인지, 클라에게 받은 세션인지 여부

이렇게 HttpSession이 제공하는 데이터를 이용해서 만료기간을 설정할 수 있다.

➡ 만료시간을 설정하는 건 보안적인 이유도 있지만, 서버의 메모리 용량을 계속 차지하기 때문에 필수적이다.

 if(HTTP 세션쿠키가 전송되었다면){
  session.setMaxInactiveInterval(1800); // 1800초로 만료기한 갱신
}

이렇게 HttpSession에 만료기간을 지정하면 WAS가 내부에서 해당 세션을 제거한다.

참고로 기본 세션 만료기간을 스프링 application.properties 옵션으로 설정할 수 있다.

 # application.properties
server.servlet.session.timeout=60 # 60초를 기본값으로 지정

블로그의 정보

JiwonDev

내 블로그 - 관리자 홈 전환	`Q` `Q`
새 글 쓰기	`W` `W`

글 수정 (권한 있는 경우)	`E` `E`
댓글 영역으로 이동	`C` `C`

이 페이지의 URL 복사	`S` `S`
맨 위로 이동	`T` `T`
티스토리 홈 이동	`H` `H`
단축키 안내	`Shift` + `/` `⇧` + `/`

티스토리툴바

개인정보

단축키

내 블로그

블로그 게시글

모든 영역

	@Data
	public class Member {
	private Long id;

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

	@Slf4j
	@Repository
	public class MemberRepository {
	private static Map<Long, Member> store = new HashMap<>(); //static 사용
	private static long sequence = 0L;//static 사용

	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) {
	return findAll().stream()
	.filter(m -> m.getLoginId().equals(loginId))
	.findFirst();
	}

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

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

	@Data
	public class Item {

	private Long id;
	private String itemName;
	private Integer price;
	private Integer quantity;

	public Item() {
	}
	}

	@Repository
	public class ItemRepository {

	private static final Map<Long, Item> store = new HashMap<>(); //static
	private static long sequence = 0L; //static

	public Item save(Item item) {
	item.setId(++sequence);
	store.put(item.getId(), item);
	return item;
	}

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

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

	public void update(Long itemId, Item updateParam) {
	Item findItem = findById(itemId);
	findItem.setItemName(updateParam.getItemName());
	findItem.setPrice(updateParam.getPrice());
	findItem.setQuantity(updateParam.getQuantity());
	}

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

	}

	@Service
	@RequiredArgsConstructor
	public class LoginService {

	private final MemberRepository memberRepository;

	/**
	* @return null 로그인 실패
	*/
	public Member login(String loginId, String password) {
	return memberRepository.findByLoginId(loginId)
	.filter(m -> m.getPassword().equals(password))
	.orElse(null);
	}
	}

	<!DOCTYPE HTML>
	<html xmlns:th="http://www.thymeleaf.org">
	<head>
	<meta charset="utf-8">
	<!-- 부트스트랩을 다운받아 사용 -->
	<link href="../css/bootstrap.min.css"
	rel="stylesheet" th:href="@{/css/bootstrap.min.css}">
	<style>
	.container {
	max-width: 560px;
	}

	.field-error {
	border-color: #dc3545;
	color: #dc3545;
	}
	</style>
	</head>

	<body>
	<div class="container">

	<div class="py-5 text-center">
	<h2>로그인</h2>
	</div>

	<form action="item.html" method="post" th:action th:object="${loginForm}">
	<!-- 글로벌 에러 (객체에서 발생한 에러)는 조건으로 확인한다. -->
	<div th:if="${#fields.hasGlobalErrors()}">
	<p class="field-error" th:each="err : ${#fields.globalErrors()}"
	th:text="${err}"> 전체 오류 메시지 </p>
	</div>

	<div>
	<label for="loginId">로그인 ID</label>
	<input class="form-control" id="loginId" th:errorclass="field-error" th:field="*{loginId}"
	type="text"> <!-- th:errors는 FieldError가 발생했을 때만 렌더링된다. -->
	<div class="field-error" th:errors="*{loginId}"/>
	</div>

	<div>
	<label for="password">비밀번호</label>
	<input class="form-control" id="password" th:errorclass="field-error" th:field="*{password}"
	type="password"> <!-- th:errors는 FieldError가 발생했을 때만 렌더링된다. -->
	<div class="field-error" th:errors="*{password}"/>
	</div>

	<hr class="my-4">

	<div class="row">
	<div class="col">
	<button class="w-100 btn btn-primary btn-lg" type="submit">로그인</button>
	</div>

	<div class="col">
	<button class="w-100 btn btn-secondary btn-lg" onclick="location.href='items.html'"
	th:onclick="\|location.href='@{/}'\|"
	type="button">취소
	</button>
	</div>
	</div>

	</form>

	</div> <!-- /container -->
	</body>
	</html>

	@Data
	public class LoginForm {

	@NotEmpty
	private String loginId;

	@NotEmpty
	private String password;
	}

	@Slf4j
	@Controller
	@RequiredArgsConstructor
	public class LoginController {

	private final LoginService loginService;

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

	@PostMapping("/logout")
	public String logout(HttpServletResponse response) {
	expireCookie(response, "memberId");
	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());

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

	//로그인 성공 처리
	//쿠키에 시간 정보를 주지 않으면 세션 쿠키가 됨(브라우저 종료시 모두 종료)
	Cookie idCookie = new Cookie("memberId", String.valueOf(loginMember.getId()));
	response.addCookie(idCookie);
	return "redirect:/";

	}
	}

	<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" onclick="location.href='items.html'" type="submit">
	로그아웃
	</button>
	</form>
	</div>
	</div>

	<hr class="my-4">

	</div> <!-- /container -->

	</body>
	</html>

	@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(UUID)를 생성하고, 값을 세션에 저장
	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());
	}
	}

	// 서블릿에서 세션 객체(Session)를 제공해주긴 하지만, 이해를 돕기위해 직접 구현해보았다.
	public Cookie findCookie(HttpServletRequest request, String cookieName) {
	if (request.getCookies() == null) { // 쿠키값은 array 또는 null 로 반환된다.
	return null;
	}
	return Arrays.stream(request.getCookies()) // 해당 쿠키이름을 찾아 반환하는 로직
	.filter(cookie -> cookie.getName().equals(cookieName))
	.findAny() // 처음으로 발견된 값 아무거나
	.orElse(null); // 없다면 null 반환
	}

	}

	class SessionManagerTest {

	SessionManager sessionManager = new SessionManager();

	@Test
	@DisplayName("SessionManager 테스트")
	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();

	}
	}

	public class SessionConst {
	public static final String LOGIN_MEMBER = "loginMember";
	}

	@PostMapping("/login")
	public String login(... HttpServletRequest request){
	// ... 생략 ...

	//세션이 있으면 있는 세션 반환, 없으면 신규 세션을 생성
	// request.getSession(false)로 하면 세션이 없다면 null을 반환한다.
	HttpSession session = request.getSession();

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

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

	# application.properties
	server.servlet.session.tracking-modes=cookie

	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()); // JSESSION ID 값
	log.info("getMaxInactiveInterval={}", session.getMaxInactiveInterval());// 유효시간(sec)
	log.info("creationTime={}", new Date(session.getCreationTime()));// 세션 생성일시
	log.info("lastAccessedTime={}", new Date(session.getLastAccessedTime()));//마지막 사용시간
	log.info("isNew={}", session.isNew());//새로 만든 세션인지, 클라에게 받은 세션인지 여부

	if(HTTP 세션쿠키가 전송되었다면){
	session.setMaxInactiveInterval(1800); // 1800초로 만료기한 갱신
	}

	# application.properties
	server.servlet.session.timeout=60 # 60초를 기본값으로 지정