전체 소스코드 Github

🔎🔎🔎

Spring Security를 이용해서 세션 기반 로그인 및 권한 검증을 구현합니다.
디테일한 설정보다는 전체적인 흐름을 보기 위한 프로젝트입니다.

🔎 Dependencies

Spring Initializr

• Spring web
• Spring security
• Spring Data JPA
• Lombok
• MySQL Driver

🔎 Member Entity 작성

@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
@Table(name = "MEMBER")
@Getter
public class Member {

    @Id @GeneratedValue
    private Long id;

    private String username;

    private String password;

    private boolean enabled;

    @Enumerated(EnumType.STRING)
    private Role role;

    @Builder
    public Member(String username, String password, boolean enabled, Role role) {
        this.username = username;
        this.password = password;
        this.enabled = enabled;
        this.role = role;
    }
}

Role (Enum class)

spring security가 제공하는 ROLE 네이밍 정책이 ROLE_권한 이므로 맞춰서 작성해줍니다.

@Getter
public enum Role {

    ROLE_ADMIN("관리자"), ROLE_MANAGER("매니저"), ROLE_MEMBER("일반사용자");

    private String description;

    Role(String description) {
        this.description = description;
    }
}

Spring security의 User 클래스를 보면 "ROLE_"로 시작하는 권한을 찾는 것을 확인할 수 있습니다.

---

🔎 MemberRepository 작성

username을 이용해 로그인 처리를 할 것이기 때문에 JPA 네이밍 쿼리를 이용해 findByUsername 메서드 하나를 정의합니다.

간단한 실습을 위해 서비스 계층은 두지 않았습니다.

public interface MemberRepository extends CrudRepository<Member, Long> {

    Optional<Member> findByUsername(String username);
}

---

🔎 User 클래스 커스텀

spring security가 제공하는 User 클래스를 우리가 정의한 Member로 사용하기 위해 커스텀합니다.

이후 SecurityUser를 통해 Member에 접근할 것이므로 Member를 필드로 갖게 하고 생성자를 통해 값을 유지시켜 줍니다.

super 키워드를 이용해 부모 클래스(User)의 생성자로 username, password, role 을 넘겨줍니다.

요청되는 데이터를 확인하기 위해 로그도 찍어보았습니다.

@Slf4j
@Getter @Setter
public class SecurityUser extends User {

    private Member member;

    public SecurityUser(Member member) {
        super(member.getUsername(), member.getPassword(), AuthorityUtils.createAuthorityList(member.getRole().toString()));

        log.info("SecurityUser member.username = {}", member.getUsername());
        log.info("SecurityUser member.password = {}", member.getPassword());
        log.info("SecurityUser member.role = {}", member.getRole().toString());

        this.member = member;
    }

}

---

🔎 UserDetailsService 구현체 작성

로그인을 위한 username (혹은 id, email) 이 DB에 있는지 확인하는 메서드 loadUserByUsername 메서드를 작성합니다.

이 메서드에서 사용하기 위해 repository에 findByUsername 메서드를 정의한 것 입니다.

memberRepository를 주입받고 findByUsername 메서드를 이용해 입력된 username이 유효한지 확인합니다.

username이 유효하지 않다면 예외를 발생시키고 유효하다면 username으로 찾아온 Member를 이용해 Custom User인 SecurityUser를 생성하여 반환합니다.

@Slf4j
@Component
@RequiredArgsConstructor
public class UserDetailsServiceImpl implements UserDetailsService {

    private final MemberRepository memberRepository;


    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Optional<Member> findMember = memberRepository.findByUsername(username);
        if (!findMember.isPresent()) throw new UsernameNotFoundException("존재하지 않는 username 입니다.");

        log.info("loadUserByUsername member.username = {}", username);

        return new SecurityUser(findMember.get());
    }
}

---

🔎 SecurityConfig 작성

이제 인증 및 권한 처리를 위한 SecutiryConfig클래스를 작성합니다.

WebSecurityConfigurerAdapter를 상속받고 configure 메서드를 오버라이딩 합니다.

가장 먼저 authorizaRequests 를 이용해 권한 검증을 수행합니다.
antMatchers에는 공통된 권한을 가지는 endpoint를 묶어줍니다. 그리고 다음의 메서드를 이용해서 묶어진 endpoint에 대한 권한 분기를 수행합니다.

• permitAll : 인증 없이 접근 가능
• authentication : 인증된 사용자라면 특별한 권한 없이 접근 가능
• hasAnyRole : 명시한 권한을 가진 인증된 사용자만 접근 가능
  • hasAnyRole("ADMIN", "MANAGER") => Role.ADMIN, Role.MANAGER 접근가능
• hasRole : hasAnyRole과 동일한 기능이지만 하나의 권한과 매핑

다음은 formLogin을 이용해 로그인 관련 기능을 정의합니다.

• loginPage: 인증되지 않은 사용자가 인증을 필요로 하는 endpoint에 접근시 설정한 경로로 이동시켜준다. (보통 로그인 페이지로 이동)
• loginProcessingUrl : 지정한 endpoint로 POST 요청이 올 때 요청된 정보를 기반으로 로그인 처리를 수행
• exceptionHandling().accessDiniedPage : 인증된 사용자이지만 권한 밖의 endpoint에 접근시 이동시킬 uri 명시
• logout().logoutUrl : 해당 URL로 요청이 오는 경우 로그아웃 수행

http.userDetailsService(userDetailsService);

실제 로그인 처리를 수행하는 UserDetailsService를 지정

@RequiredArgsConstructor
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    private final UserDetailsServiceImpl userDetailsService;
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable();
        http.authorizeRequests()
                .antMatchers("/","/registry","/login", "/css/**").permitAll()
                .antMatchers("/member/**").authenticated() // 일반사용자 접근 가능
                .antMatchers("/manager/**").hasAnyRole("MANAGER", "ADMIN") // 매니저, 관리자 접근 가능
                .antMatchers("/admin/**").hasRole("ADMIN"); // 관리자만 접근 가능
        // 인증 필요시 로그인 페이지와 로그인 성공시 리다이랙팅 경로 지정
        http.formLogin().loginPage("/login").defaultSuccessUrl("/", true);
        // 로그인이 수행될 uri 매핑 (post 요청이 기본)
        http.formLogin().loginProcessingUrl("/login").defaultSuccessUrl("/", true);
        // 인증된 사용자이지만 인가되지 않은 경로에 접근시 리다이랙팅 시킬 uri 지정
        http.exceptionHandling().accessDeniedPage("/forbidden");
        // logout
        http.logout().logoutUrl("/logout").logoutSuccessUrl("/");

        http.userDetailsService(userDetailsService);
    }
}

---

🔎 Home HTML 작성

인증된 사용자에게 view를 달리하기 위해 thymeleaf extras Springsecurity5 를 사용했습니다. (인증된 사용자에게만 로그아웃 버튼 표시, 로그인 버튼 미표시 등 ..)
Maven Repository 링크

의존성 추가 후 아래와 같이 네임스페이스를 추가해줍니다.

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/extras/spring-security">
<head>
    <meta charset="UTF-8">
    <title>Home</title>
    <link th:href="@{/css/bootstrap.min.css}" rel="stylesheet">
</head>
<body>
<div class="container">
  <div class="my-4">
    <h2>홈</h2>
      <div sec:authorize="isAuthenticated()">
          <p th:text="|${principal.username}님 환영합니다.|"></p>
          <p th:text="|현재 ${principal.username} 님의 권한 : ${role}|"></p>
          <ul>
              <li th:text="|session.getId = ${#session.getId()}|"></li>
              <li th:text="|session.getAttributeNames = ${#session.getAttributeNames()}|"></li>
              <li th:text="|session.getCreationTime = ${#session.getCreationTime()}|"></li>
          </ul>
      </div>
      <div class="btn">
        <a th:href="@{/registry}">
            <button class="btn btn-lg btn-secondary">회원가입</button>
        </a>
        <a th:href="@{/login}">
            <button sec:authorize="!isAuthenticated()" class="btn btn-lg btn-dark">로그인</button>
        </a>
          <a th:href="@{/logout}">
              <button sec:authorize="isAuthenticated()" class="btn btn-danger btn-lg">로그아웃</button>
          </a>

        <hr class="my-4">
          <a th:href="@{/admin/home}"><button class="btn btn-lg btn-dark">ADMIN page 접근 </button></a>
          <a th:href="@{/manager/home}"><button class="btn btn-lg btn-dark">MANAGER page 접근</button></a>
      </div>
  </div>
</div>
</body>
</html>

---

🔎 회원가입, 로그인 폼

[ 회원가입 폼 ]
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>회원가입</title>
    <link th:href="@{/css/bootstrap.min.css}" rel="stylesheet">
</head>
<body>

<div class="container">
    <div class="my-4">
        <h2>회원가입</h2>
    </div>
    <form th:action method="post" th:object="${member}">
        <div class="mb-3">
            <label for="username" class="form-label">username</label>
            <input type="text" class="form-control" id="username" th:field="*{username}">
        </div>
        <div class="mb-3">
            <label for="password" class="form-label">Password</label>
            <input type="password" class="form-control" id="password" th:field="*{password}">
        </div>

        <hr class="my-3">
        <div class="mb-3">
            <div th:each="r : ${roles}" class="form-check form-check-inline">
                <input type="radio" th:field="*{role}" th:value="${r.value}" class="form-check-input">
                <label th:for="${#ids.prev('role')}" th:text="${r.key}" class="form-check-label"></label>
            </div>
        </div>
        <button type="submit" class="btn btn-primary">회원가입</button>
    </form>
</div>
</body>
</html>

[ 로그인 폼 ]

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Login</title>
    <link th:href="@{/css/bootstrap.min.css}" rel="stylesheet">
</head>
<body>
<div class="container">
  <div class="my-4">
    <h2>로그인</h2>
  </div>
  <form th:action method="post" th:object="${member}">
    <div class="mb-3">
      <label for="username" class="form-label">username</label>
      <input type="text" class="form-control" id="username" th:field="*{username}">
    </div>
    <div class="mb-3">
      <label for="password" class="form-label">Password</label>
      <input type="password" class="form-control" id="password" th:field="*{password}">
    </div>
    <button type="submit" class="btn btn-primary">로그인</button>
  </form>
</div>
</body>
</html>

---

🔎 회원가입 컨트롤러 작성

서비스 계층을 따로 두지 않아 컨트롤러에서 바로 레포지토리를 주입받아 사용했습니다.

password 저장시 BCryptPasswordEncoder를 이용해 단방향 해시로 인코딩했습니다.

@Slf4j
@RequiredArgsConstructor
@Controller
public class RegistryController {

    private final MemberRepository memberRepository;
    private final BCryptPasswordEncoder passwordEncoder;

    @GetMapping("/registry")
    public String registryForm(Model model) {
        model.addAttribute("member", new RegistryRequest());
        return "registration";
    }

    @PostMapping("/registry")
    public String registry(@ModelAttribute RegistryRequest registryRequest) {
        Member member = Member.builder()
                .username(registryRequest.getUsername())
                .password(passwordEncoder.encode(registryRequest.getPassword()))
                .role(registryRequest.getRole())
                .build();
        memberRepository.save(member);

        return "redirect:/login";
    }

    @ModelAttribute("roles")
    public Map<String, Role> roles() {
        Map<String, Role> map = new LinkedHashMap<>();
        map.put("관리자", Role.ROLE_ADMIN);
        map.put("매니저", Role.ROLE_MANAGER);
        map.put("일반 사용자", Role.ROLE_MEMBER);
        return map;
    }
}

BCryptPasswordEncoder는 간단하게 main 클래스에서 빈으로 등록해주었습니다.

view와 controller 간 데이터 인터페이싱을 위해 사용한 요청객체입니다.

@Getter @Setter
public class RegistryRequest {

    private String username;
    private String password;
    private Role role = Role.ROLE_MEMBER;
}

---

🔎 로그인 컨트롤러 작성

전부입니다..

로그인 쪽 컨트롤러는 로그인 폼 랜더링만을 담당합니다.
로그인 처리는 SecurityConfig의 loginProcessingUrl로 보내주기만 하면 됩니다.

@Controller
public class LoginController {

    @GetMapping("/login")
    public String loginForm(Model model) {

        model.addAttribute("member", new LoginRequest());
        return "login";
    }
}

---

🔎 테스트 !

홈 화면

일반 사용자 (Role_MEMBER)로 회원가입

일반 사용자 권한으로 MANAGER, ADMIN 페이지에 접근 (권한X)

ADMIN 권한으로 회원가입 / 로그인 후 MANAGER, ADMIN 페이지에 접근 (권한O)

이상으로 Spring Security를 이용한 간단한 세션방식 로그인을 알아보았습니다.
사실 이런 방식은 이제는 잘 쓰이지 않는다고 합니다. 주로 JWT 토큰방식을 사용하죠. 보안적인 문제가 가장 크겠지만 이런 세션방식을 사용한다면 이후 Oauth2 사용시 문제가 될 수 있습니다.
그래도 기본은 알고 있어야한다고 생각하기에 한 번 간단하게 구현해봤습니다. ㅎ

다음에는 JWT를 이용한 인증을 구현해보겠습니다 !

전체 소스코드는 깃허브를 참고해주세요 감사합니다 ㅎ 😄