[Spring] 5. 스프링시큐리티와 OAuth 2.0으로 로그인 기능 구현하기

스프링 시큐리티는 막강한 인증(Authentication)과 인가(Authorization) 기능을 가진 프레임워크입니다.  사실상 스프링 기반의 애플리케이션에서는 보안을 위한 표준이라고 보시면 됩니다. 

스프링의 대부분 프로젝트들(Mvc, Data, Batch 등등)처럼 확장성을 고려한 프레임워크다 보니 다양한 요구사항을 손쉽게 추가하고 변경할 수 있습니다. 

 

 

 

스프링 시큐리티와 스프링 시큐리티 oauth2 클라이언트

많은 서비스에서 로그인 방식보다는 구글, 페이스북, 네이버 로그인과 같은 소셜 로그인 기능을 사용합니다.

 

많은 서비스에서 소셜 로그인을 사용하는 이유는 뭘까요?? 로그인 기능을 직접 구현할 경우 배보다 배꼽이 커지는 경우가 많기 때문입니다. 직접 구현하면 다음을 전부 구현해야 합니다. OAuth를 써도 구현해야 하는것은 제외했습니다.

• 로그인 시 보안
• 비밀번호 찾기
• 회원가입 시 이메일 혹은 전화번호 인증
• 비밀변호 변경
• 회원정보 변경

OAuth 로그인 구현 시 앞선 목록의 것들을 모두 구글, 페이스북, 네이버 등에 맡기면 되니 서비스 개발에 집중할 수 있씁니다.

 

• 스프링 부트 1.5 vs 스프링 부트 2.0

스프링 부트 1.5에서의 OAuth2 연동 방법이 2.0에서는 크게 변경되었습니다. 하지만, 인터넷 자료들을 보면 설정 방법에 크게 차이가 없는 경우를 자주 봅니다. 이는 spring-security-oauth2-autoconfigure 라이브러리 덕분입니다.

 

spring-security-oauth2-autoconfigure

spring-security-oauth2-autoconfigure 라이브러리를 사용할 경우 스프링 부트2에서도 1.5에서 쓰던 설정을 그대로 사용할 수 있습니다. 새로운 방법을 쓰기보다는 기존에 안전하게 작동하던 코드를 사용하는 것이 아무래도 더 확실하므로 많은 개발자가 이 방식을 사용해 왔습니다. 

 

하지만 이 책에서는 스프링 부트 2 방식인 Spring Security Oauth2 Client 라이브러리를 사용해서 진행합니다. 이유는 아래와 같습니다.

• 스프링 팀에서 기존 1.5에서 사용되던 spring-security-oauth 프로젝트는 유지 상태로 결정했으며 더는 신규 기능은 추가하지 않고 버그 수정 정도의 기능만 추가될 예정, 신규 기능은 새 oauth2 라이브러리에서만 지원하겠다고 선언
• 스프링 부트용 라이브러리(starter) 출시
• 기존에 사용되던 방식은 확장 포인트가 적절하게 오픈되어 있지 않아 직접 상속하거나 오버라이딩 해야 하고 신규 라이브러리의 경우 확장 포인트를 고려해서 설계된 상태   

그리고 한가지 더 이야기하자면, 이 책 이외에 스프링 부트 2 방식의 자료를 찾고 싶은 경우 인터넷 자료들 사이에서 다음 두 가지만 확인하면 됩니다. 먼저 spring-security-oauth2-autoconfigure 라이브러리를 썻는지를 확인하고 application.properties 혹은 application.yml 정보가 다음과 같이 차이가 있는지 비교해야합니다. 

스프링 부트 1.5와 2.0 설정 차이

스프링 부트 1.5방식에서는 url 주소를 모두 명시해야하지만, 2.0방식에서는 client 인증 정보만 입력하면 됩니다. 1.5 버전에서 직접 입력했던 값들은 2.0버전으로 오면서 모두 enum으로 대체되었습니다.

CommonOAuth2Provider라는 enum이 새롭게 추가되어 구글, 깃허브, 페이스북, 옥타의 기본 설정값을 모두 여기서 제공합니다. 이외의 다른 소셜 로그인(네이버, 카카오 등)을 추가한다면 직접 다 추가해주어야 합니다.

 

 

 

구글 서비스 등록

먼저 구글 서비스에 신규 서비스를 생성합니다. 여기서 발급된 인증 정보(clientId와 clientSecret)를 통해서 로그인 기능과 소셜 서비스 기능을 사용할 수 있으니 무조건 발급받고 시작해야 합니다.

 

 

 

appication-oauth 등록

src/main/resources에 appication-oauth.properties 파일을 생성한 뒤 아래의 코드를 추가합니다. 

spring.security.oauth2.client.registration.google.client-id=구글클라이언트ID
spring.security.oauth2.client.registration.google.client-secret=구글클라이언트시크릿
spring.security.oauth2.client.registration.google.scope=profile,email

• scpoe=profile,email
  • 기본 값은 openid, profile, email 입니다.
  • 강제로 profile, email을 등록한 이유는 Openid라는 scope가 있으면 Open Id Provider로 인식하기 때문입니다.
  • 이렇게되면 openid Provider인 서비스(구글)와 그렇지 않은 서비스(네이버/카카오 등)로 나눠서 각각 Oauth2Service를 만들어야합니다.

스프링 부트에서는 properties의 이름을 application-xxx.properties로 만들면 xxx라는 이름의 Profiler이 생성되어 이를 통해 관리할 수 있습니다. 즉, profile=xxx라는 식으로 호출하면 해당 properties의 설정들을 가져올 수 있습니다. 호출하는 방식을 여러개지만 이 책에서는 스프링 부트의 기본 설정파일인 application.properties에서 application-oauth.properties를 포함하도록 구성합니다. 

 

application.properties에 아래와 같이 코드를 추가합니다.

spring.profiles.include=oauth

 

 

.gitignore 등록

구글 로그인을 위한 클라이언트 ID와 클라이언트 보안 비밀은 보안이 중요한 정보들입니다. 외부에 노출하면 안되는데 github에 오픈소스를 올려놓으면 노출하게됩니다. 보안을 위해 깃허브에 application-oauth.properties 파일이 올라가는 것을 방지하겠습니다.

 

plugins에 .gitignore을 설치 후 gitignore 파일을 만들어줍니다. 해당 파일에 아래의 코드를 추가해주면 됩니다.

application-oauth.properties

.gradle
.idea

 

커밋 내역의 해당 파일이 없으면 성공입니다.

 

 

 

구글 로그인 연동하기

구글의 로그인 인증정보를 발급 받았으니 프로젝트 구현을 진행해봅시다. 머넞 사용자 정보를 담당할 도메인인 User 클래스를 생성합니다. 패키지는 domain 아래에 user 패키지를 생성합니다.

User 클래스 생성

@Getter
@NoArgsConstructor
@Entity
public class User extends BaseTimeEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private String email;

    @Column
    private String picture;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private Role role;

    @Builder
    public User(String name, String email, String picture, Role role) {
        this.name = name;
        this.email = email;
        this.picture = picture;
        this.role = role;
    }

    public User update(String name, String picture) {
        this.name = name;
        this.picture = picture;

        return this;
    }

    public String getRoleKey() {
        return this.role.getKey();
    }
}

• @Enumerated (EnumType.STRING)
  • JPA로 데이터베이스로 저장할 때 Enum 값을 어떤 형태로 저장할지를 결정합니다.
  • 기본적으로는 int로 된 숫자가 저장됩니다.
  • 숫자로 저장되면 데이터베이스로 확인할 때 그 값이 무슨 코드를 의미하는지 알 수 가 없습니다.
  • 그래서 문자열(EnumType.STRING)로 저장될 수 있도록 선언합니다.

각 사용자의 권한을 관리할 Enum 클래스 Role을 생성합니다.

Role Enum 클래스 생성

@Getter
@RequiredArgsConstructor
public enum Role {

    GUEST("ROLE_GUEST", "손님"),
    USER("ROLE_USER", "일반 사용자");

    private final String key;
    private final String title;

}

스프링 시큐리티에서는 권한 코드에 항상 ROLE_이 앞에 있어야만 합니다.

 

마지막으로 User의 CRUD를 책임질 UserRepository도 생성합니다.

UserRepository 인터페이스 생성

public interface UserRepository extends JpaRepository<User, Long> {

    Optional<User> findByEmail(String email);
}

• findByEmail
  • 소셜 로그인으로 반환되는 값 중 email을 통해 이미 생성된 사용자인지 처음 가입하는 사용자인지 판단하기 위한 메소드입니다.

 

User 엔티티 관련 코드를 모두 작성했으니 본격적으로 시큐리티 설정을 진행하겠습니다.

 

 

스프링 시큐리티 설정

먼저 build.gradle에 스프링 시큐리티 관련 의존성 하나를 추가합니다. 코드는 아래와 같습니다.

    // 스프링 시큐리티
    implementation('org.springframework.boot:spring-boot-starter-oauth2-client')

• spring-boot-starter-oauth2-client
  • 소셜 로그인 등 클라이언트 입장에서 소셜 기능 구현 시 필요한 의존성입니다.
  • spring-security-oauth2-client와 spring-security-oauth2-jose를 기본으로 관리해줍니다.

build.gradle 설정이 끝났으면 OAuth 라이브러리를 이용한 소셜 로그인 설정 코드를 작성합니다.

config.auth 패키지를 앞으로 시큐리티 관련 클래스는 모두 이곳에 담는다고 보면 됩니다.

 

SecurityConfig 클래스를 생성하고 아래와 같이 코드를 작성합니다. CustomOAuth2UserService 클래스를 아직 만들지 않아서 아직 코드를 돌리면 안됩니다.

SecurityConfig 클래스 생성

@RequiredArgsConstructor
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final CustomOAuth2UserService customOAuth2UserService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .csrf().disable()
                .headers().frameOptions().disable()
                .and()
                    .authorizeRequests()
                    .antMatchers("/", "/css/**", "/images/**", "/js/**", "/h2-console/**", "/profile").permitAll()
                    .antMatchers("/api/v1/**").hasRole(Role.USER.name())
                    .anyRequest().authenticated()
                .and()
                    .logout()
                        .logoutSuccessUrl("/")
                .and()
                    .oauth2Login()
                        .userInfoEndpoint()
                            .userService(customOAuth2UserService);
    }
}

• @EnableWebSecurity
  • Spring Security 설정들을 활성화시켜 줍니다.
• csrf().disable().headers().frameOptions().disable
  • h2-console 화면을 사용하기 위해 해당 옵션들을 disalbe 합니다.
• authorizeRequests
  • URL 별 권한 관리를 설정하는 옵션의 시작점입니다.
  • authorizeRequests가 선언되어야만 antMatchers 옵션을 사용할 수 있습니다.
• antMatchers
  • 권한 관리 대상을 지정하는 옵션입니다.
  • URL, HTTP 메소드별로 관리가 가능합니다.
  • "/"등 지정된 URL들은 permitAll() 옵션을 통해 전체 열람 권한을 주었습니다.
  • "/api/v1/**" 주소를 가진 API는 USER 권한을 가진 사람만 가능하도록 했습니다.
• anyRequest
  • 설정된 값들 이외 나머지 URL들을 나타냅니다.
  • 여기서는 authenticated()를 추가하여 나머지 URL들은 모두 인증된 사용자들에게만 허용하게 합니다.
  • 인증된 사용자 즉, 로그인한 사용자들을 이야기합니다.
• logout().logoutSuccessURL("/")
  • 로그아웃 기능에 대한 여러 설정의 진입점입니다.
  • 로그아웃 성공 시 "/" 주소로 이동합니다.
• oauth2Login
  • OAuth2 로그인 기능에 대한 여러 설정의 진입점입니다.
• userInfoEndpoint
  • OAuth2 로그인 성공 이후 사용자 정보를 가져올 때 의 설정들을 담당합니다.
• userService
  • 소셜 로그인 성공 시 후속 조치를 진행할 UserService 인터페이스의 구현체를 등록합니다.
  • 리소스 서버(즉, 소셜 서비스들)에서 사용자 정보를 가져온 상태에서 추가로 진행하고자 하는 기능을 명시할 수 있습니다.

설정 코드 작성이 끝났다면 CustomOAuth2UserService 클래스를 생성합니다. 이 클래스는 구글 로그인 이후 가져온 사용자의 정보(email, name, picture)들을 기반으로 가입 및 정보수정, 세션 저장 등의 기능을 지원합니다.

CustomOAuth2UserService 클래스 생성

@RequiredArgsConstructor
@Service
public class CustomOAuth2UserService implements OAuth2UserService<OAuth2UserRequest, OAuth2User> {
    private final UserRepository userRepository;
    private final HttpSession httpSession;

    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
        OAuth2UserService delegate = new DefaultOAuth2UserService();
        OAuth2User oAuth2User = delegate.loadUser(userRequest);

        String registrationId = userRequest.getClientRegistration().getRegistrationId();
        String userNameAttributeName = userRequest.getClientRegistration().getProviderDetails()
                .getUserInfoEndpoint().getUserNameAttributeName();

        OAuthAttributes attributes = OAuthAttributes.of(registrationId, userNameAttributeName, oAuth2User.getAttributes());

        User user = saveOrUpdate(attributes);
        httpSession.setAttribute("user", new SessionUser(user));

        return new DefaultOAuth2User(
                Collections.singleton(new SimpleGrantedAuthority(user.getRoleKey())),
                attributes.getAttributes(),
                attributes.getNameAttributeKey());
    }


    private User saveOrUpdate(OAuthAttributes attributes) {
        User user = userRepository.findByEmail(attributes.getEmail())
                .map(entity -> entity.update(attributes.getName(), attributes.getPicture()))
                .orElse(attributes.toEntity());

        return userRepository.save(user);
    }
}

• registrationId
  • 현재 로그인 진행 중인 서비스를 구분하는 코드입니다.
  • 지금은 구글만 사용하는 불필요한 값이지만, 이후 네이버 로그인 연동 시에 네이버 로그인인지, 구글 로그인인지 구분하기 위해 사용합니다.
• userNameAttributeName
  • OAuth2 로그인 진행 시 키가 되는 필드값을 이야기합니다. Primary Key와 같은 의미입니다.
  • 구글의 경우 기본적으로 코드를 지원하지만, 네이버 카카오 등은 기본 지원하지 않습니다. 구글의 기본 코드는 "sub"입니다.
  • 이후 네이버 로그인과 구글 로그인을 동시 지원할 때 사용됩니다.
• OAuthAttributes
  • OAuth2UserService를 통해 가져온 OAuth2User의 attribute를 담을 클래스입니다.
  • 이후 네이버 등 다른 소셜 로그인도 이 클래스를 사용합니다.
  • 바로 아래에서 이 클래스의 코드가 나오니 차례로 생성하시면 됩니다.
• SessionUser
  • 세션에 사용자 정보를 저장하기 위한 Dto 클래스입니다.
  • 왜 User 클래스를 쓰지 않고 새로 만들어서 쓰는지 뒤이어서 상세하게 설명하겠습니다.

구글 사용자 정보가 업데이트 되었을 때를 대비하여 update 기능도 같이 구현되었습니다. 사용자의 이름이나 프로필 사진이 변경되면 User 엔티티에도 반영됩니다.

이제 OAuthAttributes 클래스를 생서해줍시다. Dto이기 때문에 auth패키지안에 dto 패키지를 만든뒤 안에 생성해줍시다.

OAuthAttributes 클래스 생성

@Getter
public class OAuthAttributes {
    private Map<String, Object> attributes;
    private String nameAttributeKey;
    private String name;
    private String email;
    private String picture;

    @Builder
    public OAuthAttributes(Map<String, Object> attributes,
                           String nameAttributeKey, String name,
                           String email, String picture) {
        this.attributes = attributes;
        this.nameAttributeKey= nameAttributeKey;
        this.name = name;
        this.email = email;
        this.picture = picture;
    }

    public static OAuthAttributes of(String registrationId,
                                     String userNameAttributeName,
                                     Map<String, Object> attributes) {
        return ofGoogle(userNameAttributeName, attributes);
    }

    private static OAuthAttributes ofGoogle(String userNameAttributeName,
                                            Map<String, Object> attributes) {
        return OAuthAttributes.builder()
                .name((String) attributes.get("name"))
                .email((String) attributes.get("email"))
                .picture((String) attributes.get("picture"))
                .attributes(attributes)
                .nameAttributeKey(userNameAttributeName)
                .build();
    }


    public User toEntity() {
        return User.builder()
                .name(name)
                .email(email)
                .picture(picture)
                .role(Role.GUEST)
                .build();
    }
}

 

• of()
  • OAuth2User에서 반환하는 사용자 정보는 Map이기 때문에 값 하나하나를 변환해야만 합니다.
• toEntity()
  • User 엔티티를 생성합니다.
  • OAuthAttributes에서 엔티티를 생성하는 시점은 처음 가입할 때입니다.
  • 가입할 때의 기본 권한을 GUEST로 주기 위해서 role 빌더값에는 Role.GUEST를 사용합니다.

 

SessionUser 클래스 생성

@Getter
public class SessionUser implements Serializable {
    private String name;
    private String email;
    private String picture;

    public SessionUser(User user) {
        this.name = user.getName();
        this.email = user.getEmail();
        this.picture = user.getPicture();
    }
}

SeesionUser에는 인증된 사용자 정보만 필요합니다. 

 

 

로그인 테스트

스프링 시큐리티가 잘 적용되었는지 확인하기 위해 화면에 로그인 버튼을 추가해보겠습니다.

index.mustache 코드 추가

{{>layout/header}}

    <h1>스프링부트로 시작하는 웹 서비스 Ver.2</h1>
    <div class="col-md-12">
        <div class="row">
            <div class="col-md-6">
                <a href="/posts/save" role="button" class="btn btn-primary">글 등록</a>
                {{#userName}}
                    Logged in as: <span id="user">{{userName}}</span>
                    <a href="/logout" class="btn btn-info active" role="button">Logout</a>
                {{/userName}}
                {{^userName}}
                    <a href="/oauth2/authorization/google" class="btn btn-success active" role="button">Google Login</a>
                {{/userName}}
            </div>
        </div>
        <br>
        <!-- 목록 출력 영역 -->
        <table class="table table-horizontal table-bordered">
            <thead class="thead-strong">
            <tr>
                <th>게시글번호</th>
                <th>제목</th>
                <th>작성자</th>
                <th>최종수정일</th>
            </tr>
            </thead>
            <tbody id="tbody">
            {{#posts}}
                <tr>
                    <td>{{id}}</td>
                    <td><a href="/posts/update/{{id}}">{{title}}</a></td>
                    <td>{{author}}</td>
                    <td>{{modifiedDate}}</td>
                </tr>
            {{/posts}}
            </tbody>
        </table>
    </div>

{{>layout/footer}}

• {{#userName}}
  
  • 머스테치는 다른 언어와 같은 if문을 제공하고 있습니다.
  • true/false 여부만 판단할 뿐입니다.
  • 그래서 머스테치에서는 항상 최종값을 넘겨줘야합니다.
  • 여기서도 역시 userName이 있다면 userName을 노출시키도록 구성했습니다.
• a href="/logout"
  • 스프링 시큐리티에서 기본적으로 제공하는 로그아웃 URL입니다.
  • 즉, 개발자가 별도로 저 URL에 해당하는 컨트롤러를 만들 필요가 없습니다.
  • securityConfig 클래스에서 URL을 변경할 순 있지만 기본 URL을 사용해도 충분하니 여기서는 그대로 사용합니다.
• {{^userName}}
  • 머스테치에서 해당 값이 존재하지 않는 경우에는 ^를 사용합니다.
  • 여기서는 userName이 없다면 로그인 버튼을 노출시키도록 구성했습니다.
• a href="/oauth2/authorization/google"
  • 스프링 시큐리티에서 기본적으로 제공하는 로그인 URL입니다.
  • 로그아웃 URL과 마찬가지로 개발자가 별도의 컨트롤러를 생성할 필요가 없습니다.

 

index.mustache에서 userName을 사용할 수 있게 IndexController에서 userName을 Model에 저장하는 코드를 추가합니다.

IndexController 코드 추가

public class IndexController {
    private final PostsService postsService;
    private final HttpSession httpSession;

    @GetMapping("/")
    public String index(Model model) {
        model.addAttribute("posts", postsService.findAllDesc());
        SessionUser user = (SessionUser) httpSession.getAttribute("user");

        if (user != null) {
            model.addAttribute("userName", user.getName());
        }
        return "index";
    }
    ...
}

• (SessionUser) httpSession.getAttribute("user")
  • 앞서 작성된 CustomOAuth2UserService에서 로그인 성공 시 세션에 SessionUser를 저장하도록 구성했습니다.
  • 즉, 로그인 성공 시 httpSession.getAttribute("user")에서 값을 가져올 수 있습니다.
• if(user != null)
  • 세션에 저장된 값이 있을 때만 model에 userName으로 등록됩니다.

 

그럼 한번 테스트해 봅시다.

로그인 된 정보는 세션에 저장되어있어 껐다가 다시 들어와도 로그인 상태가 유지됩니다. 로그아웃을 하면 세션 정보가 사라져서 더이상 로그인 정보를 갖고있지 않는 것을 테스트 할 수 있습니다.

 

h2-console을 통해 유저정보가 user 테이블에 저장되있는 모습도 볼 수 있습니다.

 

하지만, 글등록을 하려고하면 글등록을 할 수 없도록 에러가 나옵니다.

이유는 현재 로그인된 사용자의 권한은 GUEST입니다. 이 상태에서는 posts 기능을 전혀 쓸 수 없습니다. 위의 에러를 읽어보면 status가 403으로 권한이 거부된 것을 볼 수 있습니다.

 

그렇다면 권한을 변경해서 다시 해봅시다. h2-console로 가서 role을 USER로 변경해봅시다.

update user set role = 'USER';

 

세션에는 이미 GUEST인 정보로 저장되어있으니 로그아웃한 후 다시 로그인해서 글 등록을 해보겠습니다. 

권한을 부여해준 뒤 글 등록이 되는 모습을 볼 수 있습니다.

 

 

 

어노테이션 기반으로 개선하기

일반적인 프로그래밍에서 개선이 필요한 나쁜 코드 중 대표적인 것은 같은 코드가 반복되는 부분입니다. 같은 코드를 계속 복사 & 붙여넣기 하다보면 수정이 필요할 때 해당 부분들을 모두 수정해야되기 때문에 유지보수에 좋지 못하기 때문입니다. 

 

그럼 앞서 만든 코드에서 개선할만한 것은 무엇이 있을까요? 이동욱님은 IndexController에서 세션값을 가져오는 부분이라고 생각하고 있습니다.

SessionUser user = (SessionUser) httpSession.getAttribute("user");

index 메소드 외에 다른 컨트롤러와 메소드에서 세션값이 필요하면 그 때마다 직접 세션에서 값을 가져와야합니다. 그래서 이 부분을 메소드 인자로 세션값을 바로 받을 수 있도록 변경해보겠습니다.

config.auth 패키지에 @LoginUser 어노테이션을 생성합니다.

@LoginUser 어노테이션 생성

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginUser {
}

• @Target(ElementType.PARAMETER)
  • 이 어노테이션이 생성될 수 있는 위치를 지정합니다.
  • PARAMETER로 지정했으니 메소드의 파라미터로 선언된 객체에서만 사용할 수 있습니다.
  • 이 외에도 클래스 선언문에 쓸 수 있는 TYPE 등이 있습니다.
• @interface
  • 이 파일을 어노테이션 클래스로 지정합니다.
  • LoginUser라는 이름을 가진 어노테이션으로 생성되었다고 보면 됩니다.

그리고 같은 위치에 LoginUserArgumentResolver를 생성합니다. HandlerMethodArgumentResolver라는

인터페이스를 구현한 클래스입니다. HandlerMethodArgumentResolver는 한가지 기능을 지원합니다. 바로 조건에 맞는 경우 메소드가 있다면 HandlerMethodArgumentResolver의 구현체가 지정한 값으로 해당 메소드의 파라미터로 넘길 수 있습니다.

 

LoginUserArgumentReslover 클래스 생성

@RequiredArgsConstructor
@Component
public class LoginUserArgumentResolver implements HandlerMethodArgumentResolver {

    private final HttpSession httpSession;

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        boolean isLoginUserAnnotation = parameter.getParameterAnnotation(LoginUser.class) != null;
        boolean isUserClass = SessionUser.class.equals(parameter.getParameterType());
        return isLoginUserAnnotation && isUserClass;
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        return httpSession.getAttribute("user");
    }
}

• supportsParameter()
  • 컨트롤러 메서드의 특정 파라미터를 지원하는지 판단합니다.
  • 여기서는 파라미터에 @LoginUser 어노테이션이 붙어있고, 파라미터 클래스 타입이 SessionUser.class인 경우 true를 반환합니다.
• resolveArgument()
  • 파라미터에 전달할 객체를 생성합니다.
  • 여기서는 세션에서 객체를 가져옵니다.

@LoginUser를 사용하기 위한 환경은 구성되었습니다. 

 

이제 스프링에서 인식될 수 있도록 WebMvcConfigurer에 추가해줍시다. config 패키지에 WebConfig클래스를 생성합시다.

WebConfig 클래스 생성

@RequiredArgsConstructor
@Configuration
public class WebConfig implements WebMvcConfigurer {
    private final LoginUserArgumentResolver loginUserArgumentResolver;

    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        argumentResolvers.add(loginUserArgumentResolver);
    }
}

 

HandlerMethodArgumentResolver는 항상 WebMvcConfigurer의 addArgumentResolvers()를 통해 추가해야 합니다. 

 

모든 설정이 끝났으니 IndexController의 코드에서 반복되는 부분들을 모두 @LoginUser로 개선합시다.

IndexController 메서드 변경

    @GetMapping("/")
    public String index(Model model, @LoginUser SessionUser user) {
        model.addAttribute("posts", postsService.findAllDesc());
        if (user != null) {
            model.addAttribute("userName", user.getName());
        }
        return "index";
    }

• @LoginUser SessionUser user
  • 기존에 httpSession.getAttribute("user")로 가져오던 세션 정보 값이 개선되었습니다.
  • 이제는 어느 컨트롤러든지 @LoginUser만 사용하면 세션 정보를 가져올 수 있게 되었습니다.

 

 

 

세션 저장소로 데이터베이스 사용하기

현재 만든 서비스는 애플리케이션을 재실행하면 로그인이 풀립니다. 이는 세션이 내장 톰캣의 메모리에 저장되기 때문입니다. 기본적으로 세션은 실행되는 WAS의 메모리에서 저장되고 호출됩니다. 메모리에 저장되다 보니 내장 톰캣처럼 애플리케이션 실행 시 실행되는 구조에선 항상 초기화가 됩니다. 즉, 배포할 때마다 톰캣이 재시작되는 것 입니다. 

 

이 외에도 한 가지 더 문제가 있는데, 2대 이상의 서버에서 서비스하고 있다면 톰캣마다 세션 동기화 설정을 해야만 합니다. 그래서 실제 현업에서는 세션 저장소에 대해 다음의 3가지 중 한 가지를 선택합니다.

1. 톰캣 세션을 사용한다.
   • 일반적으로 별다른 설정을 하지 않을 때 기본적으로 선택되는 방식입니다.
   • 이렇게 될 경우 톰캣(WAS)에 세션이 저장되기 때문에 2대 이상의 WAS가 구동되는 환경에서는 톰캣들 간의 세션 공유를 위한 추가 설정이 필요합니다.
2. MySQL과 같은 데이터베이스를 세션 저장소로 사용합니다.
   • 여러 WAS 간의 공용 세션을 사용할 수 있는 가장 쉬운 방법입니다.
   • 많은 설정이 필요 없지만, 결국 로그인 요청마다 DB IO가 발생하여 성능상 이슈가 발생할 수 있습니다.
   • 보통 로그인 요청이 많이 없는 백오피스, 사내 시스템 용도에서 사용합니다.
3. Redis, Memcached와 같은 메모리 DB를 세션 저장소로 사용합니다.
   • B2C 서비스에서 가장 많이 사용하는 방식입니다.
   • 실제 서비스로 사용하기 위해서는 Embedded Redis와 같은 방식이 아닌 외부 메모리 서버가 필요합니다.

여기서는 두 번째 방식인 데이터베이스를 세션 저장소로 사용하는 방식을 선택하여 진행하겠습니다. 선택한 이유는 설정이 간단하고 사용자가 많은 서비스가 아니며 비용 절감을 위해서입니다. 

 

이후 AWS에서 이 서비스를 배포하고 운영할 때를 생각하면 레디스와 같은 메모리 DB를 사용하기는 부담스럽습니다. 왜냐하면, 레디스와 같은 서비스(엘라스틱 캐시)에 별도로 사용료를 지불해야 하기 때문입니다. 

 

 

spring-session-jdbc 등록

build.gradle에 아래와 같이 의존성을 등록합니다. 

implementation('org.springframework.session:spring-session-jdbc')

그리고 application.properties에 세션 저장소를 Jdbc로 선택하도록 코드를 추가합시다.

spring.session.store-type=jdbc

모두 변경하였으니 다시 애플리케이션을 실행해서 로그인을 테스트한 뒤, h2-console로 접속해봅시다.

 

h2-console을 보면 세션을 위한 테이블 2개(SPRING_SESSION, SPRING_SESSION_ATTRIBUTES)가 생성된 것을 볼 수 있습니다. JPA로 인해 세션 테이블이 자동 생성되었기 때문에 별도로 해야 할 일은 없습니다. 

로그인을 해주니 세션 테이블에 값이 추가된 것을 볼 수 있습니다.

 

물론 지금은 기존과 동일하게 스프링을 재시작하면 세션이 풀립니다. 이유는 H2 기반으로 스프링이 재실행될 때 H2도 재시작되기 때문입니다. 이후 AWS로 배포하게 되면 AWS의 데이터베이스 서비스인 RDS(Relation Database Service)를 사용하게 되니 읻대부터는 세션이 풀리지 않습니다. 그 기반이 되는 코드를 작성한 것이니 걱정하지 마시길 바랍니다.

 

 

 

네이버 로그인

구글과 같이 네이버로도 로그인할 수 있게 해줍시다!

 

 

네이버 API 등록

먼저 네이버 오픈 API로 이동합니다.

https://developers.naver.com/apps/#/register?api=nvlogin

 

위처럼 만든 후, application-oauth.properties에 등록합시다. 네이버에서는 스프링 시큐리티를 공식 지원하지 않기 때문에 그동안 Common-OAuth2Provider에서 해주던 값들도 전부 수동으로 입력해야 합니다.
application-oauth.properties 코드 추가

# registration
spring.security.oauth2.client.registration.naver.client-id=네이버클라이언트ID
spring.security.oauth2.client.registration.naver.client-secret=네이버클라이언트시크릿
spring.security.oauth2.client.registration.naver.redirect-uri={baseUrl}/{action}/oauth2/code/{registrationId}
spring.security.oauth2.client.registration.naver.authorization-grant-type=authorization_code
spring.security.oauth2.client.registration.naver.scope=name,email,profile_image
spring.security.oauth2.client.registration.naver.client-name=Naver

# provider
spring.security.oauth2.client.provider.naver.authorization-uri=https://nid.naver.com/oauth2.0/authorize
spring.security.oauth2.client.provider.naver.token-uri=https://nid.naver.com/oauth2.0/token
spring.security.oauth2.client.provider.naver.user-info-uri=https://openapi.naver.com/v1/nid/me
spring.security.oauth2.client.provider.naver.user-name-attribute=response

• user_name_attribute=response
  • 기준이 되는 user_name의 이름을 네이버에서는 response로 해야합니다.
  • 이유는 네이버의 회원 조회 시 반환되는 JSON 형태 때문입니다.

네이버 오픈 API의 로그인 회원 결과는 아래와 같습니다.

{
    "resultcode" : "00",
    "message: : "success",
    "response" : {
        "email" : "openapi@naver.com",
        ...
    }
}

스프링 시큐리티에선 하위필드를 명시할 수 없습니다. 최상위 필드들만 user_name으로 지정 가능합니다. 하지만 네이버의 응답값 최상위필드는 resultcode, message, response입니다. 이러한 이유로 3개 중에 골라야합니다. 본문에서 담고있는 response를 user_name으로 지정하고 이후 자바 코드로 response의 id를 user_name으로 지정하겠습니다. 

 

 

스프링 시큐리티 설정 등록

구글 로그인을 등록하면서 대부분 코드를 확장성 있게 작성했다보니 네이버는 쉽게 등록 가능합니다. OAuthAttributes에 아래와 같이 네이버인지 판단하는 코드와 네이버 생성자만 추가해주면됩니다.

OAuthAttributes 메소드 수정, 추가

    public static OAuthAttributes of(String registrationId,
                                     String userNameAttributeName,
                                     Map<String, Object> attributes) {
        if("naver".equals(registrationId)) {
            return ofNaver("id", attributes);
        }

        return ofGoogle(userNameAttributeName, attributes);
    }

    private static OAuthAttributes ofNaver(String userNameAttributeName,
                                           Map<String, Object> attributes) {
        Map<String, Object> response = (Map<String, Object>) attributes.get("response");

        return OAuthAttributes.builder()
                .name((String) response.get("name"))
                .email((String) response.get("email"))
                .picture((String) response.get("profile_image"))
                .attributes(response)
                .nameAttributeKey(userNameAttributeName)
                .build();
    }

 

마지막으로 index.mustache에 네이버 로그인 버튼을 추가합니다. 

<a href="/oauth2/authorization/naver" class="btn btn-secondary active" role="button">Naver Login</a>

• /oauth2/authorization/naver
  • 네이버 로그인 URL은 application-oauth.properties에 등록한 redirect-uri 값에 맞춰 자동으로 등록됩니다.
  • /oauth2/authorization/ 까지는 고정이고 마지막 path만 각 소셜 로그인 코드를 사용하면 됩니다.

 

 

네이버 로그인까지 성공했습니다.

 

 

 

기존 테스트에 시큐리티 적용하기

마지막으로 기존 테스트에 시큐리티 적용으로 문제가 되는 부분들을 해결해보겠습니다. 문제가 되는 부분들은 대표적으로 아래와 같은 이유 때문입니다.

기존에 바로 API를 호출할 수 있어 테스트 코드 역시 바로 API를 호출하도록 구성하였습니다. 하지만, 시큐리티 옵션이 활성화되면 인증된 사용자만 API를 호출할 수 있습니다. 기존의 API 테스트 코드들이 모두 인증에 대한 권한을 받지 못하였으므로, 테스트 코드마다 인증한 사용자가 호출한 것처럼 작동하도록 수정해봅시다.

 

문제 1. CustomOAuth2UserService 찾을 수 없음

CustomOAuth2UserService를 생성하는데 필요한 소셜 로그인 관련 설정값들이 없기 때문에 발생합니다. 난 분명히 application-oauth.properties를 추가했는데 왜 이런 설정값들이 없다고 할까요???

이는 src/main 환경과 src/test 환경의 차이 때문이라고 합니다.  둘은 본인만의 환경 구성을 가집니다. 다만, application.properties가 테스트 코드 수행할 때도 적용되는 이유는 test에 application.properties가 없으면 main의 설정을 그대로 가져오기 때문입니다. 다만, 자동으로 가져오는 옵션의 범위는 application.properties 파일 까지입니다. 

 

이 문제를 해결하기 위해 테스트 환경을 위한 application.properties를 만들어 봅시다. 실제 구글 연동까지 하는 테스트코드는 없기 때문에 가짜 설정값을 등록합니다.

spring.jpa.show_sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
spring.h2.console.enabled=true
spring.session.store-type=jdbc

# Test OAuth

spring.security.oauth2.client.registration.google.client-id=test
spring.security.oauth2.client.registration.google.client-secret=test
spring.security.oauth2.client.registration.google.scope=profile,email

해당 application.properties를 추가하면 7개이던 error가 4개로 줄어들 것 입니다.

 

 

문제 2. 302 Status Code

Posts_등록된다 테스트 로그를 확인해보면 302(리다이렉션 응답) Status Code가 옵니다. 이는 스프링 시큐리티 설정 때문에 인증되지 않은 사용자의 요청은 이동시키기 때문입니다. 그래서 이런 API 요청은 임의로 인증된 사용자를 추가하여 API만 테스트해 볼 수 있게 합시다.

 

스프링 시큐리티 테스트를 위한 여러 도구를 지원하는 spring-security-test를 build.gradle에 추가합니다. 

testImplementation("org.springframework.security:spring-security-test")

 

그리고 PostsApiControllerTest의 2개의 테스트 메소드에 아래와 같이 임의 사용자 인증을 추가합니다.

    @Test
    @WithMockUser(roles="USER")
    public void Posts_등록된다() throws Exception { }
    
    @Test
    @WithMockUser(roles="USER")
    public void Posts_수정된다() throws Exception {}

• @WithMockUser(roles="USER")
  • 인증된 모의 사용자를 만들어서 사용합니다.
  • roles에 권한을 추가할 수 있습니다.
  • 즉, 이 어노테이션으로 인해 ROLE_USER권한을 가진 사용자가 API를 요청하는 것과 동일한 효과를 가집니다.

이정도만하면 될 것 같지만, 실제로 작동하지 않습니다. @WithMockUser가 MockMvc에서만 작동하기 때문입니다. 현재 PostsApiControllerTest는 @SpringBootTest로만 되어있으며 MockMvc를 전혀 사용하지 않습니다. 그래서 @SpringBootTest에서 MockMvc를 사용하는 방법을 알아봅시다. 코드를 아래와 같이 변경합니다.

package com.qazyj.book.springboot.web;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qazyj.book.springboot.domain.posts.Posts;
import com.qazyj.book.springboot.domain.posts.PostsRepository;
import com.qazyj.book.springboot.web.dto.PostsSaveRequestDto;
import com.qazyj.book.springboot.web.dto.PostsUpdateRequestDto;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.http.*;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class PostsApiControllerTest {

    @LocalServerPort
    private int port;

    @Autowired
    private TestRestTemplate restTemplate;

    // 추가 MockMvc
    @Autowired
    private PostsRepository postsRepository;

    @Autowired
    private WebApplicationContext context;

    private MockMvc mvc;

    @Before
    public void setup() {
        mvc = MockMvcBuilders
                .webAppContextSetup(context)
                .apply(springSecurity())
                .build();
    }

    @After
    public void tearDown() throws Exception {
        postsRepository.deleteAll();
    }

    @Test
    @WithMockUser(roles="USER")
    public void Posts_등록된다() throws Exception {
        //given
        String title = "title";
        String content = "content";
        PostsSaveRequestDto requestDto = PostsSaveRequestDto.builder()
                .title(title)
                .content(content)
                .author("author")
                .build();

        String url = "http://localhost:" + port + "/api/v1/posts";

        //when
        // mvc로 수정 
        mvc.perform(post(url)
                        .contentType(MediaType.APPLICATION_JSON_UTF8)
                        .content(new ObjectMapper().writeValueAsString(requestDto)))
                .andExpect(status().isOk());

        //then
        List<Posts> all = postsRepository.findAll();
        assertThat(all.get(0).getTitle()).isEqualTo(title);
        assertThat(all.get(0).getContent()).isEqualTo(content);
    }

    @Test
    @WithMockUser(roles="USER")
    public void Posts_수정된다() throws Exception {
        //given
        Posts savedPosts = postsRepository.save(Posts.builder()
                .title("title")
                .content("content")
                .author("author")
                .build());

        Long updateId = savedPosts.getId();
        String expectedTitle = "title2";
        String expectedContent = "content2";

        PostsUpdateRequestDto requestDto = PostsUpdateRequestDto.builder()
                .title(expectedTitle)
                .content(expectedContent)
                .build();

        String url = "http://localhost:" + port + "/api/v1/posts/" + updateId;

        //when
        mvc.perform(put(url)
                        .contentType(MediaType.APPLICATION_JSON_UTF8)
                        .content(new ObjectMapper().writeValueAsString(requestDto)))
                .andExpect(status().isOk());

        //then
        List<Posts> all = postsRepository.findAll();
        assertThat(all.get(0).getTitle()).isEqualTo(expectedTitle);
        assertThat(all.get(0).getContent()).isEqualTo(expectedContent);
    }
}

• @Before
  • 매번 테스트가 시작되기전에 MockMvc 인스턴스를 생성합니다.
• mvc.perform
  • 생성된 MockMvc를 통해 API를 테스트 합니다.
  • 본문(Body) 영역은 문자열로 표현하기 위해 ObjectMapper를 통해 문자열 JSON으로 변환합니다.

그리고 전체 테스트를 해봅시다. 2개의 에러만 남게 됩니다.

 

 

문제 3 @WebMvcTest에서 CustomOAuth2UserService를 찾을 수 없음

@WebMvcTest는 CustomOAuth2UserService를 스캔하지 않기 때문에 에러가 발생합니다. @WebMvcTest는 WebSecurityConfigurerAdapter, WebMvcConfigurer를 비롯한 @ControllerAdvice, @Controller를 읽습니다. 즉, @Repository, @Service, @Component는 스캔 대상이 아닙니다. 그렇기 때문에 SecurityConfig를 읽었지만, SecurityConfig를 생성하기 위해 필요한 CustomOAuth2UserService는 읽을 수가 없어서 에러가 발생한 것 입니다. 

 

아래와 같이 스캔 대상에서 SecurityConfig를 제거해줍시다.

@WebMvcTest(controllers = HelloController.class,
        excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = SecurityConfig.class)
        }
)

그리고 마찬가지로 @WithMockUser를 사용해서 가짜로 인증된 사용자를 생성해줍시다.

    @WithMockUser(roles="USER")
    @Test
    public void hello가_리턴된다() throws Exception {}
    
    @WithMockUser(roles="USER")
    @Test
    public void helloDto가_리턴된다() throws Exception {}

이렇게 한 뒤 테스트를 돌려보면 추가에러가 발생합니다.

 

이 에러는 @EnableJpaAuditing으로 인해 발생합니다. @EnableJpaAuditing를 사용하기 위해선 최소 하나의 @Entity 클래스가 필요합니다. @WebMvcTest이다 보니 당연히 없습니다.

 

@EnableJpaAuditing가 @SpringBootApplication과 함께 있다보니 @WebMvcTest에서도 스캔하게 되었습니다. 그래서 @EnableJpaAuditing과 @SpringBootApplication 둘을 분리하겠습니다. Application.java에서 @EnableJpaAuditing를 제거해줍시다.

 

그리고 config 패키지에 JpaConfig를 생성하여 @EnableJpaAuditing을 추가합니다.

 

그런뒤 돌려보면 모든 테스트가 정상적으로 완료됩니다.

 

 

 

 

 

 

출처

스프링 부트와 AWS로 혼자 구현하는 웹 서비스 - YES24