🔐 스프링부트에서 카카오 소셜 로그인 구현하기 - 2. 서비스 및 컨트롤러 구현

안녕하세요! 지난 포스팅에서는 카카오 소셜 로그인 구현을 위한 기본 설정과 DTO 클래스들을 알아보았습니다. 이번 글에서는 본격적으로 실제 로그인 기능을 처리하는 서비스와 컨트롤러 코드를 구현해볼게요.

이 글을 통해 OAuth 2.0 인증 흐름을 이해하고, 카카오 API와 통신하는 방법, 사용자 정보를 관리하는 방법 등을 자세히 알아봅시다! 🚀

📋 목차

1. 카카오 로그인 서비스 구현하기
2. 카카오 로그인 컨트롤러 구현하기
3. 전체 로그인 흐름 살펴보기
4. 테스트 및 디버깅 방법
5. 발전시킬 수 있는 부분

카카오 로그인 서비스 구현하기

소셜 로그인의 핵심 비즈니스 로직은 서비스 계층에서 처리합니다. 이제 카카오 API와 통신하고 사용자 인증을 처리하는 서비스 클래스를 만들어 보겠습니다.

1️⃣ 서비스 클래스 기본 구조

@Service
@RequiredArgsConstructor
public class KakaoLoginService {

    // 의존성 주입
    private final KakaoOAuthConfig kakaoOAuthConfig;
    private final UserMapper userMapper;
    private final SocialLoginMapper socialLoginMapper;
    private final LogRepository logRepository;
    private final JwtTokenProvider jwtTokenProvider;
    private final RefreshTokenMapper refreshTokenMapper;
    private final RestTemplate restTemplate;

    // 상수 정의
    private static final int KAKAO_SOCIAL_CODE = 4;  // 카카오 소셜 코드
    private static final String REFRESH_TOKEN_COOKIE_NAME = "refresh_token";
    private static final Duration REFRESH_TOKEN_DURATION = Duration.ofDays(7);
    private static final Duration ACCESS_TOKEN_DURATION = Duration.ofMinutes(30);

    // 메서드들은 아래에 구현
}

💡 Tip: @RequiredArgsConstructor는 final 필드에 대한 생성자를 자동으로 생성해주는 롬복 어노테이션입니다. 스프링의 생성자 기반 의존성 주입을 간결하게 구현할 수 있습니다.

2️⃣ 카카오 인증 URL 생성 메서드

/**
 * 카카오 인증 URL 반환
 * 사용자를 카카오 로그인 페이지로 리다이렉트하기 위한 URL을 생성합니다.
 */
public String getKakaoAuthUrl() {
    return kakaoOAuthConfig.getAuthorizationUrl();
}

이 메서드는 간단하게 설정 클래스에서 생성한 인증 URL을 반환합니다. 컨트롤러에서 이 URL로 사용자를 리다이렉트할 것입니다.

3️⃣ 카카오 로그인 처리 메서드

이제 가장 중요한 로그인 처리 메서드를 구현해봅시다.

/**
 * 카카오 로그인 처리
 * 카카오 인증 후 받은 코드로 액세스 토큰을 요청하고, 사용자 정보를 조회하여 로그인/회원가입을 처리합니다.
 */
@Transactional
public LoginResponseDto kakaoLogin(String code, HttpServletRequest request, HttpServletResponse response) {
    try {
        // 1. 카카오로부터 액세스 토큰 획득
        KakaoTokenResponse tokenResponse = getKakaoAccessToken(code);
        if (tokenResponse == null || tokenResponse.getAccess_token() == null) {
            throw new RuntimeException("Failed to get access token from Kakao");
        }

        // 2. 액세스 토큰으로 카카오 API 호출하여 사용자 정보 획득
        KakaoUserInfoResponse userInfo = getKakaoUserInfo(tokenResponse.getAccess_token());
        if (userInfo == null || userInfo.getId() == null) {
            throw new RuntimeException("Failed to get user info from Kakao");
        }

        // 3. 사용자 정보를 기반으로 회원가입 또는 로그인 처리
        User user = processKakaoUser(userInfo, tokenResponse.getAccess_token());

        // 4. JWT 토큰 생성
        String accessToken = jwtTokenProvider.generateToken(user, ACCESS_TOKEN_DURATION);

        // 5. 리프레시 토큰 생성 및 저장
        String refreshToken = jwtTokenProvider.generateToken(user, REFRESH_TOKEN_DURATION);
        saveRefreshToken(user.getUserNo(), refreshToken, response);

        // 6. 로그인 성공 로그 기록
        saveLog(user.getUserNo(), "KAKAO_LOGIN_SUCCESS",
                "카카오 로그인 성공: " + userInfo.getId(),
                getClientIp(request), request.getHeader("User-Agent"));

        // 7. 로그인 응답 생성
        return LoginResponseDto.builder()
                .userId(user.getUserNo())
                .username(user.getUsername())
                .token(accessToken)
                .build();
    } catch (Exception e) {
        // 로그인 실패 로그 기록
        saveLog(null, "KAKAO_LOGIN_FAIL",
                "카카오 로그인 실패: " + e.getMessage(),
                getClientIp(request), request.getHeader("User-Agent"));
        throw new RuntimeException("Kakao login failed: " + e.getMessage(), e);
    }
}

⚠️ 중요: @Transactional 어노테이션은 메서드 내의 모든 데이터베이스 작업이 하나의 트랜잭션으로 처리되도록 합니다. 중간에 오류가 발생하면 모든 데이터베이스 변경사항이 롤백됩니다.

이 메서드는 다음과 같은 단계로 로그인을 처리합니다:
1. 인증 코드로 카카오 액세스 토큰 요청
2. 액세스 토큰으로 카카오 사용자 정보 요청
3. 사용자 정보로 회원가입 또는 로그인 처리
4. JWT 액세스 토큰 생성
5. 리프레시 토큰 생성 및 저장
6. 로그인 성공 로그 기록
7. 로그인 응답 데이터 반환

4️⃣ 카카오 액세스 토큰 요청 메서드

/**
 * 카카오 액세스 토큰 획득
 * 인증 코드를 사용하여 카카오 API에 액세스 토큰을 요청합니다.
 */
private KakaoTokenResponse getKakaoAccessToken(String code) {
    // 토큰 요청을 위한 헤더 설정
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

    // 토큰 요청 파라미터 설정
    MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
    params.add("grant_type", "authorization_code");  // OAuth 2.0 인증 코드 방식
    params.add("client_id", kakaoOAuthConfig.getClientId());  // REST API 키
    params.add("redirect_uri", kakaoOAuthConfig.getRedirectUrl());  // 리다이렉트 URI
    params.add("code", code);  // 인증 코드

    // 카카오에 토큰 요청
    HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<>(params, headers);
    ResponseEntity<KakaoTokenResponse> response = restTemplate.postForEntity(
            kakaoOAuthConfig.getTokenUrl(),
            request,
            KakaoTokenResponse.class);

    return response.getBody();
}

이 메서드는 인증 코드를 사용하여 카카오 서버에 액세스 토큰을 요청합니다. OAuth 2.0 프로토콜에 따라 필요한 파라미터를 설정하고, RestTemplate을 사용하여 HTTP 요청을 보냅니다.

5️⃣ 카카오 사용자 정보 요청 메서드

/**
 * 카카오 사용자 정보 요청
 * 액세스 토큰을 사용하여 카카오 API에서 사용자 정보를 요청합니다.
 */
private KakaoUserInfoResponse getKakaoUserInfo(String accessToken) {
    // 사용자 정보 요청을 위한 헤더 설정
    HttpHeaders headers = new HttpHeaders();
    headers.setBearerAuth(accessToken);  // Authorization: Bearer {액세스 토큰}
    headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

    // 카카오에 사용자 정보 요청
    HttpEntity<String> request = new HttpEntity<>(headers);
    ResponseEntity<KakaoUserInfoResponse> response = restTemplate.exchange(
            kakaoOAuthConfig.getUserInfoUrl(),
            HttpMethod.POST,
            request,
            KakaoUserInfoResponse.class);

    return response.getBody();
}

액세스 토큰을 사용하여 카카오 API에서 사용자 정보를 가져오는 메서드입니다. 헤더에 Bearer 토큰을 설정하여 인증하고, 응답을 KakaoUserInfoResponse 객체로 매핑합니다.

6️⃣ 사용자 처리 메서드

/**
 * 카카오 사용자 처리 (회원가입 또는 로그인)
 * 카카오 사용자 정보를 기반으로 신규 회원가입 또는 기존 회원 로그인을 처리합니다.
 */
private User processKakaoUser(KakaoUserInfoResponse userInfo, String accessToken) {
    // 카카오 ID로 소셜 로그인 정보 조회
    String kakaoId = String.valueOf(userInfo.getId());
    SocialLogin socialLogin = socialLoginMapper.findByExternalId(kakaoId, KAKAO_SOCIAL_CODE);

    // 이미 카카오로 가입된 사용자인 경우
    if (socialLogin != null) {
        // 액세스 토큰 업데이트
        socialLogin.setAccessToken(accessToken);
        socialLogin.setUpdateDate(LocalDateTime.now());
        socialLoginMapper.update(socialLogin);

        // 사용자 정보 조회
        User user = userMapper.findByUserNo(socialLogin.getUserNo());
        if (user == null) {
            throw new RuntimeException("User not found for social login: " + kakaoId);
        }

        return user;
    }

    // 새로운 사용자 등록 - 이메일로 기존 회원 확인
    String email = userInfo.getEmail();
    User existingUser = null;

    if (email != null && !email.isEmpty()) {
        try {
            // 이메일로 기존 회원 조회
            existingUser = userMapper.findByEmail(email);
        } catch (Exception e) {
            // 이메일로 검색 실패해도 계속 진행
        }
    }

    // 같은 이메일로 가입된 사용자가 있는 경우, 소셜 로그인 정보만 추가
    if (existingUser != null) {
        SocialLogin newSocialLogin = SocialLogin.builder()
                .userNo(existingUser.getUserNo())
                .socialCode(KAKAO_SOCIAL_CODE)
                .externalId(kakaoId)
                .accessToken(accessToken)
                .updateDate(LocalDateTime.now())
                .build();

        // 소셜 로그인 정보 저장
        socialLoginMapper.save(newSocialLogin);

        return existingUser;
    }

    // 완전히 새로운 사용자인 경우 - 회원가입 처리
    String nickname = userInfo.getNickname();
    if (nickname == null || nickname.isEmpty()) {
        nickname = "kakao_user_" + UUID.randomUUID().toString().substring(0, 8);
    }

    // 신규 사용자 생성
    User newUser = User.builder()
            .userName(nickname)
            .loginType(1) // 소셜 로그인
            .email(email)
            .build();

    // 사용자 정보 저장
    userMapper.save(newUser);
    Long userNo = userMapper.getLastInsertId();
    newUser.setUserNo(userNo);

    // 소셜 로그인 정보 저장
    SocialLogin newSocialLogin = SocialLogin.builder()
            .userNo(userNo)
            .socialCode(KAKAO_SOCIAL_CODE)
            .externalId(kakaoId)
            .accessToken(accessToken)
            .updateDate(LocalDateTime.now())
            .build();

    socialLoginMapper.save(newSocialLogin);

    return newUser;
}

이 메서드는 카카오 사용자 정보를 처리하여 세 가지 경우를 처리합니다:

1. 이미 카카오로 로그인한 적이 있는 사용자 - 액세스 토큰만 업데이트
2. 같은 이메일로 가입된 사용자 - 소셜 로그인 정보만 추가
3. 완전히 새로운 사용자 - 회원가입 진행

🔍 TIP: 이메일 기반으로 계정을 통합하면 사용자가 여러 방식(일반 로그인, 카카오 로그인 등)으로 같은 계정에 접근할 수 있습니다.

7️⃣ 리프레시 토큰 및 로그 관련 메서드

이 외에도 다음과 같은 메서드들이 필요합니다:

/**
 * 리프레시 토큰 저장
 * 리프레시 토큰을 데이터베이스와 쿠키에 저장합니다.
 */
private void saveRefreshToken(Long userNo, String refreshToken, HttpServletResponse response) {
    // DB에 리프레시 토큰 저장
    RefreshToken existingToken = refreshTokenMapper.findByUserNo(userNo);

    if (existingToken != null) {
        // 기존 토큰이 있으면 업데이트
        existingToken.setRefreshToken(refreshToken);
        refreshTokenMapper.update(existingToken);
    } else {
        // 새 토큰 생성
        RefreshToken newToken = RefreshToken.builder()
                .userNo(userNo)
                .refreshToken(refreshToken)
                .build();
        refreshTokenMapper.save(newToken);
    }

    // 쿠키에 리프레시 토큰 저장
    int cookieMaxAge = (int) REFRESH_TOKEN_DURATION.toSeconds();

    Cookie cookie = new Cookie(REFRESH_TOKEN_COOKIE_NAME, refreshToken);
    cookie.setPath("/");  // 모든 경로에서 쿠키 접근 가능
    cookie.setHttpOnly(true);  // JavaScript에서 쿠키 접근 불가 (XSS 방지)
    cookie.setMaxAge(cookieMaxAge);  // 쿠키 유효 기간 설정

    response.addCookie(cookie);  // 응답에 쿠키 추가
}

/**
 * 로그인 활동 로그 저장
 */
private void saveLog(Long userNo, String actionType, String description, String ipAddress, String userAgent) {
    Log log = Log.builder()
            .userNo(userNo)
            .actionType(actionType)
            .description(description)
            .ipAddress(ipAddress)
            .userAgent(userAgent != null ? userAgent : "Unknown")
            .status("COMPLETED")
            .createdAt(LocalDateTime.now())
            .build();

    logRepository.save(log);
}

/**
 * 클라이언트 IP 주소 가져오기
 */
private String getClientIp(HttpServletRequest request) {
    String xfHeader = request.getHeader("X-Forwarded-For");
    if (xfHeader == null) {
        return request.getRemoteAddr();
    }
    return xfHeader.split(",")[0].trim();
}

이렇게 서비스 클래스를 완성했습니다! 이제 컨트롤러를 만들어 외부 요청을 처리해보겠습니다.

카카오 로그인 컨트롤러 구현하기

컨트롤러는 외부 HTTP 요청을 받아 서비스 계층으로 전달하고, 그 결과를 클라이언트에게 반환하는 역할을 합니다.

@RestController
@RequestMapping("/api/auth/kakao")
@RequiredArgsConstructor
public class KakaoLoginController {

    private final KakaoLoginService kakaoLoginService;

    /**
     * 카카오 로그인 페이지로 리다이렉트
     */
    @GetMapping("/login")
    public RedirectView kakaoLogin() {
        String kakaoAuthUrl = kakaoLoginService.getKakaoAuthUrl();
        return new RedirectView(kakaoAuthUrl);
    }

    /**
     * 카카오 인증 콜백 처리
     */
    @GetMapping("/callback")
    public ResponseEntity<LoginResponseDto> kakaoCallback(
            @RequestParam("code") String code,
            HttpServletRequest request,
            HttpServletResponse response) {

        LoginResponseDto loginResponse = kakaoLoginService.kakaoLogin(code, request, response);
        return ResponseEntity.ok(loginResponse);
    }
}

이 컨트롤러는 두 개의 엔드포인트를 제공합니다:

1. GET /api/auth/kakao/login - 사용자를 카카오 로그인 페이지로 리다이렉트합니다.
2. GET /api/auth/kakao/callback - 카카오 인증 후 리다이렉트되는 URL로, 인증 코드를 받아 처리합니다.

간단하죠? 복잡한 로직은 모두 서비스 계층에 위임하고, 컨트롤러는 HTTP 요청과 응답만 처리합니다.

전체 로그인 흐름 살펴보기

이제 구현한 코드를 바탕으로 실제 카카오 소셜 로그인의 전체 흐름을 살펴보겠습니다.

1️⃣ 사용자 관점에서의 로그인 흐름

1. 카카오 로그인 버튼 클릭

   • 사용자가 웹사이트에서 "카카오로 로그인" 버튼을 클릭합니다.
   • 브라우저는 /api/auth/kakao/login 엔드포인트로 요청을 보냅니다.

2. 카카오 인증 페이지 표시

   • 백엔드는 사용자를 카카오 로그인 페이지로 리다이렉트합니다.
   • 사용자는 카카오 아이디와 비밀번호를 입력하여 로그인합니다.

3. 권한 동의

   • 처음 로그인하는 경우, 카카오는 앱이 요청하는 정보(닉네임, 이메일 등)에 대한 동의를 요청합니다.
   • 사용자가 동의하면 카카오는 인증 코드와 함께 백엔드의 콜백 URL로 리다이렉트합니다.

4. 백엔드 처리 및 로그인 완료

   • 백엔드는 인증 코드로 액세스 토큰을 요청하고, 사용자 정보를 가져옵니다.
   • 기존 사용자면 로그인 처리를, 신규 사용자면 회원가입 처리를 합니다.
   • JWT 토큰을 생성하여 클라이언트에게 반환합니다.

5. 클라이언트 측 처리

   • 프론트엔드는 JWT 토큰을 받아 저장하고, 이후 API 요청에 사용합니다.
   • 사용자 정보를 화면에 표시하고, 로그인된 상태로 UI를 업데이트합니다.

2️⃣ 기술적 관점에서의 데이터 흐름

카카오 로그인이 어떻게 작동하는지 좀 더 기술적인 관점에서 살펴보겠습니다:

1. 로그인 초기화 (프론트엔드 → 백엔드 → 카카오)

   GET /api/auth/kakao/login → 
   302 Redirect → 
   https://kauth.kakao.com/oauth/authorize?client_id=...&redirect_uri=...&response_type=code

2. 인증 코드 수신 (카카오 → 백엔드)

   GET /api/auth/kakao/callback?code=AUTHORIZATION_CODE

3. 액세스 토큰 요청 (백엔드 → 카카오)

   POST https://kauth.kakao.com/oauth/token
   Content-Type: application/x-www-form-urlencoded
   
   grant_type=authorization_code&
   client_id=REST_API_KEY&
   redirect_uri=CALLBACK_URL&
   code=AUTHORIZATION_CODE

4. 액세스 토큰 응답 (카카오 → 백엔드)

   {
     "token_type": "bearer",
     "access_token": "ACCESS_TOKEN",
     "refresh_token": "REFRESH_TOKEN",
     "expires_in": 21599
   }

5. 사용자 정보 요청 (백엔드 → 카카오)

   POST https://kapi.kakao.com/v2/user/me
   Authorization: Bearer ACCESS_TOKEN

6. 사용자 정보 응답 (카카오 → 백엔드)

   {
     "id": 1234567890,
     "connected_at": "2023-06-15T13:45:22Z",
     "properties": {
       "nickname": "홍길동",
       "profile_image": "https://..."
     },
     "kakao_account": {
       "email": "user@example.com"
     }
   }

7. JWT 토큰 응답 (백엔드 → 프론트엔드)

   {
     "userId": 123,
     "username": "홍길동",
     "token": "JWT_ACCESS_TOKEN"
   }

테스트 및 디버깅 방법

1️⃣ 통합 테스트하기

전체 소셜 로그인 기능을 테스트하는 방법을 알아보겠습니다:

1. 서버 실행

   ./mvnw spring-boot:run

2. 카카오 로그인 URL 접속

   • 브라우저에서 http://localhost:8080/api/auth/kakao/login 접속

3. 인증 과정 확인

   • 카카오 로그인 페이지가 표시되는지 확인
   • 로그인 시도 후 권한 동의 페이지가 나타나는지 확인
   • 콜백 URL로 리다이렉트되는지 확인

4. 응답 확인

   • 브라우저 개발자 도구의 네트워크 탭을 열어 응답 확인
   • HTTP 200 응답 코드와 JSON 데이터 확인
   • JWT 토큰 형식이 올바른지 확인 (jwt.io에서 디코딩 가능)

5. 데이터베이스 확인

   • 사용자 테이블에 레코드가 추가되었는지 확인
   • 소셜 로그인 테이블에 연결 정보가 저장되었는지 확인

2️⃣ 디버깅 팁

로그인 구현 중 발생할 수 있는 일반적인 문제와 해결 방법입니다:

1. 리다이렉트 URI 불일치 오류

   • 카카오 개발자 센터에 등록한 리다이렉트 URI와 코드의 URI가 정확히 일치해야 합니다.
   • 맨 끝의 슬래시(/)나 대소문자 차이도 오류의 원인이 될 수 있습니다.

2. 토큰 요청 실패

   • 요청 헤더와 본문 형식을 정확히 확인하세요.
   • Content-Type이 application/x-www-form-urlencoded로 설정되었는지 확인하세요.
   • 모든 필수 파라미터가 포함되었는지 확인하세요.

3. 사용자 정보 요청 실패

   • Authorization 헤더 형식이 올바른지 확인하세요.
   • 액세스 토큰이 유효한지 확인하세요.

4. 데이터 매핑 오류

   • JSON 응답 구조와 DTO 클래스의 필드명이 일치하는지 확인하세요.
   • 중첩된 객체나 배열에 대한 처리 방식을 확인하세요.

로그를 적극 활용하여 문제를 해결하세요:

log.debug("인증 코드: {}", code);
log.debug("토큰 응답: {}", tokenResponse);
log.debug("사용자 정보: {}", userInfo);

발전시킬 수 있는 부분

이제 기본적인 카카오 소셜 로그인 구현이 완료되었습니다! 하지만 실제 프로덕션 환경에서는 더 고려해야 할 부분들이 있습니다.

1️⃣ 보안 강화

// HTTPS 전용 쿠키 설정
cookie.setSecure(true);  // HTTPS에서만 쿠키 전송
cookie.setSameSite("Strict");  // CSRF 방지

// 액세스 토큰 안전하게 저장
// 프론트엔드에서는 LocalStorage 대신 HttpOnly 쿠키나 메모리에 저장하는 것을 고려하세요

// CSRF 보호 구현
@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());
    }
}

// 토큰 만료 시간 관리
private void validateTokenExpiration() {
    // 주기적으로 만료된 토큰 정리
}

### 2️⃣ 다른 소셜 로그인 추가하기

카카오 로그인 구현 패턴을 활용하면 다른 소셜 로그인도 쉽게 추가할 수 있습니다.

```java
// 공통 인터페이스 정의
public interface SocialLoginService {
    String getAuthorizationUrl();
    LoginResponseDto login(String code, HttpServletRequest request, HttpServletResponse response);
}

// 카카오 로그인 서비스
@Service
public class KakaoLoginServiceImpl implements SocialLoginService {
    // 구현...
}

// 네이버 로그인 서비스
@Service
public class NaverLoginServiceImpl implements SocialLoginService {
    // 구현...
}

// 구글 로그인 서비스
@Service
public class GoogleLoginServiceImpl implements SocialLoginService {
    // 구현...
}

3️⃣ 사용자 경험 개선

소셜 로그인 이후의 사용자 경험을 개선하기 위한 몇 가지 아이디어:

1. 프로필 정보 동기화

   • 카카오 프로필 정보가 업데이트되면 자동으로 동기화
   • 사용자 프로필 페이지에서 연결된 소셜 계정 표시

2. 계정 연동 관리

   • 사용자가 여러 소셜 계정을 하나의 계정에 연결할 수 있는 UI 제공
   • 소셜 계정 연결/해제 기능

3. 로그인 실패 처리

   • 사용자 친화적인 오류 메시지
   • 소셜 로그인 실패 시 대체 로그인 방법 제안

4. 자동 로그인

   • 리프레시 토큰을 활용한 자동 로그인 구현
   • 로그인 상태 유지 옵션

// 소셜 프로필 동기화 예시
@Scheduled(fixedRate = 24 * 60 * 60 * 1000) // 하루에 한 번
public void synchronizeProfiles() {
    List<SocialLogin> kakaoLogins = socialLoginMapper.findAllBySocialCode(KAKAO_SOCIAL_CODE);
    
    for (SocialLogin login : kakaoLogins) {
        try {
            // 최신 프로필 정보 가져오기
            KakaoUserInfoResponse userInfo = getKakaoUserInfo(login.getAccessToken());
            
            // 프로필 정보 업데이트
            User user = userMapper.findByUserNo(login.getUserNo());
            if (user != null && userInfo.getNickname() != null) {
                user.setUsername(userInfo.getNickname());
                userMapper.update(user);
            }
        } catch (Exception e) {
            log.error("프로필 동기화 실패: {}", login.getUserNo(), e);
        }
    }
}

4️⃣ 테스트 코드 작성

마지막으로, 소셜 로그인 구현의 안정성을 높이기 위한 테스트 코드를 작성해보겠습니다.

@SpringBootTest
@AutoConfigureMockMvc
public class KakaoLoginControllerTest {

    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private KakaoLoginService kakaoLoginService;
    
    @Test
    public void testKakaoLogin_ShouldRedirectToKakaoAuthUrl() throws Exception {
        // Given
        String kakaoAuthUrl = "https://kauth.kakao.com/oauth/authorize?client_id=...";
        when(kakaoLoginService.getKakaoAuthUrl()).thenReturn(kakaoAuthUrl);
        
        // When & Then
        mockMvc.perform(get("/api/auth/kakao/login"))
               .andExpect(status().is3xxRedirection())
               .andExpect(redirectedUrl(kakaoAuthUrl));
    }
    
    @Test
    public void testKakaoCallback_ShouldReturnLoginResponse() throws Exception {
        // Given
        String code = "test_auth_code";
        LoginResponseDto loginResponse = new LoginResponseDto(1L, "testUser", "jwt_token");
        
        when(kakaoLoginService.kakaoLogin(eq(code), any(), any())).thenReturn(loginResponse);
        
        // When & Then
        mockMvc.perform(get("/api/auth/kakao/callback")
                .param("code", code))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.userId").value(1))
               .andExpect(jsonPath("$.username").value("testUser"))
               .andExpect(jsonPath("$.token").value("jwt_token"));
    }
}

마무리

지금까지 스프링부트에서 카카오 소셜 로그인을 구현하는 방법에 대해 자세히 알아보았습니다. 기본적인 구현부터 실제 서비스에 적용하기 위한 추가 고려사항까지 다루었습니다.

소셜 로그인은 사용자에게 편리한 로그인 경험을 제공할 뿐만 아니라, 개발자 입장에서도 인증 로직을 간소화하고 보안 부담을 줄일 수 있는 좋은 방법입니다.

다음 글에서는 프론트엔드에서 소셜 로그인 결과를 처리하고 JWT 토큰을 관리하는 방법에 대해 다루도록 하겠습니다. 질문이나 의견이 있으시면 댓글로 남겨주세요! 😊

---

참고 자료

• 카카오 개발자 문서 - REST API
• 스프링 시큐리티 공식 문서
• JWT 공식 사이트
• OAuth 2.0 표준 명세