[Spring Security] 스프링 시큐리티 기본 - 1

들어가기전에

이번 프로젝트에서 멤버 부분을 구현하게 되었다. 그전에 스프링 시큐리티에 대해서 자세하게 학습하고 가보자!

 

Spring Security란?

 

스프링 시큐리티가 적용되지 않았을시에 문제점을 먼저 알아보자. 

 

1. 로그인기능에 Authentication(인증) 이 없음.

2. API에 대한 권한 부여 Authirization(인가) 기능이 없음.

3. 웹 보안 취약점에 대한 대비(CSRF, 클릭제킹 등)가 없음.

 

그럼 스프링 시큐리티를 적용하면 어떤점이 달라질까?

• 다양한 유형(폼 로그인 인증, 토큰 기반 인증, OAuth 2 기반 인증, LDAP 인증)의 사용자 인증 기능 적용
• 애플리케이션 사용자의 역할(Role)에 따른 권한 레벨 적용
• 애플리케이션에서 제공하는 리소스에 대한 접근 제어
• 민감한 정보에 대한 데이터 암호화
• SSL 적용
• 일반적으로 알려진 웹 보안 공격 차단
• SSO, 클라이언트 인증기반인증, 메서드보안, 접근 제어 목록 등

다시말해서 스프링시큐리티는 인증, 권한부여 및 보호 기능을 제공하는 프레임 워크이다. 개발을 할때 보안분야는 정말 중요하지만 많은 시간이 소요된다. 이를 위해 만들어진 스프링 시큐리티를 통해 인증, 권한 권한확인 등에 필요한 기능들을 사용할 수 있다.  

 

 

스프링 시큐리티 이외의 Java 보안 솔루션도 존재한다.

- Apache Shiro

- OACC

 

로그인 기능 기본(InMemory 사용)

지금부터 알아볼 부분은 DB가 없이 InMemory로 구성하는 방법이다.Inmemory 로 사용하는 방법을 확인하고 DB를 연동하는 방법을 보자.

 

기본 설정

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration //어노테이션으로 지정
public class SecurityConfiguration {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()                 // (1) csrf 공격 비활성
            .formLogin()                      // (2) 로그인 방식 지정
            .loginPage("/auths/login-form")   // (3) 지정해둔 로그인 페이지 사용
            .loginProcessingUrl("/process_login")    // (4) 로그인요청 수행 url 지정
            .failureUrl("/auths/login-form?error")   // (5) 실패시에 redirect 할곳
            .and()                                   // (6) 메서드체인형태로 사용
            .authorizeHttpRequests()                     // (7) 클라이언트 요청 접근 권한 확인
            .anyRequest()                            // (8) 모든 요청을 접근 허용
            .permitAll();                            // (9) 허용

        return http.build();
    }

/*
InMemoryUserDetailsManager를 이용해 
데이터베이스 연동 없이 테스트 목적의 
InMemory User를 생성
*/
    @Bean
    public InMemoryUserDetailsManager userDetailsService() { 
        UserDetails user =
                User.withDefaultPasswordEncoder()
                        .username("kevin@gmail.com") //계정 username 
                        .password("1111") //계정비밀번호
                        .roles("USER") //계정 권한
                        .build();
        return new InMemoryUserDetailsManager(user);
    }
}

 

URI 접근 권한 부여

 @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .formLogin()
            .loginPage("/auths/login-form")
            .loginProcessingUrl("/process_login")
            .failureUrl("/auths/login-form?error")
            .and()
            .exceptionHandling().accessDeniedPage("/auths/access-denied")   // (1)
            .and()
            .authorizeHttpRequests(authorize -> authorize                  // (2)
                    .antMatchers("/orders/**").hasRole("ADMIN")        // (2-1)
                    .antMatchers("/members/my-page").hasRole("USER")   // (2-2)
                    .antMatchers("⁄**").permitAll()                    // (2-3)
            );
        return http.build();
    }

 

(1)을 통해 접근권한이 없는 경우 exception이 발생하고 이것을 처리할 page를 지정한다.

(2)를 통해 람다 표현식으로 request URI에 접근권한을 부여한다.

(2-1) .antMatchers("/orders/**").hasRole("ADMIN")은 ADMIN Role을 부여받은 사용자만 /orders로 시작하는 모든 URL에 접근할 수 있다는 의미이다.

 

/orders/에서 `는 /orders로 시작하는 모든 하위 URL을 포함한다.
예를 들어/orders/1,/orders/1/coffees,/orders/1/coffees/1` 같은 모든 하위 URL을 포함한다. 만약 /orders/*라는 URL을 지정했다면 /orders/1과 같이 /orders의 하위 URL의 depth가 1인 URL만 포함한다.

(2-2)의 antMatchers("/members/my-page").hasRole("USER")은 USER Role을 부여받은 사용자만 /members/my-page URL에 접근할 수 있음을 나타낸다.
(2-3)의 .antMatchers("/**").permitAll()은 앞에서 지정한 URL 이외의 나머지 모든 URL은 Role에 상관없이 접근이 가능함을 의미한다.

 

antMatcher() 를 통해 작성될때 구체적인 URL 경로부터 접근권한을 부여하고, 덜구체적인 URL 경로에 접근 권한을 부여해야한다.

 

로그아웃 설정

 @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .formLogin()
            .loginPage("/auths/login-form")
            .loginProcessingUrl("/process_login")
            .failureUrl("/auths/login-form?error")
            .and()
            .logout()                        // (1) 로그아웃 설정을 함
            .logoutUrl("/logout")            // (2) 로그아웃 url을 지정한다.
            .logoutSuccessUrl("/")  // (3) 로그아웃 성공시에 redirect url
            .and()
            .exceptionHandling().accessDeniedPage("/auths/access-denied")
            .and()
            .authorizeHttpRequests(authorize -> authorize
                    .antMatchers("/orders/**").hasRole("ADMIN")
                    .antMatchers("/members/my-page").hasRole("USER")
                    .antMatchers("⁄**").permitAll()
            );
        return http.build();
    }

 

회원가입 설정

회원가입을 폼을 통해 등록하기 위해서는 아래와 같은 작업이 필요하다.

• PasswordEncoder Bean 등록
• MemberService Bean 등록을 위한 JavaConfiguration 구성
• MemberService 클래스 구현

 

1. PasswordEncoder Bean 등록

 

PasswordEncoder 는 스프링 시큐리티에서 제공하는 패스워드 암호화 기능을 제공하는 컴포넌트이다. 회원가입폼을 통해서 입력되는 데이터는 암호화되지않은 Plain Text 이다. 그러므로 이를 DB에 기록하기전에 암호화를 해야한다. 다양한 암호화 방식을 제공하지만 default는 bycrypt 방식이다.

@Configuration
public class SecurityConfiguration {
    ...
    ...

    @Bean
    public UserDetailsManager userDetailsService() {
        UserDetails user =
                User.withDefaultPasswordEncoder()
                        .username("kevin@gmail.com")
                        .password("1111")
                        .roles("USER")
                        .build();

        UserDetails admin =
                User.withDefaultPasswordEncoder()
                        .username("admin@gmail.com")
                        .password("2222")
                        .roles("ADMIN")
                        .build();

        return new InMemoryUserDetailsManager(user, admin);
    }

    // (1)
    @Bean
    public PasswordEncoder passwordEncoder() {
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();  // (1-1)
    }
}

(1-1)을 보면 PasswordEncoder를 Bean으로 등록한다. 그리고 createDelegatingPasswordEncoder()를 통헤서 DelegatingPasswordEncoder를 먼저 생성한다. 그리고 이러한 DelegatingPasswordEncoder가 실질적으로 PasswordEncoder 구현체를 생성해 준다. 

 

2.MemberService Bean 등록을 위한 JavaConfiguration 구성

 

@Configuration
public class JavaConfiguration {
    // (1)
    @Bean
    public MemberService inMemoryMemberService(UserDetailsManager userDetailsManager, 
                                               PasswordEncoder passwordEncoder) {
        return new InMemoryMemberService(userDetailsManager, passwordEncoder);
    }
}

(1)에서 Bean으로 등록을 한다. User 등록시에 패스워드를 암호화 한 후에 등록해야되므로, PasswordEncoder 객체가 필요하다. 그러므로 이러한 두가지 객체를 생성시에 DI 해준다.

 

3. MemberService 구현

public class InMemoryMemberService implements MemberService {  // (1)
    private final UserDetailsManager userDetailsManager;
    private final PasswordEncoder passwordEncoder;

    // (2) UserDetails, PasswordEncoder를 DI 받는다.
    public InMemoryMemberService(UserDetailsManager userDetailsManager, PasswordEncoder passwordEncoder) {
        this.userDetailsManager = userDetailsManager;
        this.passwordEncoder = passwordEncoder;
    }

    public Member createMember(Member member) {
        // (3) User의 권한을 지정한다.
        List<GrantedAuthority> authorities = createAuthorities(Member.MemberRole.ROLE_USER.name());

        // (4) PasswordEncoder를 이용해 등록할 User의 패스워드를 암호화한다.
        String encryptedPassword = passwordEncoder.encode(member.getPassword());

        // (5) User로 등록하기 위해 UserDetails를 생성한다.
        UserDetails userDetails = new User(member.getEmail(), encryptedPassword, authorities);

        // (6) UserDetailsManager의 create 메서드를 이용, 유저를 생성한다.
        userDetailsManager.createUser(userDetails);

        return member;
    }

    private List<GrantedAuthority> createAuthorities(String... roles) {
        // (3-1)
        return Arrays.stream(roles)
                .map(role -> new SimpleGrantedAuthority(role))
                .collect(Collectors.toList());
    }
}

 

DB 연동 로그인 구현

User 의 인증정보를 테이블에 저장하고, 테이블에 저장된 인증정보를 이용해서 인증 프로세스를 진행할 수있는 방법을 알아보자. 그중 한가지가 Custom UserDetailService를 이용하는 것이다.

 

시큐리티에서 인증을 시도하는 주체를 User(Principal)이라고 한다. Principal은 User의 구체적인 정보를 의미하고, 일반적으로 시큐리티에서의 Username을 의미한다.  

 

1. SecurityConfiguration 의 설정 변경 및 추가

@Configuration
public class SecurityConfiguration {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .headers().frameOptions().sameOrigin() // (1) //웹을 사용하기 위한 설정
            .and()
            .csrf().disable()
            .formLogin()
            .loginPage("/auths/login-form")
            .loginProcessingUrl("/process_login")
            .failureUrl("/auths/login-form?error")
            .and()
            .logout()
            .logoutUrl("/logout")
            .logoutSuccessUrl("/")
            .and()
            .exceptionHandling().accessDeniedPage("/auths/access-denied")
            .and()
            .authorizeHttpRequests(authorize -> authorize
                    .antMatchers("/orders/**").hasRole("ADMIN")
                    .antMatchers("/members/my-page").hasRole("USER")
                    .antMatchers("⁄**").permitAll()
            );
        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }
}

(1)의 .frameOptions().sameOrigin()을 호출하게 되면, 동일 출처로 부터 들어오는 request만 페이지 렌더링을 허용한다. 

 

 

2. Java Configuration의 Bean 등록 변경

@Configuration
public class JavaConfiguration {
    // (1)
    @Bean
    public MemberService dbMemberService(MemberRepository memberRepository,
                                         PasswordEncoder passwordEncoder) {
        return new DBMemberService(memberRepository, passwordEncoder); (1-1)
    }
}

(1-1) 데이터 베이스에 User의 정보를 저장하기 위해 MemberRepository와 PasswordEncoder 객체를 DI하는 dbMemberService 를 작성한다.

 

3. DB MemberService 구현

@Transactional
public class DBMemberService implements MemberService {
    private final MemberRepository memberRepository;
    private final PasswordEncoder passwordEncoder;

    // (1) 생성자를 통해 Bean객체를 DI 받음.
    public DBMemberService(MemberRepository memberRepository,
                             PasswordEncoder passwordEncoder) {
        this.memberRepository = memberRepository;
        this.passwordEncoder = passwordEncoder;
    }

    public Member createMember(Member member) {
        verifyExistsEmail(member.getEmail());
        String encryptedPassword = passwordEncoder.encode(member.getPassword());  // (2) 패스워드 암호화
        member.setPassword(encryptedPassword);    // (3) 암호화된 패스워드를 password 필드에 할당

        Member savedMember = memberRepository.save(member);

        System.out.println("# Create Member in DB");
        return savedMember;
    }
    
    ...
    ...
}

(2), (3)패스워드는 암호화된 상태에서 복호화할 필요가 없으므로 단방향 암호화방식으로 적용되야 한다!

 

 

4. Custom UserDetailService 구현

@Component
public class HelloUserDetailsServiceV1 implements UserDetailsService {   // (1)
    private final MemberRepository memberRepository;
    private final HelloAuthorityUtils authorityUtils;

    // (2)
    public HelloUserDetailsServiceV1(MemberRepository memberRepository, HelloAuthorityUtils authorityUtils) {
        this.memberRepository = memberRepository;
        this.authorityUtils = authorityUtils;
    }

    // (3)loadUserByUsername 추상 메서드를 구현
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Optional<Member> optionalMember = memberRepository.findByEmail(username);
        Member findMember = optionalMember.orElseThrow(() -> new BusinessLogicException(ExceptionCode.MEMBER_NOT_FOUND));

        // (4)이메일 정보를 이용해 Role기반 권한정보 컬렉션 생성
        Collection<? extends GrantedAuthority> authorities = authorityUtils.createAuthorities(findMember.getEmail());

        // (5)User객체를 리턴하면 Security가 리턴된 정보로 인증절차를 수행
        return new User(findMember.getEmail(), findMember.getPassword(), authorities);
    }
}

일단 공부를 위해서 V1 으로 작성을 하였다. UserDetails의 구현클래스인 User객체를 (5)에서 직접적으로 생성해서 리턴하고있는데, 이부분을 아래에서 고쳐볼것이다.

 

User DetailsService?
spring security에서 제공하는 컴포넌트 중 하나로, User 정보를 로드하는 핵심 인터페이스이다. load 는 인증에 필요한 User 정보를 DB나 메모리에서 가져온다. 는 의미이다. 

 

UserDetails?
UserDetails 는 UserDetailsService에 의해 로드 되어 인증을 위해 사용되는 핵심 User 정보를 표현하는 인터페이스이다. UserDetails 인터페이스의 구현체는 Spring Security에서 보안 정보 제공을 목적으로 직접 제공되지 않고, Authentication 객체로 캡슐화 되어 제공된다.

 

5. HelloAuthorityUtils 작성

@Component
public class HelloAuthorityUtils {
    @Value("${mail.address.admin}") // (1) application.yml에서 환경변수 가져오기
    private String adminMailAddress; //관리자권한 이메일을 가지고 온다.

    // (2) AuthorityUtils 이용, 관리자용 권한 목록을 List 객체로 생성
    private final List<GrantedAuthority> ADMIN_ROLES = AuthorityUtils.createAuthorityList("ROLE_ADMIN", "ROLE_USER");

    // (3)AuthorityUtils 이용, 일반 사용자용 권한 목록을 List 객체로 생성
    private final List<GrantedAuthority> USER_ROLES = AuthorityUtils.createAuthorityList("ROLE_USER");
    
    public List<GrantedAuthority> createAuthorities(String email) {
        // (4) 파라미터로 전달받은 이메일주소와 application.yml의 관리자와 동일하면 admin return
        if (email.equals(adminMailAddress)) {
            return ADMIN_ROLES;
        }
        return USER_ROLES;
    }
}

HelloAuthorityUtils는 Role 기반의 User 권한을 생성하기 위해 사용한다.

 

 

6. CustomUserDetails 구현 및 개선

@Component
public class HelloUserDetailsServiceV2 implements UserDetailsService {
    private final MemberRepository memberRepository;
    private final HelloAuthorityUtils authorityUtils;

    public HelloUserDetailsServiceV2(MemberRepository memberRepository, HelloAuthorityUtils authorityUtils) {
        this.memberRepository = memberRepository;
        this.authorityUtils = authorityUtils;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Optional<Member> optionalMember = memberRepository.findByEmail(username);
        Member findMember = optionalMember.orElseThrow(() -> new BusinessLogicException(ExceptionCode.MEMBER_NOT_FOUND));

        return new HelloUserDetails(findMember);  // (1) 개선된 부분
    }

    // (2) HelloUserDetails 클래스 추가
    private final class HelloUserDetails extends Member implements UserDetails { // (2-1)
        // (2-2)
        HelloUserDetails(Member member) {
            setMemberId(member.getMemberId());
            setFullName(member.getFullName());
            setEmail(member.getEmail());
            setPassword(member.getPassword());
        }

        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {
            return authorityUtils.createAuthorities(this.getEmail());  // (2-3) 리팩토링 포인트
        } //helloAuthorityUtils의 createAuthorities 이용하여 User 권한정보를 생성.

        // (2-4)
        @Override
        public String getUsername() { //getUsername의 리턴값은 null일수 없음.
            return getEmail();
        }

        @Override
        public boolean isAccountNonExpired() {
            return true;
        }

        @Override
        public boolean isAccountNonLocked() {
            return true;
        }

        @Override
        public boolean isCredentialsNonExpired() {
            return true;
        }

        @Override
        public boolean isEnabled() {
            return true;
        }
    }

}

기존에 loadUserByUsername()메서드의 리턴값으로 new User(...)을 리턴했지만, 개선된 코드에서는 (1)처럼 HelloUserDetails(findMember) 라는 Custom UserDetails 클래스의 생성자로 findMember를 전달한다. 이를 통해 코드가 훨씬 깔끔해졌고, 기존에 권한 정보를 생성하던Collection<? extends GrantedAuthority> authorities = authorityUtils.createAuthorities(findMember) 코드를 (2)의 HelloUserDetails 클래스의 내부로 포함시켰다. 

 

(2)의 HelloUserDetails 클래스는 UserDetails 인터페이스를 구현하고, Member엔티티 클래스를 상속하고 있다(2-1). 이렇게 구성하게 되면, 데이터 베이스에서 조회한 회원의 정보를 SpringSecurity의 User 정보로 변환하는 과정과 User의 권한 정보를 생성하는 과정을 캡슐화 가능하다. 그리고 Member를 상속하므로 HelloUserDetails를 리턴받아 사용하는 측에서 두개 클래스의 객체를 모두 다 쉽게 캐스팅 해서 사용 가능하다는 장점이 있다.

 

7.User의 Role을 DB에서 관리

일반적인 User의 인증정보 같은 보안관련 정보는 DB처럼 영구저장소에 안전하게 보관된다. 하지만 현재까지의 코드는 User의 권한 정보를 DB에서 관리하는 것이 아닌, DB에서 조회한 User의 정보를 기준으로 코드상에서 생성하고있다. 이를 변경하는 로직을 알아보자.

 

1. User 의 권한 정보를 저장하기 위한 테이블 생성

2. 회원 가입시 , User의 권한 정보(Role)을 DB에 저장하는 작업

3. 로그인 인증시, User의 권한 정보를 DB에서 조회하는 작업

 

7-1. User의 권한 정보 테이블 생성

@NoArgsConstructor
@Getter
@Setter
@Entity
public class Member extends Auditable implements Principal{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long memberId;

    @Column(length = 100, nullable = false)
    private String fullName;

    @Column(nullable = false, updatable = false, unique = true)
    private String email;

    @Column(length = 100, nullable = false)
    private String password;

    @Enumerated(value = EnumType.STRING)
    @Column(length = 20, nullable = false)
    private MemberStatus memberStatus = MemberStatus.MEMBER_ACTIVE;

    // (1) User의 권한 정보 테이블과 매핑되는 정보
    @ElementCollection(fetch = FetchType.EAGER)
    private List<String> roles = new ArrayList<>();

    public Member(String email) {
        this.email = email;
    }

    public Member(String email, String fullName, String password) {
        this.email = email;
        this.fullName= fullName;
        this.password = password;
    }

    @Override
    public String getName() {
        return getEmail();
    }

    public enum MemberStatus {
        MEMBER_ACTIVE("활동중"),
        MEMBER_SLEEP("휴면 상태"),
        MEMBER_QUIT("탈퇴 상태");

        @Getter
        private String status;

        MemberStatus(String status) {
           this.status = status;
        }
    }

    public enum MemberRole {
        ROLE_USER,
        ROLE_ADMIN
    }
}

User의 권한정보를 매핑하는 것은 (1)과 같이 처리하면된다. List, Set 등의 컬렉션 타입의 필드는 @ElementCollection 애너테이션을 추가하여 User 권한 정보와 관련된 별도의 엔티티 클래스를 생서하지 않아도 간단히 매핑처리가 가능하다.

 

이를 DB에서 조회하게 되면, 아래 그림과 같이 Member 엔티티 클래스와 연관관계 매핑에 대한 테이블이 생성된다.

 이때 한명의 회원이 한개이상의 Role을 가질수있으므로, Member와 Member_ROLES 테이블은 1:N 의 관계이다. 회원가입을 통해 회원 정보가 생성되면서, Member_ROLES 테이블의 MEMBER_MEMBER_ID 열에 Member 테이블의 기본키 값, ROLES 열에는 권한 정보가 저장될것이다.

 

7-2. 회원가입시, User의 권한 정보(Role)을 DB에 저장

@Component
public class HelloAuthorityUtils {
    @Value("${mail.address.admin}")
    private String adminMailAddress;

    ...
    ...

    private final List<String> ADMIN_ROLES_STRING = List.of("ADMIN", "USER");
    private final List<String> USER_ROLES_STRING = List.of("USER");

    ...
    ...

    // (1) DB 저장용
    public List<String> createRoles(String email) {
        if (email.equals(adminMailAddress)) {
            return ADMIN_ROLES_STRING;
        }
        return USER_ROLES_STRING;
    }
}

(1)을 보면 파라미터로 전달된 이메일과, application.yml의 admin 이메일 주소와 일치한지 확인하고, 동일하다면, ADMIN ROLE, 아니면 USER ROLE 을 리턴한다.

 

@Transactional
public class DBMemberService implements MemberService {
    ...
    ...
  
    private final HelloAuthorityUtils authorityUtils;

    ...
    ...

    public Member createMember(Member member) {
        verifyExistsEmail(member.getEmail());
        String encryptedPassword = passwordEncoder.encode(member.getPassword());
        member.setPassword(encryptedPassword);

        // (1) Role을 DB에 저장
        List<String> roles = authorityUtils.createRoles(member.getEmail());
        member.setRoles(roles);

        Member savedMember = memberRepository.save(member);

        return savedMember;
    }

    ...
    ...
}

위에서 작성했던 createRoles를 이용해서 회원의 권한을 생성하고, member의 객체에 Set 한다. 이렇게 Role까지 세팅된 Member 객체를 DB에 저장시킨다.

 

7-3. 로그인 인증시, User의 권한 정보를 DB에서 조회하는 작업

@Component
public class HelloUserDetailsServiceV3 implements UserDetailsService {
    private final MemberRepository memberRepository;
    private final HelloAuthorityUtils authorityUtils;

    public HelloUserDetailsServiceV3(MemberRepository memberRepository, HelloAuthorityUtils authorityUtils) {
        this.memberRepository = memberRepository;
        this.authorityUtils = authorityUtils;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Optional<Member> optionalMember = memberRepository.findByEmail(username);
        Member findMember = optionalMember.orElseThrow(() -> new BusinessLogicException(ExceptionCode.MEMBER_NOT_FOUND));

        return new HelloUserDetails(findMember);
    }

    private final class HelloUserDetails extends Member implements UserDetails {
        HelloUserDetails(Member member) {
            setMemberId(member.getMemberId());
            setFullName(member.getFullName());
            setEmail(member.getEmail());
            setPassword(member.getPassword());
            setRoles(member.getRoles());        // (1)
        }

        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {
            // (2) DB에 저장된 Role 정보로 User 권한 목록 생성
            return authorityUtils.createAuthorities(this.getRoles());
        }

        ...
        ...
    }

}

위에서 작성했었던 HelloUserDetails를 한번더 개선해서 V3로 만들었다. 

(1)을 보면, HelloUserDetails가 상속하고있는 Member에 데이터베이스에서 조회한 List<String> roles를 전달한다. 

(2)를 보면, Member에 전달한 Role의 정보를 authorityUtils.createAuthorities() 메서드의 파라미터로 전달해서 권한목록(List<GrantedAuthority>)를 생성한다.  기존(V2)에는 DB에서 Role정보를 가져오지 않았기 때문에 ,    authorityUtils.createAuthorities(this.getEmail())로 작성되었었다.

 

@Component
public class HelloAuthorityUtils {
    @Value("${mail.address.admin}")
    private String adminMailAddress;

    private final List<GrantedAuthority> ADMIN_ROLES = AuthorityUtils.createAuthorityList("ROLE_ADMIN", "ROLE_USER");
    private final List<GrantedAuthority> USER_ROLES = AuthorityUtils.createAuthorityList("ROLE_USER");
    private final List<String> ADMIN_ROLES_STRING = List.of("ADMIN", "USER");
    private final List<String> USER_ROLES_STRING = List.of("USER");

    // 메모리 상의 Role을 기반으로 권한 정보 생성.
    public List<GrantedAuthority> createAuthorities(String email) {
        if (email.equals(adminMailAddress)) {
            return ADMIN_ROLES;
        }
        return USER_ROLES;
    }

    // (1) DB에 저장된 Role을 기반으로 권한 정보 생성
    public List<GrantedAuthority> createAuthorities(List<String> roles) {
       List<GrantedAuthority> authorities = roles.stream()
               .map(role -> new SimpleGrantedAuthority("ROLE_" + role)) // (2)
               .collect(Collectors.toList());
       return authorities;
    }

    ...
    ...
}

DB에서 조회한 Role 정보를 기반으로 User의 권한 목록을 생성하는 createAuthorities(List<String> roles) 메서드를 추가하였다. 

(1)을 보면 기존에는 application.yml의 환경변수에 정의된 관리자용 이메일 주소를 기준으로 관리자의 Role을 추가 하였지만, 이제는 단순히 DB에서 가져온 Role 목록을 그대로 이용해서 권한 목록을 만들어준다. 이때, 생성자의 파라미터로 ROLE_USER , ROLE_ADMIN 등의 형태로 넘겨주어야한다.

 

여기까지 작성이 되었다면, 정상적으로 회원가입과 로그인이 작동할것이다.