[Spring MVC 2편] 로그인 처리1

개요

주제 : 스프링 MVC의 기본 기능을 공부하면서 부족했던 기능 학습한다.
내용 : 스프링 MVC2를 통해서 검증과 예외 처리에 대해 학습한다.

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

1) 로그인 요구사항

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

프로젝트 : login
패키지 구조

• hello.login
  • domain
    • item
    • member
    • login
  • web
    • item
    • member
    • login

홈 화면 개발
홈 화면을 개발하자.
HomeController - home() 수정

@GetMapping("/")
public String home() {
    return "home";
}

홈 화면 뷰 템플릿
templates/home.html 추가

회원 가입
Member

@Data
public class Member {

    private Long 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<>(); //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();
    }
}

MemberController

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

회원 가입 뷰 템플릿
templates/members/addMemberForm.html

회원용 테스트 데이터 추가
편의상 테스트용 회원 데이터를 추가.

로그인 기능
로그인 기능을 개발해보자.

LoginService

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

• 로그인의 핵심 비즈니스 로직은 회원을 조회한 다음에 파라미터로 넘어온 password와 비교해서 같으면 회원을 반환하고, 만약 password가 다르면 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());
        log.info("login? {}", loginMember);
        if (loginMember == null) {
            bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다.");
            return "login/loginForm";
        }
        //로그인 성공 처리 TODO
        return "redirect:/";
    }
}

• 로그인 컨트롤러는 로그인 서비스를 호출해서 로그인에 성공하면 홈 화면으로 이동하고, 로그인에 실패하면 bindingResult.reject() 를 사용해서 글로벌 오류( ObjectError )를 생성한다. 그리고 정보를 다시 입력하도록 로그인 폼을 뷰 템플릿으로 사용한다.

로그인 폼 뷰 템플릿
templates/login/loginForm.html

• 로그인 폼 뷰 템플릿에는 특별한 코드는 없다. loginId, password가 틀리면 글로벌 오류가 나타난다.

실행해보면 로그인이 성공하면 홈으로 이동하고, 로그인에 실패하면 "아이디 또는 비밀번호가 맞지 않습니다."라는 경고와 함께 로그인 폼이 나타난다.

그런데 아직 로그인이 되면 홈 화면에 고객 이름이 보여야 한다는 요구사항을 만족하지 못한다. 로그인의 상태를 유지하면서, 로그인에 성공한 사용자는 홈 화면에 접근시 고객의 이름을 보여주려면 어떻게 해야할까?

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

쿠키를 사용해서 로그인, 로그아웃 기능을 구현해보자

로그인 상태 유지하기
로그인의 상태를 어떻게 유지할 수 있을까?
쿼리 파라미터를 계속 유지하면서 보내는 것은 매우 어렵고 번거로운 작업이다. 따라서, 쿠기를 사용해보자.

쿠키
서버에서 로그인에 성공하면 HTTP 응답에 쿠키를 담아서 브라우저에 전달하자. 그러면 브라우저는 앞으로 해당 쿠키를 지속해서 보내준다.

쿠키에는 영속 쿠키와 세션 쿠키가 있다

• 영속 쿠키 : 만료 날짜를 입력하면 해당 날짜까지 유지
• 세션 쿠키 : 만료 날짜를 생략하면 브라우저 종료시까지만 유지
  브라우저 종료시 로그아웃이 되길 기대하므로 우리에게 필요한 것은 세션 쿠키이다.

LoginController - login()
로그인 성공시 세션 쿠키를 생성하자.

    @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);
        //로그인 성공 처리 TODO
        return "redirect:/";
    }

쿠키 생성 로직

Cookie idCookie = new Cookie("memberId",String.valueOf(loginMember.getId()));
response.addCookie(idCookie);

• 로그인에 성공하면 쿠키를 생성하고 HttpServletResponse에 담는다. 쿠키 이름은 memberId이고 값은 회원의 id를 담아둔다. 웹 브라우저는 종료 전까지 회원의 id를 서버에 계속 보내준다.

이제 요구사항에 맞추어 로그인에 성공하면 로그인 한 사용자 전용 홈 화면을 보여주면 된다.

홈 - 로그인 처리
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) {
            return "home";
        }
        model.addAttribute("member", loginMember);
        return "loginHome";
    }
}

• 기존 home()에 있는 `GetMappgng("/")은 주석 처리하자.
• @CookieValue를 사용하면 편리하게 쿠키를 조회할 수 있다.
• 로그인 하지 않은 사용자도 홈에 접근할 수 있기 때문에 required=false를 사용한다.

로직 분석

• 로그인 쿠키(memberId)가 없는 사용자는 기존 home으로 보낸다. 추가로 로그인 쿠키가 있어도 회원이 없으면 home으로 보낸다.
• 로그인 쿠키( memberId )가 있는 사용자는 로그인 사용자 전용 홈 화면인 loginHome 으로 보낸다. 추가로 홈 화면에 화원 관련 정보도 출력해야 해서 member 데이터도 모델에 담아서 전달한다.

홈 - 로그인 사용자 전용
templates/loginHome.html

• th:text="|로그인: ${member.name}|" : 로그인에 성공한 사용자 이름을 출력한다.
• 상품 관리, 로그아웃 버튼을 노출한다.

실행
로그인에 성공하면 사용자 이름이 출력되면서 상품 관리, 로그아웃 버튼을 확인할 수 있다. 로그인에 성공시 세션 쿠키가 지속해서 유지되고, 웹 브라우저에서 서버 요청시 memberId 쿠키를 계속 보내준다.

로그아웃 기능
이번에는 로그아웃 기능을 만든다. 로그아웃 방법은 다음과 같다.

• 세션 쿠키이므로 웹 브라우저 종료시
• 서버에서 해당 쿠키의 종료 날짜를 0으로 지정

LoginController - logout 기능 추가

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

• 로그아웃도 응답 쿠키를 생성하는데 Max-Age=0 를 확인할 수 있다. 해당 쿠키는 즉시 종료된다.

3) 쿠키와 보안 문제(세션)

쿠키를 사용해서 로그인Id를 전달해 로그인을 유지할 수 있었다. 그런데 여기에는 심각한 보안 문제가 있다. 이 문제를 해결하려면 결국 중요한 정보를 모두 서버에 저장해야 한다.
그리고 클라이언트와 서버는 추정 불가능한 임의의 식별자 값으로 연결해야 한다.
이렇게 서버에 중요한 정보를 보관하고 연결을 유지하는 방법을 세션이라 한다.

• 사용자가 loginId, password 정보를 전달하면 서버에서 해당 사용자가 맞는지 확인한다.

• 세션 ID를 생성하는데, 추정 불가능해야 한다.
• UUID는 추정이 불가능하다.
  • Cookie: mySessionId=zz0101xx-bab9-4b92-9b32-dadb280f4b61
• 생성된 세션 ID와 세션에 보관할 값(memberA)을 서버의 세션 저장소에 보관한다.

세션 id를 응답 쿠키로 전달

클라이언트와 서버는 결국 쿠키로 연결이 되어야 한다.

• 서버는 클라이언트에 mySessionId라는 이름으로 세션ID만 쿠키에 담아서 전달한다.
• 클라이언트는 쿠키 저장소에 mySessionId쿠키를 보관한다.
  중요
• 여기서 중요한 포인트는 회원과 관련된 정보는 전혀 클라이언트에 전달하지 않는다는 것이다.
• 오직 추정 불가능한 세션 ID만 쿠키를 통해 클라이언트에 전달한다.

클라이언트의 세션 id 쿠키 전달

• 클라이언트는 요청시 항상 mySessionId 쿠키를 전달한다.
• 서버에서는 클라이언트가 전달할 mySessionId 쿠키 정보로 세션 저장소를 조회해서 로그인시 보관한 세션 정보를 사용한다.

정리
세션을 사용해서 서버에서 중요한 정보를 관리하게 되었다. 덕분에 다음과 같은 보안 문제들을 해결할 수 있다.

• 쿠키 값을 변조 가능, 예상 불가능한 복잡한 세션Id를 사용한다.
• 쿠키에 보관하는 정보는 클라이언트 해킹시 털릴 가능성이 있다. 세션Id가 털려도 여기에는 중요한 정보가 없다.
• 쿠키 탈취 후 사용 -> 해커가 토큰을 털어가도 시간이 지나면 사용할 수 없도록 서버에서 세션의 만료시간을 짧게(예: 30분) 유지한다. 또는 해킹이 의심되는 경우 서버에서 해당 세션을 강제로 제거하면 된다.

로그인 처리하기 - 세션 직접 만들기
세션을 직접 개발해서 적용해보자.
세션 관리는 크게 다음 3가지 기능을 제공하면 된다.

• 세션 생성
  • sessionId 생성(임의의 추정 불가능한 랜덤 값)
  • 세션 저장소에 sessionId와 보관할 값 저장
  • sessionId로 응답 쿠키를 생성해서 클라이언트에 전달
• 세션 조회
  • 클라이언트가 요청한 sessionId 쿠키의 값으로, 세션 저장소에 보관할 값 조회
• 세션 만료
  • 클라이언트가 요청한 sessionId 쿠키의 값으로, 세션 저장소에 보관한 sessionId와 값 제거

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

• @Component : 스프링 빈으로 자동 등록한다.
• ConcurrentHashMap : HashMap 은 동시 요청에 안전하지 않다. 동시 요청에 안전한ConcurrentHashMap 를 사용했다.

SessionManagerTest - 테스트

public 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();
    }
}

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

지금까지 개발한 세션 관리 기능을 웹 애플리케이션에 적용해보자

LoginController - loginV2()

    @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";
        }
        /**
        //쿠키에 시간 정보를 주지 않으면 세션 쿠키(브라우저 종료시 모두 종료)
        Cookie idCookie = new Cookie("memberId", String.valueOf(loginMember.getId()));
        response.addCookie(idCookie);
        //로그인 성공 처리 TODO
         **/
        //세션 관리자를 통해 세션을 생성하고, 회원 데이터 보관
        sessionManager.createSession(loginMember, response);

        return "redirect:/";
    }

• 기존 login() 의 @PostMapping("/login") 주석 처리
• private final SessionManager sessionManager; 주입(이거 꼭 해줘야!)
• sessionManager.createSession(loginMember, response);
  로그인 성공시 세션을 등록한다. 세션에 loginMember 를 저장해두고, 쿠키도 함께 발행한다.

LoginController - logoutV2()

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

• 쿠키를 만료시키는 경우에는 클라이언트에게 쿠키를 전송하여 삭제하도록 요청해야 합니다. 따라서 HttpServletResponse를 사용하여 응답을 조작하여 클라이언트에게 쿠키를 만료시키는 것이 올바른 방법입니다.
• 세션을 만료시키는 경우에는 클라이언트에게 직접적인 요청이 필요하지 않습니다. 대신에 서버 측에서 세션을 관리하고 세션을 만료시키면 됩니다. 이를 위해 HttpServletRequest를 사용하여 클라이언트의 요청에 포함된 세션을 가져와 만료시키는 것이 올바른 방법입니다.
• 이러한 차이는 쿠키와 세션의 작동 방식과 관련이 있습니다. 쿠키는 클라이언트 측에 저장되어 있으므로 쿠키를 수정하려면 클라이언트에게 요청해야 합니다. 반면, 세션은 서버 측에 저장되어 있으므로 서버에서 직접 수정할 수 있습니다.

HomeController - homeLoginV2()

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

• private final SessionManager sessionManager; 주입
• 기존 homeLogin() 의 @GetMapping("/") 주석 처리
  세션 관리자에서 저장된 회원 정보를 조회한다. 만약 회원 정보가 없으면, 쿠키나 세션이 없는 것이므로 로그인 되지 않은 것으로 처리한다.

정리
이번 시간에는 세션과 쿠키의 개념을 명확하게 이해하기 위해서 직접 만들어보았다. 그런데 프로젝트마다 이러한 세션 개념을 직접 개발하는 것은 상당히 불편하다. 그래서 서블릿도 세션 개념을 지원한다. 이제 직접 만드는 세션 말고, 서블릿이 공식 지원하는 세션을 적용해보자.

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

세션이라는 개념은 대부분의 웹 애플리케이션에 필요하다. 어쩌면 웹이 등장하면서부터 나온 문제이다. 서블릿은 세션을 위해 HttpSession이라는 기능을 제공하는데, 지금까지 나온 문제들을 해결해준다.

HttpSession 소개
서블릿이 제공하는 HttpSession도 결국 우리가 직접 만든 SessionManager와 같은 방식으로 동작한다. 서블릿을 통해 HttpSession을 생성하면 다음과 같은 쿠키를 생성한다. 쿠키 이름이 JESSIONID이고 값은 추정 불가능한 랜덤 값이다.

서블릿이 제공하는 HttpSession을 사용하도록 개발해보자.

SessionConst

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

• HttpSession에 데이터를 보관하고 조회할 때, 같은 이름이 중복 되어 사용되므로, 상수를 하나 정의했다.

LoginController - loginV3()

    @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) 를 사용하면 된다.
  • request.getSession(false)는 세션이 없으면 새로운 세션을 생성하지 않는다.
  • request.getSession() : 신규 세션을 생성하는 request.getSession(true) 와 동일하다.

LoginController - logoutV3()

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

• session.invalidate() : 세션을 제거한다.

LoginController - homeLoginV3()

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

• session.getAttribute(SessionConst.LOGIN_MEMBER) : 로그인 시점에 세션에 보관한 회원 객체를 찾는다.

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

@SessionAttribute
스프링은 세션을 더 편리하게 사용할 수 있도록 @SessionAttribute 을 지원한다.

이미 로그인 된 사용자를 찾을 때는 다음과 같이 사용하면 된다. 참고로 이 기능은 세션을 생성하지 않는다.
@SessionAttribute(name = "loginMember", required = false) Member loginMember

HomeController - homeLoginV3Spring()

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

• 세션을 찾고, 세션에 들어있는 데이터를 찾는 번거로운 과정을 스프링이 한번에 편리하게 처리해주는 것을 확인할 수 있다.

7. 세션 정보와 타임아웃 설정

1) 세션 정보 확인

세션이 제공하는 정보들을 확인해보자.
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 "세션 출력";
    }
}

2) 세션 타임 아웃 설정

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

• application.properties에 타임아웃을 설정하여 세션을 안전하고 편리하게 사용 가능하다.