스프링 시큐리티와 OAuth 2.0으로 로그인 기능 구현하기

 

스프링 부트 1.5와 스프링 부트 2.0에서 시큐리티 설정의 차이점 스프링 시큐리티를 이용한 구글/네이버 로그인 연동 방법 세션 저장소로 톰캣/데이터베이스/메모리DB가 있으며 이 중 데이터베이스를 사용하는 이유 ArgumentResolver를 이용하면 어노테이션으로 로그인 세션 정보를 가져올 수 있다는 것 스프링 시큐리티 적용 시 기존 테스트 코드에서 문제 해결 방법

 

스프링 시큐리티

스프링 기반 애플리케이션의 보안(인증(로그인), 권한부여(guest, user, member, admin 구분))을 담당하는 프레임워크

 

 

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

* Oauth 란?

Open Authorization, Service Provider(구글 페이스북, 카카오 등)에서 제공하는 Authorization Server를 통해 회원정보를 인증하고 Access Token을 발급받은 후 Access Token을 이용해 타사의 API 서비스를 이용할 수 있게 함

 

User : Service Provider에 계정을 가지고 있으면서, Consumer앱을 이용하려는 사용자

Service Provider : OAuth를 사용하는 Open API를 제공하는 서비스 (facebook,google등)

 

로그인 기능을 OAuth 없이 직접 구현할 경우 구현해야 하는 것

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

=>이런 기능들을 구글, 네이버 등에 맡기고 다른 서비스 개발에 집중하기 위해 OAuth 2.0 사용

 

 

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

spring-security-oauth2-autoconfigure 

라이브러리를 사용하면 스프링부트 2에서도 1.5에서 쓰던 설정을 그대로 사용할 수 있다

하지만 신규 기능은 Oauth2 라이브러리에서만 지원하므로 OAuth2를 사용하자

 

 

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

1.5 버전에서 직접 입력했던 값들이 2.0버전으로 오면서 모두 enum으로 대체

 CommonOAuth2Provide라는 enum이 추가돼 구글, 깃헙, 페이스북의 기본 설정값을 모두 저장

 

 

구글 서비스 등록

console.cloud.google.com/home/dashboard?project=helpful-charmer-242004

 

 

application oauth 등록

application.properties와 같은 위치에 applicaiton-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

spring oauth2의 기본 scope가 openid, profile, email 인데 여기서 openid라는 scope가 있으면 

OpenId Provide(구글)과 그렇지 않은 서비스(네이버, 카카오 등)을 나눠 각각 OAuth2Service를 만들어야 하기 때문에 하나로 사용하기 위해 openid scope 빼고 등록

 

 

spring.profiles.include=oauth

 

스프링 부트에서는 applicaiton-xxx.properties로 만들면 xxx라는 이름의 profile이 생성돼 관리할 수 있다

즉 profile=xxx 라는 식으로 호출하면 해당 properties의 설정들을 가져올 수 있다

application.properties에서 application-oauth.properties를 포함하도록 구성

=> 이제 설정값을 사용할 수 있다

 

 

application-oatuh.properties

클라이언트 ID와 클라이언트 보안 비밀을 깃허브에 올라가지 않게 하기 위해 .gitignore에 코드 추가

 

 

구글 로그인 연동하기

domain 아래 사용자 정보를 담당할 User 패키지, 클래스 생성

 

 

User.java

@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.java

@Getter
@RequiredArgsConstructor
public enum Role {

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

    private final String key;
    private final String title;
}

스프링 시큐리티에서는 권한 코드에 항상 ROLE_이 앞에 있어야함

그래서 코드별 키 값을 ROLE_GUEST, ROLE_USER 등으로 지정

 

*enum 사용 이유 : enum 외의 값을 못 받도록 하기 위해(남/여 같이 범위 한정)

*스프링 시큐리티에서는 권한을 비회원(GUEST), 준회원(USER), 정회원(MEMBER), 관리자(ADMIN) 4가지로 나눴다. 비회원은 그 누구든 접근할 수 있고, 준회원은 로그인을 한 이용자, 정회원은 로그인 한 이용자 중에 정회원 권한을 가진 이용자, 관리자는 로그인 한 이용자 중에 관리자 권한을 가진 이용자만 접근할 수 있다.

 

 

 

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

public interface UserRepository extends JpaRepository<User, Long> {

    Optional<User> findByEmail(String email);
}

findByEmail

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

 

 

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

 

스프링 시큐리티 설정

build.gradle 스프링 시큐리티 관련 의존성 추가

compile('org.springframework.boot:spring-boot-starter-oauth2-client')

소셜 로그인 기능 구현 시 필요한 의존성

 

 

앞으로 시큐리티 관련 클래스는 모두 config.auth에 담음

SecurityConfig.java

@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/**").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 화면을 사용하기 위해 해당 옵션들을 disable

 

authorizeRequests

URL별 권한 관리를 설정하는 옵션의 시작점

authorizeRequests가 선언되어야만 antMatchers 옵션을 사용할 수 있음

 

antMatchers

권한 관리 대상을 지정하는 옵션

URL, HTTP 메소드별로 관리가 가능

"/"등 지정된 URL들은 permitAll() 옵션을 통해 전체 열람 권한을 주었습니다.

"/api/v1/**"주소를 가진 API는 USER 권한을 가진 사람만 가능하도록 했습니다.

 

anyRequest

설정된 값들 이외 나머지 URL들을 나타냅니다.

여기서는 authenticated()을 추가하여 나머지 URL들은 모두 인증된 사용자들에게만 허용하게 됩니다.

인증된 사용자 즉, 로그인한 사용자들을 이야기합니다.

 

logout().logoutSuccessUrl("/")

로그아웃 기능에 대한 여러 설정의 진입점입니다.

로그아웃 성공 시 / 주소로 이동합니다.

 

oauth2Login

OAuth 2 로그인 기능에 대한 여러 설정의 진입점입니다.

 

userInfoEndpoint

OAuth 2 로그인 성공 이후 사용자 정보를 가져올 때의 설정들을 담당합니다.

 

userService

소셜 로그인 성공 시 후속 조치를 진행할 UserService 인터페이스의 구현체를 등록합니다.

리소스 서버(즉, 소셜 서비스들)에서 사용자 정보를 가져온 상태에서 추가로 진행하고자 하는 기능을 명시할 수 있습니다.

 

 

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

 

 

CustomOAuth2UserService.java

@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엔티티에도 반영됩니다.

 

CustomOAuth2UserService 클래스까지 생성되었다면 OAuthAttributes 클래스를 생성합니다.

 

 

 

OAuthAttributes.java

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

of()

OAuth2User에서 반환하는 사용자 정보는 Map이기 때문에 값 하나하나를 변환해야만 합니다.

 

toEntity

User 엔티티를 생성합니다.

OAuthAttributes에서 엔티티를 생성하는 시점은 처음 가입할 때입니다.

가입할 때의 기본 권한을 GUEST로 주기 위해서 role 빌더값에는 Role.GUEST를 사용합니다.

OAuthAttributes 클래스 생성이 끝났으면 같은 패키지에 SessionUser 클래스를 생성합니다.

 

 

SessionUser.java

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

Entity User 클래스를 SessionUser로 사용안하는 이유

세션에 저장하기 위해 User클래스를 세션에 저장하려고 하니 User 클래스에 직렬화를 구현하지 않았다는
에러가 난다.

 

Entity 클래스는 직렬화 코드를 넣지 않는게 좋다

엔티티 클래스에는 언제 다른 엔티티와 관계가 형성될지 모른다.

@OneToMany, @ManyToMany등 자식 엔티티를 갖고 있다면 직렬화 대상에 자식들까지 포함되니 성능 이슈, 부수 효과가 발생할 확률이 높다
=> 직렬화 기능을 가진 세션 Dto를 하나 추가로 만든 것이 더 좋은 방법이다.

 

*직렬화

자바 시스템 내부에서 사용되는 Object 또는 Data를 외부의 자바 시스템에서도 사용할 수 있도록 byte 형태로 데이터를 변환하는 기술

 

로그인 테스트

index.mustache

 

스프링 시큐리티가 잘 적용됐는지 확인 위해 로그인 버튼/로그인 성공 시 사용자 이름을 보여주는 코드 추가

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

{{#userName}}

userName이 있으면 {{#userName}} ~ {{/userName}}까지의 코드가 화면에 보인다

자바의 if문과 같음

 

{{^userName}}

머스테치에서 해당 값이 존재하지 않는 경우에는 ^를 사용합니다.

자바의 else문과 같음

a href="/logout"

스프링 시큐리티에서 기본적으로 제공하는 로그아웃 URL

즉, 개발자가 별도로 저 URL에 해당하는 컨트롤러를 만들 필요가 없습니다.

SecurityConfig 클래스에서 URL을 변경할 수 있다.

 

a href="/oauth2/authorization/google"

스프링 시큐리티에서 기본적으로 제공하는 로그인 URL입니다.

로그아웃 URL과 마찬가지로 개발자가 별도의 컨트롤러를 생성할 필요가 없습니다.

 

 

index.mustache에서 userName을 사용할 수 있게 IndexController에서 userName을 추가합니다.

 

 

IndexController

@RequiredArgsConstructor
@Controller
public class IndexController {

    private final PostsService postService;
    private final HttpSession httpSession;

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

        return "index";
    }

(SessionUser) httpSession.getAttribute("user")

앞서 작선된 CustomOAuth2UserService에서 로그인 성공 시 세션에 SessionUser를 저장하도록 구성했습니다.

즉, 로그인 성공시 httpSerssion.getAttribute("user")에서 값을 가져올 수 있습니다.

 

if(user != null)

세션에 저장된 값이 있을 때만 model에 userName으로 등록

 

테스트

 

guest 권한 사용자는 posts 기능을 쓸 수 없어 403(권한거부) 에러 뜸

권한 USER로 바꾸고  세션에 이미 GUEST로 저장돼 있으니 로그아웃 후 로그인해 세션 정보를 최신 정보로 갱신한 후 글 등록하면 글 등록 성공

 

 

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

나쁜 코드 -> 같은 코드의 반복 => 수정할 때 모든 부분 바꿔야 하기 때문에 유지보수성이 떨어진다

IndexController에서 해당 코드를 사용하면 index 메소드 외의 다른 컨트롤러와 메소드에서 세션값이 필요할 때마다 직접 세션에서 값을 가져와야 된다. 같은 코드가 반복된다

 

이 부분을 메소드 인자로 세션값을 바로 받을 수 있도록 변경하자

 

LoginUser.java

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

@Target(ElementType.PARAMETER)

어노테이션이 생성될 수 있는 위치를 지정

PARAMETER로 지정했으니 메소드의 파라미터로 선언된 객체에서만 사용할 수 있습니다.

이 외에도 클래스 선언문에 쓸 수 있는 TYPE등이 있습니다.

 

@Target

 - ElementType.TYPE : 클래스, 인터페이스, enum 선언부

 - ElementType.CONSTRUCTOR : 생성자 선언부

 - ElementType.LOCAL_VARIABLE : 지역 변수 선언부

 - ElementType.METHOD : 메소드 선언부

 - ElementType.PACKAGE : 패키지 선언부

 - ElementType.PARAMETER : 파라미터 선언부

 

@interface

이 파일을 어노테이션 클래스로 지정합니다.

LoginUser라는 이름을 가진 어노테이션이 생성되었다고 보면 됩니다.

 

@Retention(RetentionPolicy.RUNTIME)

컴파일 이후에도 JVM에 의해서 참조가 가능하다.

 

 

LoginUserArgumentResolver.java

@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

파라미터에 전달할 객체를 생성

 

LoginUserArgumentResolver를 스프링에서 인식될 수 있도록 WebMvcConfigurer 추가해야한다.
config 패키지에 WebConfig 클래스 생성하여 다음과 같이 설정한다.

 

 

WebConfig.java

@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의 코드를 수정하겠습니다.

 

 

IndexController의 코드에 반복되는 부분 모두 @LoginUser로 개선

@RequiredArgsConstructor
@Controller
public class IndexController {

    private final PostsService postService;

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

        return "index";
    }

어느 컨트롤러든지 @LoginUser 사용하면 세션 정보 가져올 수 있음

 

 

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

현재 서비스는 세션이 내장 톰캣의 메모리에 저장되기 때문에 애플리케이션을 재실행하면 로그인이 풀린다

 

세션 저장소에 대해 다음의 3가지 중 한 가지를 선택합니다.

1. 톰캣 세션을 사용한다.

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

이렇게 될 경우 톰캣(WAS)에 세션이 저장되기 때문에 2대 이상의 WAS가 구동되는 환경에서는 톰캣들 간의 세션 공유를 위한 추가 설정이 필요하다.

 

2. MySQL과 같은 데이터베이스를 세션 저장소로 사용한다.

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

많은 설정이 필요 없지만, 결국 로그인 요청마다 DB IO가 발생하여 성능상 이슈가 발생할 수 있습니다.

보통 로그인 요청이 많이 없는 백오피스, 사내 시스템 용도에서 사용

 

3. Redis, Memcached와 같은 메모리 DB를 세션 저장소로 사용한다.

B2C 서비스에서 가장 많이 사용하는 방식입니다.

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

별도 사용료 지불해야 함

 

 

이를 해결하기 위해 데이터베이스를 세션 저장소로 사용하자

build.gradle

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

 

application.properties

spring.session.store-type=jdbc

 

h2-console를 보면 세션을 위한 테이블 2개(SPRING_SESSION,SPRING_SESSION_ATTRIBUTES)가 생성된 것을 볼 수 있습니다. JPA로 인해 세션 테이블이 자동 생성되었습니다.

지금은 H2 기반으로 스프링이 재실행될 때 H2도 재시작되기 때문에 세션이 풀리는데

이후 AWS로 배포하게 되면 AWS의 데이터베이스 서비스인 RDS를 사용하게 되니 그 때부터 세션이 풀리지 않는다

 

 

네이버 로그인

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

발급받은 ClientID, ClientSecret 키값 application-oauth.properties에 등록

네이버에서는 스프링 시큐리티를 지원하지 않기 때문에 그동안 Common-OAuth2Provide에서 해주던 값들도 전부 수동 입력

# 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 형태 때문입니다.

 

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

네이버 오픈 API 로그인 회원 결과는 위와 같은데

스프링 시큐리티에선 하위 필드를 명시할 수 없고,

네이버 응답값 최상위 필드는 resultcode, message, response 이므로 회원 정보 담고 있는 response 입력

 

이후 자바 코드(OauthAttribute.java)로 response의 id를 user_name으로 지정하도록 함

 

 

OAuthAttributes.java

네이버인지 판단하는 코드와 네이버 생성자 추가

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에 네이버 로그인 버튼 추가

<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>
                <a href="/oauth2/authorization/naver" class="btn btn-secondary active" role="button">Naver Login</a>
            {{/userName}}
        </div>
    </div>

/oauth2/authorization/naver

네이버 로그인 URL은 application-oauth.properties에 등록한 redirect-uri 값에 맞춰 자동으로 등록됩니다.

/oauth2/authorization/ 까지는 고정이고 마지막 Path만 각 소셜 로그인 코드를 사용하면 됩니다.

 

 

 

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

인증된 사용자만 API를 호출할 수 있는데 기존의 api 테스트 코드들은 모두 인증에 대한 권한을 받지 못했으므로 테스트 코드마다 인증한 사용자가 호출한 것처럼 작동하도록 수정

 

 

전체 테스트 수행

 

오류 발생

 

 

문제 1. CustomOAuth2UserService을 찾을 수 없음

소셜 로그인 관련 설정값들이 없기 때문에 발생합니다.
test에 application.properties를 설정합니다.

 

application.properties(test)

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

 

 

문제 2. 302 Status Code

 

Post_등록된다 실패

인증되지 않은 사용자의 요청은 이동하지 않기 때문에 실패

=>스프링 시큐리티 테스트를 위한 의존성을 주입해준다

 

build.gradle

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

 

PostsApiControllerTest

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

   @LocalServerPort
   private int port;

   @Autowired
   private TestRestTemplate restTemplate;

   @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.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 savePosts = postsRepository.save(Posts.builder()
               .title("title")
               .content("content")
               .author("author")
               .build());

       Long updateId = savePosts.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;

       HttpEntity<PostsUpdateRequestDto> requestEntity = new HttpEntity<>(requestDto);

       //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 테스트

본문 영역은 문자열로 표현하기 위해 ObjectMapper를 통해 문자열 JSON으로 변환

 

@WithMockUser(roles = "USER")

인증된 모의 사용자를 만들어서 사용합니다.

roles에 권한을 추가할 수 있습니다.

ROLE_USER 권한을 가진 사용자가 API를 요청하는 것과 동일한 효과

 

 

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

@WebMvcTest는 WebSecurityConfigurerAdapter, WebMvcConfigurer를 비롯한 @ControllerAdvice, @Controller를 읽습니다. 즉 @Repository, @Service, @Component는 스캔 대상이 아니다.

그래서 ScutiryConfig는 읽었지만 SecurityConfig 생성 위해 필요한 CustomOAuth2UserService를 못 읽어 에러 발생

 

이를 해결하기 위해

1. 스캔 대상에서 SecurityConfig를 제거합니다.

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

 

 

HelloControllerTest

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

   @Autowired
   private MockMvc mvc;

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

       mvc.perform(get("/hello"))
               .andExpect(status().isOk())
               .andExpect(content().string(hello));
   }

   @WithMockUser(roles = "USER")
   @Test
   public void helloDto가_리턴된다() throws  Exception {
       String name = "hello";
       int amount = 1000;

       mvc.perform(
                   get("/hello/dto")
                           .param("name", name)
                           .param("amount", String.valueOf(amount)))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.name", is(name)))
               .andExpect(jsonPath("$.amount", is(amount)));
   }
}

 

 

문제 4 @EnableJpaAuditing 에러

@EnableJpaAuditing은 @Entity클래스 최소 하나 필요한데 @WebMvcTest테스트이다 보니 없어 에러 발생

@SpringBootApplication과 @EnableJpaAuditing이 함게 있다보니 @WebMvcTest에서도 스캔하게 돼

둘을 분리하자 

 

SpringWebServiceApplication 수정

// @EnableJpaAuditing 제거
@SpringBootApplication
public class Application {
   public static void main(String[] args) {
       SpringApplication.run(Application.class, args);
   }
}

 

 

JpaConfig 생성

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