[Spring] REST API 카카오 로그인 구현하기

BackEnd/Spring Boot

[Spring] REST API 카카오 로그인 구현하기

ddonghyeo 2024. 5. 20. 14:56

카카오 공식 문서를 기반으로 작성
https://developers.kakao.com/docs/latest/ko/kakaologin/common

구현 코드
https://github.com/DDonghyeo/kakao-login

참고
이 글은 절차에 따라 코드를 완성해 나가는 과정입니다. 전체 코드는 깃허브를 참고해 주세요.
프론트(클라이언트) 부분은 thymeleaf로 구현하였습니다.
Spring Boot 3.x.x 버전 기준입니다.

먼저 , 카카오 로그인 방식에 대해 이해하고 시작해야 한다.

https://developers.kakao.com/docs/latest/ko/kakaologin/common

아래처럼 정리하고 진행하겠다.

카카오 로그인 요청
- 사용자가 로그인을 요청한다. 미리 설정해둔 client_id (REST API KEY) + redirect URI 가 설정된 링크로 들어간다.
사용자가 카카오 로그인
- 카카오 로그인 창으로 redirect 되며 사용자가 카카오 아이디로 로그인한다.
앱에 등록된 Redirect URI와 같이 code 전달 받기
- 로그인이 완료되면 미리 설정해둔 redirect uri로 돌아오며, 파라미터 code로 인가코드를 받는다.
- 인가코드는 카카오가 전달해주는 코드이다.
code를 통해 토큰 발급 요청
- 받은 인가코드를 카카오에 보내면 access token, refresh token을 받는다.
받은 토큰으로 사용자 정보 가져오기
- 받은 access token을 카카오에게 보내서 사용자 정보를 요청한다.
회원가입, 또는 로그인 처리
- 받은 사용자 정보로 서버 내에서 회원가입, 로그인 처리를 한다.

0. Settings

0-1. 애플리케이션 생성

먼저, 카카오에서 애플리케이션을 추가해야 한다.

https://developers.kakao.com/

카카오 Developer에서 로그인을 하고 내 애플리케이션에 들어가자.

애플리케이션 추가하기를 누른다.

원하는 이름을 작성하고 저장을 누른다.

새 애플리케이션이 만들어졌다.

애플리케이션을 눌러서 들어갔을 때, 앱 키 칸에서 키를 볼 수 있다.

우리는 REST API를 이용할 것이기 때문에 REST API 키를 복사해두자.

0-2. 동의 항목 설정

동의항목에 들어가 카카오 로그인 과정에서 사용자로부터 받을 정보를 설정할 수 있다.

일부 항목은 필수 동의로 설정할 수 있지만, 일부는 카카오 내에서 검수가 필요하다.

다른 항목 또한 설정하고 싶다면, 비즈 앱으로 전환하면 설정할 수 있다.

일단은 닉네임과 프로필 사진을 필수 동의로 설정하고 넘어가겠다.

‼️ Email을 받을 수 없으면, 서버 내에서 사용자 식별을 어떻게 하나요?
닉네임은 unique한 값이 아니기 때문에 회원 식별용으로 사용할 수 없지만,
카카오 내에 auth_id로 사용자를 식별할 수 있다.

0-3. RedirectURI 등록

카카오로그인 탭에 들어가서 활성화를 설정해주면, RedirectURI를 등록할 수 있다.

사용자가 카카오 로그인을 성공하면, 카카오 측에서 Client를 Redirect 해줄 URI를 설정해주는 것이다.

한 마디로, 카카오 측에서 "우리 로그인 완료되면 어디로 보내줄까?" 를 정해두는 것이다.

*여기서 등록한 RedirectURI만 사용할 수 있다. 사용할 서버의 도메인 URI중 하나를 등록하자.
*여기서 사용할 RedirectURI는 위 과정 중 3번 -> 4번 과정에서 사용하는 URI에 해당한다.

임시 테스트 용으로 위와 같이 등록했다.

0-4. 의존성 추가

build.gradle

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-web'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
	compileOnly 'org.projectlombok:lombok'
	annotationProcessor 'org.projectlombok:lombok'

	//Webflux
	implementation 'org.springframework.boot:spring-boot-starter-webflux'

	//thymeleaf
	implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
}

HTTP 요청을 Webflux Webclient로 구현했다.

만약 카카오 로그인 페이지를 직접 구현하지 않을 예정이라면, thymeleaf는 추가하지 않아도 된다.

1. 카카오 로그인 요청

사용자가 카카오 로그인을 하는 과정이다.

이 부분은 프론트의 개입이 반드시 필요하다.

사용자가 브라우저를 통해 카카오 로그인 링크를 들어가 로그인 과정을 거쳐야 하기 때문이다.

1-1. 로그인 페이지 만들기

https://developers.kakao.com/docs/latest/ko/kakaologin/design-guide

카카오에서 버튼 디자인에 대한 가이드를 제공한다.

png를 직접 다운받고, thymeleaf를 써서 구현해 보았다.

build.gradle 의존성 추가

implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'

application.yml -> 초기에 세팅했던 REST API 키, Redirect URI를 등록

kakao:
  client_id: {REST API KEY}
  redirect_uri: http://localhost:8080/callback

1-2. Page Controller

Page Controller

로그인 페이지를 반환해줄 컨트롤러

@Controller
@RequestMapping("/login")
public class KakaoLoginPageController {

    @Value("${kakao.client_id}")
    private String client_id;

    @Value("${kakao.redirect_uri}")
    private String redirect_uri;

    @GetMapping("/page")
    public String loginPage(Model model) {
        String location = "https://kauth.kakao.com/oauth/authorize?response_type=code&client_id="+client_id+"&redirect_uri="+redirect_uri;
        model.addAttribute("location", location);

        return "login";
    }
}

1-3. Login Page HTML

resources/templates/login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>KakaoLogin</title>
</head>
<body>
<div class="container" style="display: flex; justify-content: center; align-content: center; align-items: center; flex-direction: column; margin: 200px auto; ">
    <h1>카카오 로그인</h1>
    <a th:href="${location}">
        <img src="/kakao_login_medium_narrow.png" >
    </a>
</div>
</body>
</html>

/resources/static 경로에 png파일을 추가

이제, http://localhost:8080/login/page 에 접속하면

2. 사용자가 카카오 로그인

카카오 로그인은 파라미터로 REST API키와 redirect uri가 첨부된 카카오 로그인 링크로 들어가며 시작된다.

https://kauth.kakao.com/oauth/authorize?response_type=code&client_id=${REST_API_KEY}&redirect_uri=${REDIRECT_URI}

만약 thymeleaf로 구현하지 않았다면, 그냥 링크를 브라우저에서 직접 접속할 수도 있다.

‼️ Tip
여러번 테스트하면 캐시때문에 자동 로그인 되니 캐시 삭제 후 테스트하거나 브라우저 시크릿 모드로 활용

해당 링크로 들어가보면, 초기에 설정했던 동의항목과 함께 로그인을 진행할 수 있다.

등록해둔 Redirect URI에 파라미터로 code와 함께 Redirect되는 것을 확인할 수 있다.

3. 앱에 등록된 Redirect URI와 같이 code 전달 받기

그럼 이제, Redirect된 URI에 전달된 code를 가져와보자.

3-1. KakaoLoginController

KakaoLoginController (추후에 더 수정됨)

@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("")
public class KakaoLoginController {

    @GetMapping("/callback")
    public ResponseEntity<?> callback(@RequestParam("code") String code) {

        return new ResponseEntity<>(HttpStatus.OK);
    }
}

위와 같이, 등록해둔 URI에 GetMapping을 해두면 파라미터 code와 함께 받을 수 있을 것이다.

4. code를 통해 토큰 발급 요청

이제 카카오로부터 받은 code를 카카오에 토큰 발급 요청을 하면, 사용자 정보가 담겨있는 토큰을 받을 수 있다.

https://kauth.kakao.com/oauth/token URL로 POST 요청을 보내면, 토큰을 받을 수 있다.

토큰까지 받아야 로그인이 카카오 로그인이 완료된다!

4-1. KakaoService

KakaoTokenResponseDto.java

@Getter
@NoArgsConstructor //역직렬화를 위한 기본 생성자
@JsonIgnoreProperties(ignoreUnknown = true)
public class KakaoTokenResponseDto {

    @JsonProperty("token_type")
    public String tokenType;
    @JsonProperty("access_token")
    public String accessToken;
    @JsonProperty("id_token")
    public String idToken;
    @JsonProperty("expires_in")
    public Integer expiresIn;
    @JsonProperty("refresh_token")
    public String refreshToken;
    @JsonProperty("refresh_token_expires_in")
    public Integer refreshTokenExpiresIn;
    @JsonProperty("scope")
    public String scope;
}

카카오로부터 받은 Response DTO를 미리 만들어 둔다.

역직렬화를 위해 @JsonProperty를 이용하여 매핑해주고, default 생성자를 선언해둔다.

자세한 API는 https://developers.kakao.com/docs/latest/ko/kakaologin/rest-api#request-token 에서 확인

kakaoService.java (추후에 더 추가됨)

@Slf4j
@RequiredArgsConstructor
@Service
public class KakaoService {

    private String clientId;
    private final String KAUTH_TOKEN_URL_HOST;
    private final String KAUTH_USER_URL_HOST;

    @Autowired
    public KakaoService(@Value("${kakao.client_id}") String clientId) {
        this.clientId = clientId;
        KAUTH_TOKEN_URL_HOST ="https://kauth.kakao.com";
        KAUTH_USER_URL_HOST = "https://kapi.kakao.com";
    }

    public String getAccessTokenFromKakao(String code) {
        
        KakaoTokenResponseDto kakaoTokenResponseDto = WebClient.create(KAUTH_TOKEN_URL_HOST).post()
                .uri(uriBuilder -> uriBuilder
                        .scheme("https")
                        .path("/oauth/token")
                        .queryParam("grant_type", "authorization_code")
                        .queryParam("client_id", clientId)
                        .queryParam("code", code)
                        .build(true))
                .header(HttpHeaders.CONTENT_TYPE, HttpHeaderValues.APPLICATION_X_WWW_FORM_URLENCODED.toString())
                .retrieve()
                //TODO : Custom Exception
                .onStatus(HttpStatusCode::is4xxClientError, clientResponse -> Mono.error(new RuntimeException("Invalid Parameter")))
                .onStatus(HttpStatusCode::is5xxServerError, clientResponse -> Mono.error(new RuntimeException("Internal Server Error")))
                .bodyToMono(KakaoTokenResponseDto.class)
                .block();


        log.info(" [Kakao Service] Access Token ------> {}", kakaoTokenResponseDto.getAccessToken());
        log.info(" [Kakao Service] Refresh Token ------> {}", kakaoTokenResponseDto.getRefreshToken());
        //제공 조건: OpenID Connect가 활성화 된 앱의 토큰 발급 요청인 경우 또는 scope에 openid를 포함한 추가 항목 동의 받기 요청을 거친 토큰 발급 요청인 경우
        log.info(" [Kakao Service] Id Token ------> {}", kakaoTokenResponseDto.getIdToken());
        log.info(" [Kakao Service] Scope ------> {}", kakaoTokenResponseDto.getScope());

        return kakaoTokenResponseDto.getAccessToken();
    }
}

Webclient로 HTTP 요청을 구현했다.

각 서비스마다 Custom Exception이 있다면 onStatus 메서드에 지정하면 되겠다.

HTTP 요청을 받아오면 .retrieve() 메서드 부터, Request Body 내용이

미리 지정해둔 KakaoTokenResponseDto에 json이 직렬화되어 들어가게 된다.

https://kauth.kakao.com/oauth/token?grant_type=authorization_code&client_id=${client_id}&code=${code}

위 url에 POST 요청을 보내면, 받은 Response의 Body에 아래 내용을 받을 수 있다.

요청 예시

curl -v -X POST "https://kauth.kakao.com/oauth/token" \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "grant_type=authorization_code" \
-d "client_id=${REST_API_KEY}" \
--data-urlencode "redirect_uri=${REDIRECT_URI}" \
-d "code=${AUTHORIZE_CODE}"

응답 예시

HTTP/1.1 200 OK
Content-Type: application/json;charset=UTF-8
{
    "token_type":"bearer",
    "access_token":"${ACCESS_TOKEN}",
    "expires_in":43199,
    "refresh_token":"${REFRESH_TOKEN}",
    "refresh_token_expires_in":5184000,
    "scope":"account_email profile"
}

여기서 expire은 기한,

scope는 사용자로부터 받은 정보들의 항목이다.

이를 통해 카카오로부터 토큰을 발급받았다.

구현한 Service를 Controller에서 연동하자.

4-2. KakaoLoginController

KakaoLoginController.java (추후에 더 수정됨)

@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("")
public class KakaoLoginController {

    private final KakaoService kakaoService;

    @GetMapping("/callback")
    public ResponseEntity<?> callback(@RequestParam("code") String code) throws IOException {
        String accessToken = kakaoService.getAccessTokenFromKakao(code);
        return new ResponseEntity<>(HttpStatus.OK);
    }
}

이제 code를 이용해서 accessToken을 받아올 수 있게 됐다.

‼️ 여기까지 토큰을 받았으므로, 카카오 로그인이 완료된 상황이다.
여기서 멈춰서 받은 토큰을 통해 인증, 인가를 구현해도 되지만,
추가로 토큰을 이용하여 사용자 정보를 받은 후 서버에 회원가입을 구현하려고 한다.

5. 받은 토큰으로 사용자 정보 가져오기

이제, 카카오에서 받은 access token으로 사용자 정보를 가져오자.

5-1. KakaoService (추가)

KakaoUserInfoResponseDto.java

@Getter
@NoArgsConstructor //역직렬화를 위한 기본 생성자
@JsonIgnoreProperties(ignoreUnknown = true)
public class KakaoUserInfoResponseDto {

    //회원 번호
    @JsonProperty("id")
    public Long id;

    //자동 연결 설정을 비활성화한 경우만 존재.
    //true : 연결 상태, false : 연결 대기 상태
    @JsonProperty("has_signed_up")
    public Boolean hasSignedUp;

    //서비스에 연결 완료된 시각. UTC
    @JsonProperty("connected_at")
    public Date connectedAt;

    //카카오싱크 간편가입을 통해 로그인한 시각. UTC
    @JsonProperty("synched_at")
    public Date synchedAt;

    //사용자 프로퍼티
    @JsonProperty("properties")
    public HashMap<String, String> properties;

    //카카오 계정 정보
    @JsonProperty("kakao_account")
    public KakaoAccount kakaoAccount;

    //uuid 등 추가 정보
    @JsonProperty("for_partner")
    public Partner partner;

    @Getter
    @NoArgsConstructor
    @JsonIgnoreProperties(ignoreUnknown = true)
    public class KakaoAccount {

        //프로필 정보 제공 동의 여부
        @JsonProperty("profile_needs_agreement")
        public Boolean isProfileAgree;

        //닉네임 제공 동의 여부
        @JsonProperty("profile_nickname_needs_agreement")
        public Boolean isNickNameAgree;

        //프로필 사진 제공 동의 여부
        @JsonProperty("profile_image_needs_agreement")
        public Boolean isProfileImageAgree;

        //사용자 프로필 정보
        @JsonProperty("profile")
        public Profile profile;

        //이름 제공 동의 여부
        @JsonProperty("name_needs_agreement")
        public Boolean isNameAgree;

        //카카오계정 이름
        @JsonProperty("name")
        public String name;

        //이메일 제공 동의 여부
        @JsonProperty("email_needs_agreement")
        public Boolean isEmailAgree;

        //이메일이 유효 여부
        // true : 유효한 이메일, false : 이메일이 다른 카카오 계정에 사용돼 만료
        @JsonProperty("is_email_valid")
        public Boolean isEmailValid;

        //이메일이 인증 여부
        //true : 인증된 이메일, false : 인증되지 않은 이메일
        @JsonProperty("is_email_verified")
        public Boolean isEmailVerified;

        //카카오계정 대표 이메일
        @JsonProperty("email")
        public String email;

        //연령대 제공 동의 여부
        @JsonProperty("age_range_needs_agreement")
        public Boolean isAgeAgree;

        //연령대
        //참고 https://developers.kakao.com/docs/latest/ko/kakaologin/rest-api#req-user-info
        @JsonProperty("age_range")
        public String ageRange;

        //출생 연도 제공 동의 여부
        @JsonProperty("birthyear_needs_agreement")
        public Boolean isBirthYearAgree;

        //출생 연도 (YYYY 형식)
        @JsonProperty("birthyear")
        public String birthYear;

        //생일 제공 동의 여부
        @JsonProperty("birthday_needs_agreement")
        public Boolean isBirthDayAgree;

        //생일 (MMDD 형식)
        @JsonProperty("birthday")
        public String birthDay;

        //생일 타입
        // SOLAR(양력) 혹은 LUNAR(음력)
        @JsonProperty("birthday_type")
        public String birthDayType;

        //성별 제공 동의 여부
        @JsonProperty("gender_needs_agreement")
        public Boolean isGenderAgree;

        //성별
        @JsonProperty("gender")
        public String gender;

        //전화번호 제공 동의 여부
        @JsonProperty("phone_number_needs_agreement")
        public Boolean isPhoneNumberAgree;

        //전화번호
        //국내 번호인 경우 +82 00-0000-0000 형식
        @JsonProperty("phone_number")
        public String phoneNumber;

        //CI 동의 여부
        @JsonProperty("ci_needs_agreement")
        public Boolean isCIAgree;

        //CI, 연계 정보
        @JsonProperty("ci")
        public String ci;

        //CI 발급 시각, UTC
        @JsonProperty("ci_authenticated_at")
        public Date ciCreatedAt;

        @Getter
        @NoArgsConstructor
        @JsonIgnoreProperties(ignoreUnknown = true)
        public class Profile {

            //닉네임
            @JsonProperty("nickname")
            public String nickName;

            //프로필 미리보기 이미지 URL
            @JsonProperty("thumbnail_image_url")
            public String thumbnailImageUrl;

            //프로필 사진 URL
            @JsonProperty("profile_image_url")
            public String profileImageUrl;

            //프로필 사진 URL 기본 프로필인지 여부
            //true : 기본 프로필, false : 사용자 등록
            @JsonProperty("is_default_image")
            public String isDefaultImage;

            //닉네임이 기본 닉네임인지 여부
            //true : 기본 닉네임, false : 사용자 등록
            @JsonProperty("is_default_nickname")
            public Boolean isDefaultNickName;

        }
    }

    @Getter
    @NoArgsConstructor
    @JsonIgnoreProperties(ignoreUnknown = true)
    public class Partner {
        //고유 ID
        @JsonProperty("uuid")
        public String uuid;
    }

}

카카오에서 받을 수 있는 내용을 모두 기재했다.

간단한 설명은 주석으로 추가해 두었다.

여기서, 사용자가 동의한 항목만 담겨지고, 동의하지 않은 항목은 null로 들어오게 된다.

동의 항목을 고려하여 자유롭게 커스텀하면 되겠다.

KakaoService에 추가

public KakaoUserInfoResponseDto getUserInfo(String accessToken) {

        KakaoUserInfoResponseDto userInfo = WebClient.create(KAUTH_USER_URL_HOST)
                .get()
                .uri(uriBuilder -> uriBuilder
                        .scheme("https")
                        .path("/v2/user/me")
                        .build(true))
                .header(HttpHeaders.AUTHORIZATION, "Bearer " + accessToken) // access token 인가
                .header(HttpHeaders.CONTENT_TYPE, HttpHeaderValues.APPLICATION_X_WWW_FORM_URLENCODED.toString())
                .retrieve()
                //TODO : Custom Exception
                .onStatus(HttpStatusCode::is4xxClientError, clientResponse -> Mono.error(new RuntimeException("Invalid Parameter")))
                .onStatus(HttpStatusCode::is5xxServerError, clientResponse -> Mono.error(new RuntimeException("Internal Server Error")))
                .bodyToMono(KakaoUserInfoResponseDto.class)
                .block();

        log.info("[ Kakao Service ] Auth ID ---> {} ", userInfo.getId());
        log.info("[ Kakao Service ] NickName ---> {} ", userInfo.getKakaoAccount().getProfile().getNickName());
        log.info("[ Kakao Service ] ProfileImageUrl ---> {} ", userInfo.getKakaoAccount().getProfile().getProfileImageUrl());

        return userInfo;
    }

마찬가지로 Webclient로 구현했다.

위 로직은

https://kapi.kakao.com/v2/user/me

위 URL의 헤더 Authorization에 Bearer token을 추가해서 GET요청을 보내면, Response에 아래와 같은 Body를 받을 수 있다.

자세한건 https://developers.kakao.com/docs/latest/ko/kakaologin/rest-api#req-user-info 에서 확인

Response Body (예시)

HTTP/1.1 200 OK
{
    "id":123456789,
    "connected_at": "2022-04-11T01:45:28Z",
    "kakao_account": { 
        // 프로필 또는 닉네임 동의항목 필요
        "profile_nickname_needs_agreement": false,
        // 프로필 또는 프로필 사진 동의항목 필요
        "profile_image_needs_agreement": false,
        "profile": {
            // 프로필 또는 닉네임 동의항목 필요
            "nickname": "홍길동",
            // 프로필 또는 프로필 사진 동의항목 필요
            "thumbnail_image_url": "http://yyy.kakao.com/.../img_110x110.jpg",
            "profile_image_url": "http://yyy.kakao.com/dn/.../img_640x640.jpg",
            "is_default_image":false,
            "is_default_nickname": false
        },
        // 이름 동의항목 필요
        "name_needs_agreement":false, 
        "name":"홍길동",
        // 카카오계정(이메일) 동의항목 필요
        "email_needs_agreement":false, 
        "is_email_valid": true,   
        "is_email_verified": true,
        "email": "sample@sample.com",
        // 연령대 동의항목 필요
        "age_range_needs_agreement":false,
        "age_range":"20~29",
        // 출생 연도 동의항목 필요
        "birthyear_needs_agreement": false,
        "birthyear": "2002",
        // 생일 동의항목 필요
        "birthday_needs_agreement":false,
        "birthday":"1130",
        "birthday_type":"SOLAR",
        // 성별 동의항목 필요
        "gender_needs_agreement":false,
        "gender":"female",
        // 카카오계정(전화번호) 동의항목 필요
        "phone_number_needs_agreement": false,
        "phone_number": "+82 010-1234-5678",   
        // CI(연계정보) 동의항목 필요
        "ci_needs_agreement": false,
        "ci": "${CI}",
        "ci_authenticated_at": "2019-03-11T11:25:22Z",
    },
    "properties":{
        "${CUSTOM_PROPERTY_KEY}": "${CUSTOM_PROPERTY_VALUE}",
        ...
    },
    "for_partner": {
        "uuid": "${UUID}"
    }
}

위 json에 담겨있는 정보는 마찬가지로 애플리케이션에서 사용자로부터 어느 정보를 동의 받았는지 에 따라 달라질 수 있다.

동의하지 않았다면 마찬가지로 null이 들어오니 검사하는 로직을 꼭 추가해야 한다.

예를 들어, 앱에 닉네임만 동의 항목에 추가한 경우 Response는 아래와 같다.

HTTP/1.1 200 OK
{
    "id":123456789,
    "connected_at": "2022-04-11T01:45:28Z",
    "kakao_account": { 
        "profile_nickname_needs_agreement": false,
        "profile": {
            "nickname": "홍길동"
        }
    },  
    "properties":{
        "${CUSTOM_PROPERTY_KEY}": "${CUSTOM_PROPERTY_VALUE}",
        ...
    }
}

위 데이터를 파싱해서 필요한 정보들을 이용하여 서버에 회원가입을 하면 되겠다.

5-2. KakaoLoginController (최종)

KakaoLoginController (최종)

@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("")
public class KakaoLoginController {

    private final KakaoService kakaoService;

    @GetMapping("/callback")
    public ResponseEntity<?> callback(@RequestParam("code") String code) {
        String accessToken = kakaoService.getAccessTokenFromKakao(code);

        KakaoUserInfoResponseDto userInfo = kakaoService.getUserInfo(accessToken);

        // 여기에 서버 사용자 로그인(인증) 또는 회원가입 로직 추가
        return new ResponseEntity<>(HttpStatus.OK);
    }
}

이제 로그인을 통해 사용자가 동의한 정보들을 얻을 수 있다.

카카오로부터 받은 정보들을 통해서 서버에 회원가입 로직을 추가하면 되겠다.

카카오에서 받은 토큰으로 인가를 해도 되고, 서버 내에서 사용중인 인가 방법이 있다면 새로 발급해줘도 되겠다.

카카오 공식 문서를 보면,

추가 항목 동의 받기
카카오톡에서 자동 로그인하기
약관 선택해 동의 받기
OpenID Connect ID 토큰 발급하기
기존 로그인 여부와 상관없이 로그인하기
카카오계정 가입 후 로그인하기
로그인 힌트 주기
카카오계정 간편 로그인

등등 기능을 추가로 이용할 수 있으니, 필요한 서비스는 참고해서 이용하면 되겠다.

카카오 REST API Docs
https://developers.kakao.com/docs/latest/ko/kakaologin/rest-api#before-you-begin

저작자표시