Peony의 기록 창고 🌼
article thumbnail
Published 2022. 7. 19. 23:47
Spring Boot와 AWS로 혼자 구현하는 웹서비스 5장 도서/Spring Boot와 AWS 로 혼자 구현하는 웹서비스
반응형

이 글은 이동욱 님의 '스프링 부트와 AWS로 혼자 구현하는 웹 서비스' 책 내용을 정리한 것입니다.

http://www.yes24.com/Product/Goods/83849117

 

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

가장 빠르고 쉽게 웹 서비스의 모든 과정을 경험한다. 경험이 실력이 되는 순간!이 책은 제목 그대로 스프링 부트와 AWS로 웹 서비스를 구현한다. JPA와 JUnit 테스트, 그레이들, 머스테치, 스프링

www.yes24.com

 

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

스프링 시큐리티는 막강한 인증과 인가(권한 부여) 기능을 가진 프레임워크이다. 스프링 기반의 애플리케이션에서 보안을 위한 표준이라고 보면 된다. 확장성을 고려한 프레임워크로 다양한 요구사항을 손쉽게 추가하고 변경할 수 있다.

 

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

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

 

❓왜 많은 서비스에서 소셜 로그인을 사용할까?

직접 구현할 경우 많은 기능(로그인시 보안, 회원가입시 이메일 혹은 전화번호 인증, 비밀번호 찾기/변경 등)을 직접 구현해주어야 하는데 이를 모두 구글,페이스북,네이버 등에 맡기면 되므로 서비스 개발에 집중할 수 있기 때문이다.

 

2. 구글 서비스 등록

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

구글 클라우드 플랫폼 주소(https://console.cloud.google.com)으로 이동한다. [프로젝트 선택] 탭을 클릭한다. [새 프로젝트]를 클릭하고 등록될 서비스의 이름을 입력한다. (원하는 이름)

생성이 완료된 프로젝트를 선택하고 왼쪽 메뉴 탭을 클릭해서 API 및 서비스 카테고리로 이동한다.

[사용자 인증 정보]를 클릭하고 [사용자 인증 정보 만들기]버튼을 클릭한다.

 

사용자 인증 정보에는 여러 메뉴가 있는데 이 중 구현할 소셜 로그인은 OAuth 클라이언트 ID로 구현한다. [OAuth 클라이언트 ID]항목을 클릭한다. > [동의 화면 구성] 버튼을 클릭한다.

OAuth 동의 화면 에서 각 항목을 다음과 같이 작성한다.

  1. 애플리케이션 이름 : 구글 로그인시 사용자에게 노출될 애플리케이션 이름
  2. 지원 이메일 : 사용자 동의 화면에서 노출될 이메일 주소. 보통은 서비스 help이메일주소를 사용한다.
  3. Google API 의 범위 : 이번에 등록할 구글 서비스에서 사용할 범위목록이다. 기본값은 email/profile/openid이며, 다른 정보를 사용하고 싶으면 범위 추가 버튼으로 추가하면 된다.

 

OAuth 클라이언트 ID 만들기

애플리케이션 유형을 웹 애플리케이션으로 해주고 승인된 리디렉션 URI를 등록해야 한다.

승인된 리디렉션 URI

  • 서비스에서 파라미터로 인증 정보를 주었을 때 인증이 성공하면 구글에서 리다이렉트할 URL
  • 스프링 부트 2 버전의 시큐리티에서는 기본적으로 {도메인}/login/oauth2/code{소셜서비스코드}로 리다이렉트 URL을 지원
  • 현재는 개발 단계이므로 http://localhost:8080/login/oauth2/code/google 로만 등록하자.

생성 버튼을 클릭하면 생성된 클라이언트 정보를 볼 수 있고 생성된 애플리케이션을 클릭하면 다음과 같은 인증 정보를 볼 수 있다. 클라이언트 ID와 클라이언트 보안 비밀 코드를 프로젝트에서 설정하자.

 

application-oauth 등록

application.properties가 있는 src/main/resources/ 디렉토리에 application-oauth.properties 파일을 생성한다.

해당 클라이언트 ID와 클라이언트 보안 비밀 코드를 등록한다.

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=profile,email
    • 많은 예제에서는 이 scope를 별도로 등록하지 X.
      → 기본값이 openid.profile.email이기 때문
    • profile, email을 등록한 이유 : openid라는 scope가 있으면 Open Id Provider로 인식하기 때문
      → 이렇게 되면 Open Id Provider인 서비스(구글)과 그렇지 않은 서비스(네이버, 카카오)로 나눠서 각각 OAuth2Service를 만들어야 함.

 

스프링 부트에서는 properties의 이름을 application-xxx.properties로 만들면 xxx라는 이름의 profile이 생성되어 이를 통해 관리할 수 있다. 즉, profile=xxx라는 식으로 호출하면 해당 properties의 설정들을 가져 올 수 있다.

application.properties에서 application-oauth.properties를 포함하도록 구성한다. application.properties에 밑의 코드를 추가하자.

spring.profiles.include = oauth

 

.gitignore 등록

구글 로그인을 위한 클라이언트 ID와 클라이언트 보안 비밀은 보안이 중요한 정보들이기 때문에 깃허브에 올라가지 않도록 관리해야 하므로 .gitignore에 밑의 코드를 추가해주자.

application-oauth.properties

 

3. 구글 로그인 연동하기

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

src/main/java/com/jojoldu/book/springboot/domain/user/User.java

import com.jojoldu.book.springboot.domain.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)
    @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로 된 숫자가 저장
    • 숫자로 저장되면 데이터베이스로 확인할 때 그 값이 무슨 코드를 의미하는지 알 수 가 없기 때문에 문자열로 저장

 

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

src/main/java/com/jojoldu/book/springboot/domain/user/Role.java

package com.jojoldu.book.springboot.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_이 앞에 있어야만 한다. 그래서 코드별 키값을 ROLE_GUEST,ROLE_USER등으로 지정한다.

 

마지막으로 user의 CRUD를 책임질 UserRepository 인터페이스도 생성하자.

src/main/java/com/jojoldu/book/springboot/domain/user/UserRepository.java

public interface UserRepository extends JpaRepository<User,Long> {
    Optional<User> findByEmail(String email);
}
  • findByEmail : 소셜 로그인으로 반환되는 값 중 email을 통해 이미 생성된 사용자인지 처음 가입하는 사용자인지 판단하기 위한 메소드이다.
  • Optional<T> : null이 올 수 있는 값을 감싸는 Wrapper클래스로 참조하더라도 NullPointerException이 발생하지 않도록 도와준다.

 

스프링 시큐리티 설정

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

implementation('org.springframework.boot:spring-boot-starter-oauth2-client')
  • spring-boot-starter-oauth2-client
    : 소셜 로그인 등 클라이언트 입장에서 소셜 기능 구현시 필요한 의존성.

 

앞으로 시큐리티 관련 클래스를 담을 config.auth 패키지를 생성하자. SecurityConfig 클래스를 생성하고 다음과 같이 코드를 작성하자. 아직 CustomOAuth2UserService 클래스를 만들지 않아 컴파일 에러가 발생하지만, 일단 작성해보자.

src/main/java/com/jojoldu/book/springboot/config/auth/SecurityConfig.java

package com.jojoldu.book.springboot.config.auth;

import com.jojoldu.book.springboot.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 //1
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    private final CustomOAuth2UserService customOAuth2UserService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .csrf().disable()
                .headers().frameOptions().disable() //2
                .and()
                    .authorizeRequests() //3
                    .antMatchers("/","/css/**","/images/**","/js/**","/h2-console/**").permitAll()
                    .antMatchers("/api/v1/**").hasRole(Role.USER.name()) //4
                    .anyRequest().authenticated()//5
                .and()
                    .logout()
                        .logoutSuccessUrl("/")//6
                .and()
                    .oauth2Login()//7
                        .userInfoEndpoint()//8
                            .userService(customOAuth2UserService);//9
    }
}
  1. @EnableWebSecurity
    • Spring Security 설정 활성화
  2. .csrf().disable().headers().frameOptions().disable()
    • h2-console화면을 사용하기 위해 해당 옵션들을 disable
  3. .authorizeRequests()
    • URL 별 권한 관리를 설정하는 옵션의 시작점.
    • authorizeRequests가 선언되어야만 antMatchers옵션을 사용할 수 있다
  4. .antMatchers("/api/v1/**")
    • 권한 관리 대상을 지정하는 옵션
    • URL,HTTP 메소드 별로 관리가 가능
    • "/" 등 지정된 URL들은 permitAll()옵션을 통해 전체 열람 권한을 주었다
    • "/api/v1/**" 주소를 가진 API는 USER권한을 가진 사람만 가능하도록 하였다
  5. .anyRequest()
    • 설정된 값들 이외 나머지 URL들을 나타낸다
    • 여기서는 authenticated()를 추가하여 나머지 URL들은 모두 인증된 사용자들에게만 허용(로그인한 사용자)
  6. .logout().logoutSuccessUrl("/")
    • 로그아웃 기능에 대한 여러 설정의 진입점
    • 로그아웃 성공시 /주소로 이동
  7. .oauth2Login()
    • oAuth2 로그인 기능에 대한 여러 설정의 진입점
  8. .userInfoEndpoint()
    • OAuth2 로그인 성공 이후 사용자 정보를 가져올 떄의 설정들을 담당
  9. .userService(customOAuth2UserService)
    • 소셜 로그인 성공 시 후속 조치를 진행할 UserService 인터페이스의 구현체를 등록
    • 리소스 서버(소셜 서비스)에서 사용자 정보를 가져온 상태에서 추가로 진행하고자 하는 기능을 명시할 수 있다

 

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

src/main/java/com/jojoldu/book/springboot/config/auth/CustomOAuth2UserService.java

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<OAuth2UserRequest, OAuth2User> delegate = new DefaultOAuth2UserService();
        OAuth2User oAuth2User = delegate.loadUser(userRequest);

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

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

        User user = saveOrUpdate(attributes);

        httpSession.setAttribute("user", new SessionUser(user)); //4

        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);
    }
}
  1. registraionId
    • 현재 로그인 진행 중인 서비스를 구분하는 코드
    • 현재는 구글만 사용하여 불필요한값이지만, 이후 네이버 로그인 연동시 구분하기 위해 사용
  2. userNameAttributeName
    • OAuth2 로그인 진행 시 키가 되는 필드값을 이야기한다(= Primary Key와 같은 의미)
    • 구글의 경우 기본적으로 코드를 지원하지만, 네이버/카카오 등은 기본 지원하지 않는다. 구글의 기본코드는 sub이다
    • 이후 네이버/구글 로그인 동시 지원할 때 사용
  3. OAuthAttributes
    • OAuth2UserService를 통해 가져온 OAuth2User의 attribute를 담을 클래스
    • 이후 네이버 등 다른 소셜 로그인도 이 클래스를 사용
  4. SessionUser
    • 세션에 사용자 정보를 저장하기 위한 Dto 클래스

 

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

이제 OAuthAttributes클래스를 생성하자. 필자의 경우 OAuthAttributes는 Dto로 보기 때문에 config.auth.dto 패키지에 생성하였다.

src/main/java/com/jojoldu/book/springboot/config/auth/dto/OAuthAttributes.java

import com.jojoldu.book.springboot.domain.user.Role;
import com.jojoldu.book.springboot.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;
    }

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

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

        //2
    public User toEntity(){
        return User.builder()
                .name(name)
                .email(email)
                .picture(picture)
                .role(Role.GUEST)
                .build();
    }
}
  1. of()
    • OAuth2User에서 반환하는 사용자 정보는 Map이기 때문에 값 하나하나를 변환해야만 한다.
  2. toEntity()
    • User엔티티를 생성
    • OAuthAttributes에서 엔티티를 생성하는 시점은 처음 가입할 때이다.
    • 가입할 때의 기본권한을 GUEST로 주기 위해서 role빌더값에는 Role.GUEST를 사용

 

이제 같은 패키지에 SessionUser 클래스를 추가해보자.

src/main/java/com/jojoldu/book/springboot/config/auth/dto/SessionUser.java

package com.jojoldu.book.springboot.config.auth.dto;

import com.jojoldu.book.springboot.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만 필드로 선언한다.

 

📌User 클래스를 사용하면 안되는 이유
User클래스를 그대로 사용하면 User클래스를 세션에 저장하려고하여 직렬화를 구현하지 않았다는 의미의 에러가 발생한다. User클래스는 엔티티이기 때문에 언제 다른 엔티티와의 관계가 형성될지 모른다. 그렇다면 직렬화 대상에 자식들까지 포함됨으로써 성능 이슈,부수 효과가 발생할 확률이 높다. 그래서 직렬화 기능을 가진 세션 Dto를 하나 추가로 많드는 것이 이후 운영 및 유지보수 때 많은 도움이 된다.

 

이제 로그인 기능을 테스트해보기 위해 화면에 로그인 버튼을 추가해보자.

index.mustache에 로그인 버튼과 로그인 성공 시 사용자 이름을 보여주는 코드를 작성해보자.

src/main/resources/templates/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>
    </div>
    <br>
    <!--목록 출력 영역-->
    <table class="table table-horizontal table-bordered">
  • {{#userName}}
    • 머스테치는 다른 언어와 같은 if문 등을 제공하지 않는다.
    • 오직 true/false여부만 판단한다. 그래서 머스테치에는 항상 최종값을 넘겨줘야 한다.
    • 여기서도 userName이 있다면 userName을 노출시키도록 구성하였다.
  • a href="/logout"
    • 스프링 시큐리티에서 기본적으로 제공하는 로그아웃 url
    • 해당 컨트롤러 만들 필요 없음
  • {{^userName}}
    • 머스테치에서는 해당 값이 존재하지 않는 경우에는 ^ 를 사용
    • userName이 없는 경우 로그인 버튼을 노출시키도록 구성했다
  • a href="/oauth2/authorization/google"
    • 기본적으로 제공하는 로그인 URL
    • 별도의 컨트롤러 생성할 필요 ❌

 

index.mustache에서 userName을 사용할 수 있도록 userName을 Model에 추가하는 코드 추가하자.

src/main/java/com/jojoldu/book/springboot/web/IndexController.java

@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으로 등록한다.
    • 저장된 값이 없을 경우 model엔 아무 값도 없으므로 로그인 버튼이 보이게 된다.

 

이제 프로젝트를 실행시켜 테스트해보자. Google Login 버튼을 눌러서 로그인을 해보자.

 

이제 DB를 확인해보자.

 

DB에도 잘 들어간 것을 확인할 수 있다. 이제 글 등록도 해보자.

글 등록을 누르면 다음과 같은 오류가 뜨는 것을 볼 수 있다.

 

h2 console에 가서 role을 "USER"로 바꿔서 다시 글 등록하면 잘 되는 것을 확인할 수 있다. 

 

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

일반적인 프로그래밍에서 개선이 필요한 나쁜 코드에는 어떤 것이 있을까?

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

 

앞서 만든 코드에서 개선할만한 것은 무엇이 있을까? IndexController.java를 한번 보자.

IndexController에서 세션값 가져오는 부분

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

index메소드 외에도 다른 컨트롤러와 메소드에서 세션값이 필요하면 그 때마다 직접 세션에서 값을 가져와야 한다. 같은 코드가 계속 반복되는 것은 불필요하다. 그래서 이 부분을 메소드 인자로 세션값을 바로 받을 수 있도록 변경해보겠다.

 

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

src/main/java/com/jojoldu/book/springboot/config/auth/LoginUser.java

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginUser {
}
  • @Target(ElementType.PARAMETER)
    • 어노테이션이 생성될 수 있는 위치를 지정한다.
    • PARAMETER - 파라미터로 선언된 객체에서 사용 가능
    • 이 외에도 클래스 선언문에 쓸 수 있는 TYPE 등이 있다.
  • @Retention(RetentionPolicy.RUNTIME)
    • 커스텀 어노테이션을 생성할 때 주로 사용
    • RetentionPolicy의 값을 넘겨주는 것으로 어노테이션의 메모리 보유 범위가 결정
    • RUNTIME
      • 어노테이션을 런타임시에까지 사용할 수 있다.
      • JVM이 자바 바이트코드가 담긴 class 파일에서 런타임환경을 구성하고 런타임을 종료할 때까지 메모리는 살아있다.
  • @Interface
    • 어노테이션 클래스로 지정한다는 어노테이션

 

그리고 같은 위치에 LoginUserArgumentResolver를 생성하자. Login-UserArgumentResolver 라는 HandlerMethodArgumentResolver인터페이스를 구현한 클래스이다.

HandlerMethodArgumentResolver는 조건에 맞는 경우 메소드가 있다면, HandlerMethodArgumentResolver의 구현체가 지정한 값으로 해당 메소드의 파라미터로 넘길 수 있다.

src/main/java/com/jojoldu/book/springboot/config/auth/LoginUserArgumentResolver.java

import com.jojoldu.book.springboot.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) { //1
        boolean isLoginUserAnnotation = parameter
                .getParameterAnnotation(LoginUser.class) != null;
        boolean isUserClass = SessionUser.class
                .equals(parameter.getParameterType());

        return isLoginUserAnnotation && isUserClass;

    }

    @Override //2
    public Object resolveArgument(MethodParameter parameter,
                                  ModelAndViewContainer mavContainer,
                                  NativeWebRequest webRequest,
                                  WebDataBinderFactory binderFactory) throws Exception {

        return httpSession.getAttribute("user");
    }
}
  1. supportParameter()
    • 컨트롤러 메서드의 특정 파라미터를 지원하는지 판단
    • 여기서는 파라미터에 @LoginUser어노테이션이 붙어 있고, 파라미터 클래스 타입이Sessionuser.class 인 경우 true를 반환한다.
  2. resolveArgument()
    • 파라미터에 전달할 객체를 생성
    • 여기서는 세션에서 객체를 가져온다

 

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

src/main/java/com/jojoldu/book/springboot/config/WebConfig.java

import com.jojoldu.book.springboot.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);
    }
}
  • addArgumentResolver()에 구현한 HandlerMethodArgumentResolver를 등록
    • HandlerMethodArgumentResolver는 항상 WebMvcConfigurer의 addArgumentResolver()를 통해 추가해야한다.

 

이제 IndexController의 코드에서 반복되는 부분들을 모두 @LoginUser로 개선해보자.

@GetMapping("/")
public String index(Model model, @LoginUser SessionUser user){
  model.addAttribute("posts", postsService.findAllDesc());
//        SessionUser user = (SessionUser) httpSession.getAttribute("user");
  if(user != null) {
    model.addAttribute("userName", user.getName());
  }
  return "index";
}
  • @LoginUser SessionUser user
    • 기존에 (SessionUser)httpSession.getAttribute("user")로 가져오던 세션 정보 값이 개선되었다
    • 이제 어느 컨트롤러이든지 @LoginUser만 사용하면 세션 정보를 가져올 수 있게 되었다

 

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

지금 만든 서비스는 애플리케이션을 재실행하면 로그인이 풀린다. 그 이유는 세션이 내장 톰캣의 메모리에 저장되기 때문이다. 기본적으로 세션은 실행되는 WAS의 메모리에서 저장되고 호출된다. 메모리에 저장되다 보니 내장 톰캣처럼 애플리케이션 실행 시 실행되는 구조에선 항상 초기화가 된다.

즉, 배포할 때마다 톰캣이 재시작 되는 것이다.

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

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

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

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

사용자가 없는 현재 단계에서는 DB로 모든 기능을 처리하는게 부담이 적다. 만약 본인이 운영 중인 서비스가 커진다면 한번 고려해 보고, 이 과정에서는 데이터베이스를 사용하겠다.

 

spring-session-jdbc 등록

먼저 build.gradle에 의존성을 등록한다.

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

 

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

spring.session.store-type=jdbc

로그인을 테스트한뒤, h2-console로 접속하면 세션을 위한 테이블이 2개가 생성된 것을 볼 수 있다. JPA로 인해 세션 테이블이 자동 생성되었기 때문에 별도로 해야 할 일은 없다.

물론, 지금은 기존과 동일하게 스프링을 재시작하면 세션이 풀린다. 이유는 H2기반으로 스프링이 재실행될때 H2도 재시작되기 때문이다. 이후 AWS로 배포하게 되면 AWS의 데이터베이스 서비스인 RDS를 사용하게 되니 이때부터는 세션이 풀리지 않는다.

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

 

6. 네이버 로그인

먼저 네이버 오픈 api로 이동한다.

서비스 URL은 필수이므로 localhost:8080으로 등록한다. callback Url은 구글에서 등록한 리디렉션 URL과 같은 역할을 한다. /login/oauth2/code/naver로 등록한다. 등록을 완료시 ClientID와 ClientSecret이 생성된다.

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

#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 형태 때문

 

스프링 시큐리티에선 하위 필드를 명시할 수 없다. 최상위 필드들만 user_name으로 지정이 가능하다. 하지만 네이버의 응답값 최상위 필드는 resultCode, message, response이다.

이러한 이유로 스프링 시큐리티에서 인식 가능한 필드는 저 3개중에 골라야 한다. 본문에서 담고있는 response를 user_name으로 지정하고 이후 자바 코드로 response의 id를 user_name으로 지정하자.

 

스프링 시큐리티 설정 등록

구글 로그인을 등록하면서 대부분 코드가 확장성 있게 작성되었다보니 네이버는 쉽게 등록이 가능하다.

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

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

마지막으로 index.mustache에 네이버 로그인 버튼을 추가해주자.

src/main/resources/templates/index.mustache

...
  {{^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}}
...
  • /oauth2/authorization/naver
    • 네이버 로그인 URL은 application-oauth.properties에 등록한 redirect-uri 값에 맞춰 자동으로 등록된다.
    • /oauth2/authorization/까지는 고정이고 마지막 Path만 각 소셜 로그인 코드를 사용하면 된다.

 

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

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

인텔리제이 오른쪽 위에 [Gradle] 탭을 클릭한다 [Tasks ⇨ verification ⇨ test]를 차례로 선택해서 전체 테스트를 수행해보자. test를 실행해보면 롬복을 이용한 테스트 외에 스프링을 이용한 테스트는 모두 실패하는 것을 확인할 수 있다. 그 이유를 하나씩 확인해보자.

 

(1) properties 적용되는 범위에 대한 문제

  • test에 application.properties가 없으면 main의 설정을 그대로 가져온다
    • 자동으로 가져오는 옵션의 범위는 application.properties 파일 까지이다
    • 즉, application-oauth.properties는 test에 파일이 없다고 자동으로 main에서 가져오는 것이 아니다
  • 위와 같은 문제를 해결하기 위해 test환경에 application.properties를 새로 작성
    • main의 application-oauth.properties의 설정 값은 가짜 설정 값을 등록

src/test/resources/application.properties

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL57Dialect
spring.jpa.properties.hibernate.dialect.storage_engine=innodb
spring.datasource.hikari.jdbc-url=jdbc:h2:mem:testdb;MODE=MYSQL

spring.h2.console.enabled=true

spring.profiles.include=oauth
spring.session.store-type=jdbc

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) 인증된 가짜 사용자 만들기

"Posts_등록된다" 테스트 로그를 확인해보면 응답의 결과로 200(정상 응답) Status Code를 원했는데 결과는 302(리다이렉션 응답) Status Code가 와서 실패했다는 것을 볼 수 있다. 이는 스프링 시큐리티 설정 때문에 인증되지 않은 사용자의 요청은 이동시키기 때문이다. 이런 API 요청은 임의로 인증된 사용자를 추가하여 API만 테스트해 볼 수 있게 하자.

build.gradle에 spring-security-test 추가

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

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

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

@Test
@WithMockUser(roles = "USER")
public void Posts_수정() throws Exception {...}
  • @WithMockUser(roles="USER)
    • 인증된 가짜 사용자를 만들어서 사용한다.
    • ROLE_USER권한을 가진 사용자가 API를 요청하는 것과 동일한 효과를 가지게 해준다.
    • 해당 어노테이션은 MockMvc에서만 작동한다.

 

현재 PostsApiControllerTest 는 @SpringBootTest로만 되어있으며, MockMvc를 사용하지 않으므로 코드를 다음과 같이 변경해보자.

package com.jojoldu.book.springboot.web;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.jojoldu.book.springboot.domain.posts.Posts;
import com.jojoldu.book.springboot.domain.posts.PostsRepository;
import com.jojoldu.book.springboot.web.dto.PostsSaveRequestDto;
import com.jojoldu.book.springboot.web.dto.PostsUpdateRequestDto;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
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.junit.jupiter.SpringExtension;
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;

@ExtendWith(SpringExtension.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)

public class PostsApiControllerTest {
        ...
    @Autowired
    private WebApplicationContext context;

    private MockMvc mvc;

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

    ...

    @Test
    @WithMockUser(roles = "USER")
    void Posts_등록된다() throws Exception {
        ...

        //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);
        assertThat(all.get(0).getAuthor()).isEqualTo(author);
    }

    @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);
    }
}
  • mvc.perform
    • 생성된 MockMvc를 통해 API를 테스트 한다.
    • 본문(Body)영역은 문자열로 표현하기 위해 ObjectMapper를 통해 문자열 JSON으로 변환한다.

 

 

반응형
저작자표시
profile

Peony의 기록 창고 🌼

@myeongju

검색 태그

Dijkstra
TDD
BOJ
algorithm
springboot
JPA
beakjoon
Security
Spring
java
사방탐색
운영체제
react
프리코스
우테코
OS
컴퓨터 시스템 구조
구름톤팰린지
켄트벡
aws
양방향 인접리스트
Spting
PostgreSQL
5기
ubuntu
Sprng
모던자바인액션
BigInteger
stack
Docker

티스토리툴바