[Spring Boot & AWS] Chpt 5 - 스프링 시큐리티와 OAuth 2.0으로 로그인 기능 구현하기

이 글은 이동욱 님의 스프링 부트와 AWS로 혼자 구현하는 웹 서비스를 읽고 정리한 글입니다.

스프링 시큐리티는 강력한 인증과 인가 기능을 가진 프레임워크로, 사실상 스프링 기반 애플리케이션 보안을 위한 표준으로 볼 수 있다. 인터셉터나 필터를 기반으로 한 보안 기능을 구현하는 것보단 스프링 시큐리티를 통해 구현하는 것을 적극적으로 권장하고 있다.

이번 장에서는 스프링 시큐리티와 OAuth 2.0을 구현한 구글 로그인을 연동하여 로그인 기능을 만들어 보겠다.

1. 스프링 시큐리티와 스프링 시큐리티 OAuth2 클라이언트

많은 서비스에서 로그인 기능을 새로운 id/password를 만드는 방식보다는 구글, 페이스북, 네이버 로그인 등의 소셜 로그인 기능을 사용한다. 이는 배보다 배꼽이 커지는 경우를 방지하기 위해서로 볼 수 있다.

직접 구현해야 하는 경우 다음을 모두 구현해야 한다. (당연히 OAuth를 써도 구현해야 하는 것은 제외)

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

OAuth를 사용하여 로그인을 구현하면 위의 것들을 모두 구글, 페이스북, 네이버 등에 맡기면 되니, 서비스 개발에 몰두할 수 있다.

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

스프링 부트 1.5에서의 OAuth2 연동 방법이 2.0에서는 크게 변경되었다. 하지만 spring-security-oauth2-autoconfigure 라이브러리 덕분에 설정 방법에 크게 차이가 없다. 이 라이브러리를 사용함으로써 스프링 부트 2.0에서도 1.5에서 사용한 설정을 그대로 사용할 수 있다. 새로운 코드를 작성하는 것보다 기존에 안전하게 작동하는 코드를 사용하는 것이 아무래도 더 확실하기 때문에 많은 개발자들이 이 방식을 사용해 왔다.

하지만 이 책에서는 다음과 같은 이유로 스프링 부트 2.0의 방식인 Spring Security Oauth2 Clinet 라이브러리를 사용한다.

스프링 팀에서 신규 기능은 새 OAuth2 라이브러리에서만 지원하겠다고 선언함
스프링 부트용 라이브러리(starter) 출시됨
기존의 방식은 확장 포인트가 적절하게 오픈되지 않아 직접 상속하거나 오버라이딩 해야 하지만, 신규 라이브러리는 확장 포인트를 고려하여 설계됨

또한 스프링 부트 1.5 방식에서는 url 주소를 모두 명시해야 하지만, 2.0 방식에서는 clinet 인증 정보만 입력하면 된다.

1.5 버전에서 직접 입력했던 값들은 모두 2.0 버전에서 CommonOAuth2Provider라는 enum으로 대체되었다.

2. 구글 서비스 등록

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

구글 클라우드 플랫폼 주소(https://console.cloud.google.com/)로 이동한다.

로그인과 결제 등록 후, 새 프로젝트를 생성 후 다음과 같이 API 및 서비스 대시보드로 접속한다.

사이드바 중간에 있는 사용자 인증 정보 탭에서 새로운 사용자 인증 정보를 만든다. 여러 메뉴 중 OAuth 클라이언트 ID를 선택하여 동의 화면 구성을 마친다.

동의 화면 구성을 마쳤다면 화면 제일 아래에 저장 버튼을 클릭한 후, OAuth 클라이언트 ID 만들기 화면으로 바로 이동한다.

그 후 다음과 같이 설정하고 저장 버튼을 클릭하면 아래와 같이 인증 정보를 확인할 수 있다.

생성된 애플리케이션을 클릭하면 나오는 clientId와 clientSecret 코드를 프로젝트에서 설정하자.

1) application-oauth 등록

4장에서 만들었던 src/main/resources 디렉토리에 application-oauth.properties 파일을 생성한다.

// application-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

많은 다른 예제에서는 굳이 마지막의 scope를 등록하지 않는다. 기본 값이 openid, profile, email이기 때문인데 강제로 profile, email만 등록한 이유는 openid라는 scope가 존재하게 되면 Open Id Provider로 인식하기 때문이다.

이렇게 되면 Open Id Provider(구글)과 그렇지 않은 서비스들(네이버/카카오 등)로 나눠서 각각 OAuth2Service를 만들어야 한다. 하나로 사용하기 위해서 일부러 openid를 제외하고 등록한다.

스프링 부트 기본 설정 파일인 application.properties가 application-oauth.properties를 포함하도록 아래와 같이 코드를 추가한다.

// application.properties
spring.profiles.include=oauth

2) .gitignore 등록

구글 로그인을 위한 clientId와 clientSecret은 보안에 중요한 정보들이다. 그렇기 때문에 이들이 외부에 유출되면 언제든지 개인 정보를 가져갈 수 있는 취약점이 될 수 있다. 따라서 깃허브에 application-oauth.properties 파일이 올라가는 것을 방지해야 한다.

.gitignore에 다음 코드를 추가한다.

// .gitignore
application-oauth.properties

3. 구글 로그인 연동하기

1) User 엔티티 코드 작성

사용자 정보를 담당할 도메인인 User 클래스를 생성한다. 패키지 domain 아래에 user 패키지를 생성한다.

// User.java
package com.cotato.study.SpringnAWS.domain.user;

import com.cotato.study.SpringnAWS.domain.posts.BaseTimeEntity;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;

import javax.persistence.*;

@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) // Enum값을 default인 int가 아닌 문자열로 저장될 수 있도록 선언
    @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();
    }
}

사용자의 권한을 관리할 Enum 클래스 Role을 생성하자.

// Role.java
package com.cotato.study.SpringnAWS.domain.user;

import lombok.Getter;
import lombok.RequiredArgsConstructor;

@Getter
@RequiredArgsConstructor
public enum Role {
    GUEST("ROLE_GUEST", "손님"),
    USER("ROLE_USER", "일반 사용자");

    private final String key;
    private final String title;
}

스프링 시큐리티에서는 권한 코드에 항상 ROLE_이 앞에 있어야만 한다. 그래서 위와 같이 지정하였다. 마지막으로 User의 CRUD를 책임질 UserRepository도 생성한다.

// UserRepository.java
package com.cotato.study.SpringnAWS.domain.user;

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface UserRepository extends JpaRepository<User, Long> {

    // 소셜 로그인으로 반환되는 값 중 email을 통해 이미 생성된 사용자인지 판단하기 위한 메서드
    Optional<User> findByEmail(String email);
}

User 엔티티 관련 코드를 모두 작성하였으니 이제 시큐리티 설정을 진행하겠다.

2) 스프링 시큐리티 설정

먼저 build.gradle에 다음과 같은 시큐리티 관련 의존성을 하나 추가한다.

// build.gradle
compile('org.springframework.boot:spring-boot-starter-oauth2-client') // 소셜 로그인 등 소셜 기능 구현 시 필요한 의존성

※ 뒤에 나올 CustomOAuth2UserService.java 코드 작성 중 SimpleGrantedAuthority를 불러오지 못하는 오류가 발생하였다. 이를 해결하기 위해 아래 코드도 build.gradle에 추가하도록 하자.

// build.gradle
implementation 'org.springframework.boot:spring-boot-starter-security'

그 후 config.auth 패키지를 생성한다. 앞으로 시큐리티 관련 클래스는 모두 여기에 담을 것이다. 이 패키지에 SecurityConfig 클래스를 생성한다.

//SecurityConfig.java
package com.cotato.study.SpringnAWS.config.auth;

import com.cotato.study.SpringnAWS.domain.user.Role;
import lombok.RequiredArgsConstructor;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@RequiredArgsConstructor
@EnableWebSecurity // Spring Security 설정들을 활성화
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    private final CustomOAuth2UserService customOAuth2UserService;

    @Override
    protected void configure(HttpSecurity http) throws Exception{
        http.csrf().disable()
                .headers().frameOptions().disable() // h2-console 화면을 사용하기 위해 해당 옵션들을 disable
                .and()
                .authorizeRequests() // URL별 권한 관리를 설정하는 옵션의 시작점, antMather 옵션을 사용하기 위한 필수 조건
                // antMatchers는 권한 관리 대상을 지정하는 옵션
                .antMatchers("/","/css/**","/images/**","/js/**","/h2-console/**","/profile") // "/", "/css" 등은
                .permitAll() // 전체 열람 권한
                .antMatchers("/api/v1/**").hasRole(Role.USER.name()) // "/api/v1/**" 주소를 가진 API는
                .anyRequest().authenticated() // USER 권한을 가진 사람만 가능
                .and()
                .logout() // 로그아웃 기능에 대한 여러 설정의 진입점
                .logoutSuccessUrl("/") // 로그아웃 성공 시에 "/" 주소로 이동
                .and()
                .oauth2Login() // OAuth2 로그인 기능에 대한 여러 설정의 진입점
                .userInfoEndpoint() // OAuth2 로그인 성공 이후 사용자 정보를 가져올 때의 설정을 담당
                .userService(customOAuth2UserService); // 소셜 로그인 성공 시 후속 조치를 시행할 UserService의 구현체를 등록
    }
}

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

// CustomOAuth2UserService.java
package com.cotato.study.SpringnAWS.config.auth;

import com.cotato.study.SpringnAWS.config.auth.dto.OAuthAttributes;
import com.cotato.study.SpringnAWS.config.auth.dto.SessionUser;
import com.cotato.study.SpringnAWS.domain.user.User;
import com.cotato.study.SpringnAWS.domain.user.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.oauth2.client.userinfo.DefaultOAuth2UserService;
import org.springframework.security.oauth2.client.userinfo.OAuth2UserRequest;
import org.springframework.security.oauth2.client.userinfo.OAuth2UserService;
import org.springframework.security.oauth2.core.OAuth2AuthenticationException;
import org.springframework.security.oauth2.core.user.DefaultOAuth2User;
import org.springframework.security.oauth2.core.user.OAuth2User;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpSession;
import java.util.Collections;

@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(); // OAuth2 로그인 시 키가 되는 필드값(PK)

        OAuthAttributes attributes = OAuthAttributes.
                of(registrationId, userNameAttributeName,
                        oAuth2User.getAttributes()); // OAuth2UserService를 통해 가져온 OAuth2User의 attribute를 담을 클래스

        User user = saveOrUpdate(attributes);

        httpSession.setAttribute("user", new
                SessionUser(user)); // 세션에 사용자 정보를 저장하기 위한 Dto 클래스

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

구글 사용자 정보가 업데이트되었을 때를 대비하여 update 기능도 같이 구현하였다. 사용자의 name, picture가 변경되면 User 엔티티에도 반영된다.

CustomOAuth2UserService 클래스까지 생성되었다면 OAuthAttributes 클래스도 생성한다. 저자는 OAuthAttributes도 Dto로 보기 때문에, 이를 config.auth.dto 패키지에 생성했다.

// OAuthAttributes.java
package com.cotato.study.SpringnAWS.config.auth.dto;

import com.cotato.study.SpringnAWS.domain.user.Role;
import com.cotato.study.SpringnAWS.domain.user.User;
import lombok.Builder;
import lombok.Getter;

import java.util.Map;

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

    // OAuth2User에서 반환하는 사용자 정보는 Map이기 때문에 값 하나하나를 변환해야 함
    public static OAuthAttributes of(String registrationId, 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();
    }

    // User 엔티티를 처음 가입할 때 생성하고, 기본 권한은 GUEST로 함
    public User toEntity() {
        return User.builder()
                .name(name)
                .email(email)
                .picture(picture)
                .role(Role.GUEST)
                .build();
    }
}

같은 config.auth.dto 패키지에 SessionUser 클래스도 추가한다.

// SessionUser.java
package com.cotato.study.SpringnAWS.config.auth.dto;

import com.cotato.study.SpringnAWS.domain.user.User;
import lombok.Getter;

import java.io.Serializable;

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

SessionUser에는 인증된 사용자 정보만 필요하다. 그 외에는 필요한 정보가 없으니 name, email, picture만 필드로 선언하도록 하자.

그런데 SessionUser 대신 전에 만들었던 User를 사용해도 되지 않나라는 의문이 들 수도 있다. 만약 User를 그대로 사용했다면, 직렬화를 구현하지 않았다는 내용의 오류가 발생한다. 그럼 이를 해결하기 위해 User 클래스에 직렬화 코드를 넣게 된다면 어떻게 될까?

User 클래스는 엔티티이기 때문에 다른 엔티티들과 언제 어디서 새로운 관계를 형성할지 모른다. 만약 자식 엔티티를 갖게 된다면 직렬화 대상에 자식 엔티티까지 포함되니 성능 이슈와 부수 효과가 발생할 확률이 높다.

그래서 직렬화 기능을 가지고 있는 새로운 세션 Dto를 추가로 만드는 것이 운영 및 유지 보수에 도움이 된다.

시큐리티 설정이 끝났으니 이제 로그인 기능을 테스트하자.

3) 로그인 테스트

로그인 테스트를 위해서 화면에 로그인 버튼을 추가해 보겠다. index.mustache에 로그인 버튼과 로그인 성공 시 사용자 이름을 보여주는 코드를 추가한다.

{{!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}} {{!userName이 존재하면 userName이 노출되도록 구성}}
                    Logged in as : <span id="user">{{userName}}</span>
                    <a href="/logout" class="btn btn-info active"
                       role="button">Logout</a> {{!스프링 시큐리티에서 기본적으로 제공하는 로그아웃 URL}}
                {{/userName}}
                {{^userName}} {{!userName이 없다면 로그인 버튼 노출되도록 구성}}
                    <a href="/oauth2/authorization/google" {{!스프링 시큐리티에서 기본적으로 제공하는 로그인 URL}}
                       class="btn btn-success active" role="button">Google Login</a>
                {{/userName}}
            </div>
        </div>
        <br>
        {{!목록 출력 영역}}
        
        ...

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

// IndexController.java

...

@RequiredArgsConstructor
@Controller
public class IndexController {
    private final PostsService postsService;
    private final HttpSession httpSession;

    @GetMapping("/")
    public String index(Model model) {
        model.addAttribute("posts", postsService.findAllDesc());
        // 로그인 성공 시 httpSession.getAttribute("user") 에서 값 가져옴
        SessionUser user = (SessionUser) httpSession.getAttribute("user");

        if (user != null) {	// session에 저장된 값이 있을 때만 model에 userName으로 등록
            model.addAttribute("userName", user.getName());
        }
        return "index";
    }
    
    ...

프로젝트를 실행해서 다음과 같이 Google Login 버튼이 잘 노출되는지 확인한다.

버튼을 클릭해 보면 다른 서비스에서도 볼 수 있던 것처럼 구글 로그인 동의 화면으로 이동한다.

로그인을 하고 나면 구글 계정에 등록된 이름이 화면에 노출됨을 확인할 수 있다.

이제 데이터베이스에 정상적으로 회원 정보가 들어갔는지 확인해 보자.

다음으로 권한 관리가 잘 되는지 확인해 보자. 현재 로그인 한 사용자는 GUEST이기 때문에 posts 기능을 쓸 수 없다. 실제로 글 등록 기능을 사용하면 아래와 같이 403(권한 거부) 에러가 발생한다.

그럼 권한 변경을 해서 다시 시도해 보자. 먼저 h2-console에 가서 사용자의 role을 USER로 변경한다.

update user set role = 'USER';

세션에는 이미 GUEST로 저장되어 있으므로 로그아웃 한 후 다시 로그인하여 세션 정보를 최신화한 후 글 등록을 다시 시도해 보면 정상적으로 글이 등록됨을 확인할 수 있다.

기본적인 구글 로그인, 로그아웃, 회원가입, 권한 관리 기능이 모두 구현되었다.

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

일반적으로 우리는 반복적으로 같은 코드가 나타나는 부분들을 개선이 필요한 나쁜 코드라고 할 수 있다.

같은 코드를 계속해서 복사와 붙여 넣기로 반복하게 만든다면 이후에 수정이 필요할 때 모든 부분을 하나씩 찾아가며 수정해야 한다. 이렇게 하면 유지보수성이 떨어질 수밖에 없으며, 혹시나 수정이 하나라도 반영되지 않았다면 문제가 발생하게 된다.

그럼 앞서 만든 코드에서 개선할 부분은 없을까? 저자는 IndexController에서 세션값을 가져오는 부분을 개선할 수 있다고 생각했다.

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

index 메서드 외에 다른 컨트롤러와 메서드에서 세션값이 필요하다면 그때마다 직접 세션에서 값을 가져와야 한다.

이 부분이 반복되는 것은 불필요하므로, 메서드 인자로 세션값을 바로 받아오도록 변경해 보겠다.

1) @LoginUser 어노테이션 생성

config.auth 패키지에 다음과 같이 @LoginUser 어노테이션을 생성한다.

// LoginUser.java
package com.cotato.study.SpringnAWS.config.auth;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.PARAMETER) // 이 어노테이션이 생성될 수 있는 위치를 메서드의 파라미터로 선언된 객체로 한정
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginUser { // 어노테이션 클래스로 지정, @LoginUser라는 어노테이션이 생성됨
}

그리고 같은 위치에 LoginUserArgumentResolver를 생성한다.

LoginUserArgumentResolver는 HandlerMethodArgumentResolver 인터페이스를 구현한 클래스이다.

조건에 맞는 경우 메서드가 있다면 구현체가 지정한 값으로 해당 메서드의 파라미터로 넘기는 기능을 가진다.

// LoginUserArgumentResolver.java
package com.cotato.study.SpringnAWS.config.auth;

import com.cotato.study.SpringnAWS.config.auth.dto.SessionUser;
import lombok.RequiredArgsConstructor;
import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

import javax.servlet.http.HttpSession;

@RequiredArgsConstructor
@Component
public class LoginUserArgumentResolver implements HandlerMethodArgumentResolver {
    private final HttpSession httpSession;

    @Override
    public boolean supportsParameter(MethodParameter 
                                                 parameter){ // 컨트롤러 메서드의 특정 파라미터를 지원하는지 판단
        boolean isLoginUserAnnotation = parameter
                .getParameterAnnotation(LoginUser.class) != null; // 파라미터에 @LoginUser 어노테이션이 붙어있고
        boolean isUserClass = SessionUser.class
                .equals(parameter.getParameterType()); // 파라미터 클래스 타입이 SessionUser인 경우
        return isLoginUserAnnotation && isUserClass; // True 반환
    }

    @Override // 파라미터에 전달할 객체를 생성
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        return httpSession.getAttribute("user"); // 세션에서 객체를 가져옴
    }
}

이렇게 @LoginUser를 사용하기 위한 환경은 구성되었다. 이제 생성한 LoginUserArgumentResolver가 스프링에서 인식될 수 있도록 WebMvcConfigurer에 추가하겠다. config 패키지에 WebConfig 클래스를 생성하자.

// WebConfig.java
package com.cotato.study.SpringnAWS.config;

import com.cotato.study.SpringnAWS.config.auth.LoginUserArgumentResolver;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.List;

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

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

HandlerMethodArgumentResolver는 항상 WebMvcConfigurer의 addArgumentResolver()를 통해 추가해야 한다.

다른 HandlerMethodArgumentResolver가 필요하게 된다면 같은 방식으로 추가해 주자.

2) @LoginUser 어노테이션 사용

모든 설정을 마쳤으니 IndexController의 반복되는 부분들을 @LoginUser로 개선하겠다.

// IndexController.java

...

@RequiredArgsConstructor
@Controller
public class IndexController {
    private final PostsService postsService;

	/*
    기존 방식 : 로그인 성공 시 HttpSession에서 값을 받아옴
    private final HttpSession httpSession;
     */

    @GetMapping("/")
    public String index(Model model,
                        @LoginUser SessionUser user) { // 이제 어느 컨트롤러에서든 @LoginUser만 사용하여 세션 정보를 가져올 수 있음
        model.addAttribute("posts", postsService.findAllDesc());

        /* 
        기존 방식 : 로그인 성공 시 httpSession.getAttribute("user") 에서 값 가져옴
        SessionUser user = (SessionUser) httpSession.getAttribute("user"); 
        */

        if (user != null) {    // session에 저장된 값이 있을 때만 model에 userName으로 등록
            model.addAttribute("userName", user.getName());
        }
        return "index";
    }

다시 애플리케이션을 실행해 로그인 기능이 정상적으로 작동하는 것을 확인하자.

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

지금까지 개발한 서비스의 가장 큰 단점이 무엇일까? 그것은 바로 애플리케이션을 재시작하게 되면 로그인이 풀리게 된다는 것이다.

이는 세션이 내장 톰캣의 메모리에 저장되기 때문이다. 기본적으로 세션은 실행되는 WAS의 메모리에서 저장되고 호출된다. 그렇기 때문에 내장 톰캣처럼 애플리케이션 실행 시에 실행되는 구조에서는 항상 초기화된다.

또 다른 문제가 있다. 2대 이상의 서버에서 서비스하고 있다면 톰캣마다 세션 동기화 설정을 해주어야 한다.

이런 문제들 때문에 실제 현업에서는 세션 저장소에 대해 다음의 3가지 중 한 가지를 선택해야 한다.

● 톰캣 세션을 사용

일반적으로 별다른 설정을 하지 않을 때 기본적으로 선택되는 방식

톰캣에 세션이 저장되기 때문에 2대 이상의 WAS가 구동되는 경우에는 톰캣들 간의 세션 공유를 위한 추가 설정이 필요

● MySQL과 같은 DB를 세션 저장소로 사용

여러 WAS 간의 공용 세션을 사용할 수 있는 가장 쉬운 방법

많은 설정이 필요 없지만, 로그인 요청 때마다 DB IO가 발생하여 성능상의 이슈 발생 가능

보통 로그인 요청이 많지 않은 백오피스, 사내 시스템 용도로 사용

● Redis, Memcached와 같은 메모리 DB를 세션 저장소로 사용

B2C 서비스에서 가장 많이 사용하는 방식

실제 서비스로 사용하기 위해서는 Embedded Redis와 같은 방식이 아닌 외부 메모리 서버가 필요

여기서는 두 번째 방식인 데이터베이스를 세션 저장소로 사용하는 방식을 선택하겠다. 설정이 간단하고 사용자가 많은 서비스가 아닐 뿐만 아니라 비용도 많이 줄일 수 있기 때문이다. 메모리 DB는 이후에 AWS에서 서비스를 배포하고 운영할 때를 생각할 때 사용하기 부담스럽다. 레디스와 같은 서비스에 별도로 사용료를 지불해야 하기 때문이다.

세션 저장소로 데이터베이스를 사용하기 위해 spring-session-jdbc를 등록해야 한다.

build.gradle에 다음과 같이 의존성을 등록한다.

// build.gradle
compile('org.springframework.session:spring-session-jdbc')

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

// application.properties
spring.session.store-type=jdbc

모두 변경하였으니 다시 애플리케이션을 실행하여 로그인을 테스트하고 나서 h2-console로 접속해 보자.

그러면 세션을 위한 테이블 2개가 생성된 것을 확인할 수 있다. (SPRING_SESSION, SPRING_SESSION_ATTRIBUTES)

또한 방금 로그인을 진행했으니 한 개의 세션이 등록돼 있는 것을 볼 수 있다.

세션 저장소를 데이터베이스로 교체하였다. 물론 지금은 저번과 마찬가지로 스프링을 재시작하면 세션이 풀린다. H2도 스프링이 재실행될 때 재시작되기 때문이다.

하지만 이후에 AWS로 배포하게 되면 AWS의 RDS를 사용하기 때문에 이때부터는 세션이 풀리지 않고 진행할 수 있을 것이다.

6. 네이버 로그인

마지막으로 네이버 로그인도 추가해 보자.

1) 네이버 API 등록

먼저 네이버 오픈 API(https://developers.naver.com/apps/#/register?api=nvlogin)로 이동하자.

다음과 같이 설정하면 된다. Callback URL은 구글에서 등록한 리디렉션 URL과 같은 역할을 한다.

등록이 완료되면 ClientID와 ClientSecret을 발급받게 된다.

해당 키값들을 application-oatuh.properties에 등록한다. 네이버에서는 스프링 시큐리티를 공식 지원하지 않기 때문에 그동안 Common-OAuth2Provider에서 해주던 값들도 전부 수동으로 입력해야 한다.

# application-oauth.properties
# registration-naver
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-naver
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

네이버 로그인 API 반환값 중에서 response를 user_name으로 설정하고 이후 자바 코드로 response에서 id를 user_name으로 지정하도록 하겠다.

2) 스프링 시큐리티 설정 등록

구글 로그인을 등록하면서 대부분 코드를 확장성 있게 잘 작성하였기 때문에 네이버는 쉽게 등록할 수 있다.

OAuthAttributes에 다음과 같이 네이버인지 판단하는 코드와 네이버 생성자만 추가해 주자.

// OAuthAttributes.java

...

@Getter
public class 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) attributes.get("name"))
                .email((String) attributes.get("email"))
                .picture((String) attributes.get("profile_image"))
                .attributes(response)
                .nameAttributeKey(userNameAttributeName)
                .build();
    }

    ...
    
}

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

{{!index.mustache}}

...

{{^userName}} {{!userName이 없다면 로그인 버튼이 노출되도록 구성}}
    <a href="/oauth2/authorization/google"  {{!스프링 시큐리티에서 기본적으로 제공하는 로그인 URL}}
       class="btn btn-success active" role="button">Google Login</a>

	{{!스프링 시큐리티에서 기본적으로 제공하는 로그인 URL}}
    <a href="/oauth2/authorization/naver"  {{!/oauth2/authorization/까지는 고정이고 마지막 Path만 각 소셜 로그인 코드를 사용}}
       class="btn btn-secondary active" role="button">Naver Login</a>
{{/userName}}

...

애플리케이션을 실행하여 메인 화면을 확인해 보면 네이버 버튼이 활성화되었음을 확인할 수 있다.

네이버 로그인 버튼을 눌러 로그인을 진행하면 다음과 같이 로그인이 성공함을 확인할 수 있다.

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

이제 스프링 시큐리티 적용을 마쳤으니 기존 테스트에 시큐리티 적용으로 인해 문제가 되는 부분들을 해결해 보겠다.

기존에는 바로 API를 호출하는 것이 가능했으나, 지금은 시큐리티 옵션이 활성화됨에 따라 인증된 사용자만 API를 사용하는 것이 가능하다.

기존의 API 테스트 코드들이 모두 인증에 대한 권한을 받지 못했기 때문에 테스트 코드마다 인증한 사용자가 호출한 것처럼 작동하도록 수정해 보겠다.

IntelliJ 오른쪽 위에 [Gradle] 탭을 클릭하고, [Tasks -> verification -> test]를 차례로 선택해서 전체 테스트를 수행하자.

수행 결과를 보면 롬복을 이용한 테스트 외의 스프링을 이용한 테스트는 모두 실패하는 것을 확인할 수 있다.

그 이유를 하나씩 확인해 보자.

문제 1. CustomOAuth2UserService를 찾을 수 없음

첫 번째 실패 테스트인 "hello가_리턴된다"의 메시지를 보면 아래와 같은 오류 메시지를 볼 수 있다.

No qualifying bean of type 'com.cotato.study.SpringnAWS.config.auth.CustomOAuth2UserService' available:

이는 CustomOAuth2UserSerivce를 생성하는데 필요한 소셜 로그인 관련 설정값들이 없기 때문에 발생한다.

분명 application-oauth.properties에 설정값들을 추가했지만 왜 설정이 없다고 나오는 것일까?

이는 src/main과 src/test 환경의 차이 때문으로, 둘은 본인만의 환경 구성을 가진다.

test에 application.properties가 없다면 main의 설정을 그대로 가져오지만, application-oauth.properties는 가져오지 않는다.

이 문제를 해결하기 위해 테스트 환경을 위한 application.properties를 만들어보겠다. 실제로 구글 연동까지 진행할 것은 아니므로 가짜 설정값을 등록하자.

// src/test/resources/application.properties
spring.jpa.show-sql=true
spring.h2.console.enabled=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL57Dialect
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를 만들고, 다시 테스트를 수행해 보면 실패 테스트의 수가 줄어듦을 확인할 수 있다.

문제 2. 302 Status Code

두 번째로 "Posts_등록된다" 테스트 로그를 확인해 보자.

expected:<[200 OK]> but was:<[302 FOUND]>
필요:200 OK
실제   :302 FOUND

응답의 결과로는 200(정상 응답) Status Code를 원했는데 결과는 302(리다이렉션 응답) Status Code가 와서 실패했다.

이는 스프링 시큐리티 설정 때문에 인증되지 않은 사용자의 요청은 이동시키기 때문이다.

이런 API 요청들은 임의로 인증된 사용자를 추가하여 API만 테스트될 수 있게 하겠다.

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

// build.gradle
testCompile('org.springframework.security:spring-security-test')

그리고 PostsApiControllerTest의 2개 테스트 메소드에 다음과 같이 임의 사용자 인증을 추가한다.

// PostsApiController.java

...

@Test
@WithMockUser(roles = "USER") // 인증된 모의 사용자를 만들어서 사용
public void Posts_등록된다() throws Exception{

	...

}

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

@WithMockUser는 MockMvc에서만 작동하기 때문에 @SpringBootTest에서 MockMvc를 사용하게 설정해야 한다.

// PostsApiController.java

...

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

	...

    @Autowired
    private WebApplicationContext context;

    private MockMvc mvc;

    @Before // 매번 테스트가 시작되기 전에 MockMvc 인스턴스 생성
    public void setup(){
        mvc = MockMvcBuilders
                .webAppContextSetup(context)
                .apply(springSecurity())
                .build();
    }
  
  	...
  
    @Test
    @WithMockUser(roles = "USER") // 인증된 모의 사용자를 만들어서 사용
    public void Posts_등록된다() throws Exception{
        
        ...
        
        // when
        mvc.perform(post(url) // 생성된 MockMvc를 통해 API를 테스트
                .contentType(MediaType.APPLICATION_JSON_UTF8) // Body영역은 문자열로 표현하기 위해 JSON으로 변환
                .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 {
 		
        ...
        
        // 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);
    }
}

이렇게 설정하고 다시 테스트를 수행하면 Posts 관련 테스트들도 통과함을 확인할 수 있다.

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

"Hello가 리턴된다" 테스트를 확인해 보면 다음과 같은 오류 메시지를 볼 수 있다.

No qualifying bean of type 'com.cotato.study.SpringnAWS.config.auth.CustomOAuth2UserService' available:

이는 @WebMvcTest가 CustomOAuth2UserService를 스캔하지 않기 때문이다.

@WebMvcTest는 @ControllerAdvice와 @Controller를 읽기 때문에 @Respository, @Service, @Component는 스캔 대상이 아니다. 그렇기 때문에 SecurityConfig는 읽었지만, SecurityConfig를 생성하기 위한 CustomOAuth2UserService는 읽을 수가 없어 앞에서와 같이 에러가 발생한 것이다.

이를 해결하기 위해 스캔 대상에서 SecurityConfig를 제거한다.

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

여기서도 @WithMockUser를 사용해서 가짜로 인증된 사용자를 생성한다.

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

    ...

}

...

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

    ...

}

이렇게 한 뒤 다시 테스트를 돌려보면 또 다른 에러를 발견할 수 있다.

java.lang.IllegalArgumentException: JPA metamodel must not be empty!

이 에러는 @EnableJpaAuditing으로 인해 발생한다. 이 어노테이션을 사용하기 위해선 최소 하나의 @Entity 클래스가 필요하지만 @WebMvcTest다 보니 당연히 존재하지 않는다.

@EnableJpaAuditing이 @SpringBootApplication과 함께 있다 보니 @WebMvcTest에서도 한 번에 스캔하게 된 것이다. 그래서 이 둘을 분리하겠다.

※ @WebMvcTest : 실제 객체와 비슷하지만 테스트에 필요한 기능만 가지는 가짜 객체를 만들어서 애플리케이션 서버에 배포하지 않고도 스프링 MVC 동작을 재현할 수 있는 클래스

Application.java에서 @EnableAuditiong를 제거하자.

// @EnableJpaAuditing이 삭제됨
@SpringBootApplication // 스프링 부트의 자동 설정, Spring 빈의 읽기와 생성을 자동 설정
public class Application { // 프로젝트의 메인 클래스
    public static void main(String[] args) {
            SpringApplication.run(Application.class, args); // 내장 WAS 서버 실행
    }
}

config 패키지에 JpaConfig를 생성하여 @EnableJpaAuditing를 추가하자.

// JpaConfig.java
package com.cotato.study.SpringnAWS.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;

@Configuration
@EnableJpaAuditing // JPA Auditing 활성화
public class JpaConfig {
}

이제 전체 테스트를 실행하면 모두 통과함을 확인할 수 있다.

'개발 > 스프링 부트와 AWS로 혼자 구현하는 웹 서비스' 카테고리의 다른 글

[Spring Boot & AWS] Chpt 7 - AWS에 데이터베이스 환경을 만들어보자 - AWS RDS (0)	2023.01.30
[Spring Boot & AWS] Chpt 6 - AWS 서버 환경을 만들어보자 - AWS EC2 (0)	2023.01.24
[Spring Boot & AWS] Chpt 4 - 머스테치로 화면 구성하기 (0)	2023.01.18
[Spring Boot & AWS] Chpt 3 - 스프링 부트에서 JPA로 데이터베이스 다뤄보자 (0)	2023.01.13
[Spring Boot & AWS] Chpt 2 - 스프링 부트에서 테스트 코드를 작성하자 (0)	2023.01.11