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

---

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

스프링 시큐리티(Spring Security)는 막강한 인증(Authentication)과 인가(Authorization) 기능을 가진 프레임워크이다

 

구글이나 네이버등 소셜 로그인을 지원하는 어플리케이션을 쉽게 찾아볼 수 있다.

로그인도 간편하며, 연동되는 외부 웹 어플리케이션에서 제공하는 기능들을 간편하게 사용할 수 있다.

 

이 때 사용되는 프로토콜이 바로 OAuth다.

프로토콜(Protocol)이란?
통신 프로토콜 또는 통신 규약은 컴퓨터나 원거리 통신 장비 사이에서 메시지를 주고 받는 양식과 규칙의 체계이다. 즉 통신 규약 및 약속이다.

OAuth의 정의?
OAuth는 인터넷 사용자들이 비밀번호를 제공하지 않고 다른 웹사이트 상의 자신들의 정보에 대해 웹사이트나 애플리케이션의 접근 권한을 부여할 수 있는 공통적인 수단으로서 사용되는, 접근 위임을 위한 개방형 표준이다.

요즘은 로그인 기능을 아이디/비밀번호로 로그인 하는 방식보다는 구글,페이스북, 네이버 로그인과 같은 소셜 로그인 기능을 사용.

소셜 로그인을 사용하지 않으면 직접 구현해야 하는 것들이 많아지기 때문.

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

OAuth로 로그인을 구현하면 위 목록들을 구글, 페이스북, 로그인에 맡기면 되므로 서비스 개발에 집중할 수 있음.

---

2️⃣ 구글 서비스 등록

1. 구글 클라우드 플랫폼 주소로 들어간다
   https://console.cloud.google.com
2. 프로젝트 선택 > 새 프로젝트 > 원하는 이름으로 프로젝트 생성
3. API 및 시버스 > 사용자 인증 정보 > 사용자 인증 정보 만들기 > OAuth 클라이언트 ID
4. 동의 화면 구성 > OAuth 동의 화면 > 만들기
   4-1. 앱 이름, 사용자 지원 이메일, 개발자 작성
   4-2. 범위 추가 또는 삭제 > email, profile, openid 선택 (기본 범위) > 저장 후 계속
   4-3. (테스트 사용자 skip) 저장 후 계속
5. 다시 사용자 인증 정보 만들기로 돌아가서 > OAuth 클라이언트 ID > 유형 선택하고 이름 작성, 승인된 리디렉션 URI 추가 > 만들기

사용자 인증 정보에서 클라이언트 정보와 인증 정보를 확인할 수 있다. (클라이언트 ID와 클라이언트 보안 비밀 코드 확인하기)

💚 application-oauth 등록

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

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

 

application.properites에 아래 코드를 추가

spring.profiles.include=oauth

💚 .gitignore 등록

gitginore 파일에 코드 추가

application-oauth.properties

---

3️⃣ 구글 로그인 연동하기

domain에 user 패키지를 생성

package com.example.demo.domain.user;

import com.example.demo.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을 생성

package com.example.demo.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 생성

package com.example.demo.domain.user;

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

import java.util.Optional;

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

📌 findByEmail

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

💚 스프링 시큐리티 설정

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

implementation 'org.springframework.boot:spring-boot-starter-oauth2-client'

 

소셜 기능 구현 시 필요한 의존성으로, spring-security-oauth2-client와 spring-security-oauth2-jose를 기본으로 관리해준다.

config.auth 패키지를 생성 후, SecurityConfig 코드 작성

package com.example.demo.config.auth;

import com.example.demo.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
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 코드 작성

package com.example.demo.config.auth;

import com.example.demo.config.auth.dto.OAuthAttributes;
import com.example.demo.config.auth.dto.SessionUser;
import com.example.demo.domain.user.User;
import com.example.demo.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<OAuth2UserRequest, OAuth2User> 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);
        }
}

이 클래스에서는 구글 로그인 이후 가져온 사용자의 정보(email, name, picture등)를 기반으로 가입 및 정보 수정, 세션 저장 등의 기능을 지원

📌 registrationId

• 현재 로그인 진행 중인 서비스를 구분하는 코드
• 여러 소셜 로그인 서비스를 연동할 때 네이버 로그인인지, 구글 로그인인지 구분하기 위해 사용

📌 userNameAttributeName

• OAuth2 로그인 진행 시 키가 되는 필드값, Primary Key와 같은 의미
• 구글의 경우 기본적으로 코드를 지원하지만, 네이버나 카카오 등은 기본 지원하지 않음
• 이후 네이버 로그인과 구글 로그인을 동시 지원할 때 사용

📌 OAuthAttributes

• OAuth2UserService를 통해 가져온 OAuth2User의 attirbute를 담을 클래스

📌 SessionUser

• 세션에 사용자 정보를 저장하기 위한 DTO 클래스
• User 클래스를 그대로 사용하면, User 클래스는 엔티티이기 때문에 언제 다른 엔티티와 관계가 형성될지 모른다.
  User 클래스에 직렬화 코드를 넣으면 직렬화 대상에 자식들까지 포함되어 성능 이슈, 부수 효과가 발생할 확률이 높아진다.
  그러므로 직렬화 기능을 가진 세션 DTO를 하나 추가로 만드는 것이 이후 운영 및 유지보수 때 많은 도움이 된다.

OAuthAttributes 코드 작성

package com.example.demo.config.auth.dto;

import com.example.demo.domain.user.Role;
import com.example.demo.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);
    }

    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 Entity를 생성
• OAuth에서 엔티티를 생성하는 시점은 처음 가입할 때
• 가입할 때 기본 권한으로 GUEST를 주기 위해 role 빌더 값으로 Role.GUSET를 사용

SessionUser 코드 작성

package com.example.demo.config.auth.dto;

import com.example.demo.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();
    }
}

+ User 클래스를 사용하면 안되는 이유?

User 클래스를 그대로 사용하면 직렬화 관련 에러가 뜸. 그렇다고 User 클래스에 직렬화 코드를 넣으면 안된다. User 클래스가 엔티티이기 때문이다. 따라서 직렬화 기능을 가직 세션 Dto를 하나 추가로 만드는게 바람직함

💚 로그인 테스트

index.mustache 코드 수정

{{#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}}

IndexController에서 userName을 model에 저장하는 코드를 추가

@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")

• 로그인 성공 시 httpSession.getAttribute("user")에서 값을 가져올 수 있음

if (user != null)

• 세션에 저장된 값이 있을 때만 model에 userName으로 등록
• 저장된 값이 없으면 model엔 아무런 값이 없는 상태이므로 로그인 버튼만 보임

이후 로그인을 수행해보고 h2-console에서 user 테이블을 확인해보면, 정상적으로 회원정보가 들어간 것을 확인할 수 있음

다만 지금 로그인된 사용자의 권한은 GUEST이기 때문에 posts 기능을 사용할 수 없음 (실제로 테스트해보면 403(권한 거부) 에러가 발생)

h2-console에서 권한을 변경하여 role을 USER로 변경

update "USER" set role = 'USER';

 

책과는 다르게 "USER"로 쳐야지 업데이트가 되더라구요...??

이후 글 작성, 수정 전부 원활하게 되는것을 확인할 수 있음

---

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

• 반복 코드가 있다면 문제가 발생
• 유지보수성이 떨어지며, 혹시나 수정이 반영되지 않은 코드가 있다면 문제가 발생할 수 있음
• 앞선 코드에서 개선할만한 부분은 IndexController에서 세션값을 가져오는 부분임

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

• index 메소드에서만 사용되지만, 다른 컨트롤러와 메소드에서 세션값이 필요하면 그때마다 직접 세션에서 값을 가져와야 한다.
• 이 부분을 메소드 인자로 세션값을 바로 받을 수 있도록 변경하도록 하겠다.

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

package com.example.demo.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 {
}

📌 @Target(ElementType.PARAMETER)

• 어노테이션이 생성될 수 있는 위치를 지정
• PARAMETER → 메소드의 파라미터로 선언된 객체에서만 사용 가능

📌 @interface

• 해당 파일을 어노테이션 클래스로 지정
• 이제 LoginUser라는 어노테이션이 생김

LoginUserArgumentResolver 클래스 생성

package com.example.demo.config.auth;

import com.example.demo.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;
        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()

• 파라미터에 전달할 객체를 생성
• 여기서는 세션에서 객체를 가져온다.

config 패키지에 WebConfig 클래스를 생성

package com.example.demo.config;

import com.example.demo.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);
    }
}

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

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

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

기존에 (User) httpSessoin.getAttribute("user")로 가져오던 세션 정보 값을 파라미터로 가져올 수 있다.
이제 어느 컨트롤러든 @LoginUser만 사용하면 세션 정보를 가져올 수 있게 되었다

---

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

• 애플리케이션을 재실행하면 로그인이 풀리는 문제가 있다
• 이는 세션이 내장 톰캣의 메모리에 저장되기 때문이다
• 내장 톰캣처럼 애플리케이션 실행 시 실행되는 구조에서는 항상 초기화 된다
• 즉, 배포할 때마다 톰캣이 재시작된다

이외에도 2대 이상의 서버에서 서비스하고 있다면 톰캣마다 세션 동기화 설정을 해야만 한다.

 

실제 현업에서는 이 3가지 방법 중 한가지를 선택하여 문제를 해결

 

1️⃣ 톰캣 세션을 이용

• 기본적인 방식
• 2대 이상의 WAS가 구동되는 환경에서는 톰캣들 간의 세션 공유를 위한 추가 설정이 필요

2️⃣ MySQL과 같은 데이터베이스를 세션 저장소로 이용

• 여러 WAS 간의 공용 세션을 사용할 수 있는 가장 쉬운 방법
• 로그인 요청마다 DB IO가 발생하여 성능상 이슈가 발생할 수 있음
• 로그인 요청이 많이 없는 백오피스, 사내 시스템 용도에서 사용

3️⃣ Redis, Memcached와 같은 메모리 DB를 세션 저장소로 이용

• B2C 서비스에서 가장 많이 사용
• 실제 서비스로 사용하기 위해서는 외부 메모리 서버 필요

여기서는 2번째 방식인 데이터베이스를 세션 저장소로 사용하여 진행한다

💚 spring-session-jdbc 등록

build.gradle에 의존성을 추가

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

application.properties에 세션 저장소를 jdbc로 선택하도록 함

spring.session.store-type=jdbc

h2-console 접속 시, 세션을 위한 테이블 2개 (SPRING_SESSION, SPRING_SESSION_ATTRIBUTES)가 생성된것을 확인할 수 있음

---

6️⃣ 네이버 로그인

💚 네이버 API 등록

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

등록하면 구글 로그인 처럼 ClientIDd와 Client Secret을 발급받는다

해당 키 값들을 application-oauth.properties에 추가

# registration
spring.security.oauth2.client.registration.naver.client-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로 하도록 함

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

{
	"resultcode": "00",
    "message": "success",
    "response": {
    	"email": "openapi@naver.com",
        "nickname": "OpenAPI",
        "profile_image": "https://ssl.pstatic.net/static/pwe/address/nodata_33x33.gif",
        "age": "40-49",
        "gender": "F",
        "id": "32742776",
        "name": "오픈 API",
        "birthday": "10-01"
    }
}

💚 스프링 시큐리티 설정 등록

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

package com.example.demo.config.auth.dto;

import com.example.demo.domain.user.Role;
import com.example.demo.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) {
        if ("naver".equals(registrationId)) {
            return ofNaver("id", 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();
    }
    
    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();
    }

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

index.mustache에서 구글 로그인 버튼 아래 네이버 로그인 버튼을 추가

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

짠

---

💻 Reference

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

어노테이션 기반 구글 로그인 리팩토링 + 네이버 로그인 구현