[FEAT] kakao login 구현

build.gradle

@@ -57,7 +57,16 @@ dependencies {
 
     implementation 'me.paulschwarz:spring-dotenv:4.0.0' // .env 읽기
 
+	// JWT
+	implementation("io.jsonwebtoken:jjwt-api:0.12.6")
+	runtimeOnly("io.jsonwebtoken:jjwt-impl:0.12.6")
+	runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.12.6")
 
+	// Spring Security
+	implementation("org.springframework.boot:spring-boot-starter-security")
+
+	// WebClient
+	implementation("org.springframework.boot:spring-boot-starter-webflux")
 }
 
 tasks.named('test') {

src/main/java/com/example/demo/auth/client/KakaoOAuthClient.java

@@ -0,0 +1,28 @@
+package com.example.demo.auth.client;
+
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.client.WebClient;
+import org.springframework.web.reactive.function.client.WebClientResponseException;
+
+@Component
+public class KakaoOAuthClient {
+
+    private final WebClient webClient;
+
+    public KakaoOAuthClient(WebClient.Builder webClientBuilder) {
+        this.webClient = webClientBuilder.baseUrl("https://kapi.kakao.com").build();
+    }
+
+    public KakaoUserInfo retrieveUserInfo(String accessToken) {
+        try {
+            return webClient.get()
+                    .uri("/v2/user/me")
+                    .headers(headers -> headers.setBearerAuth(accessToken))
+                    .retrieve()
+                    .bodyToMono(KakaoUserInfo.class)
+                    .block();
+        } catch (WebClientResponseException e) {
+            throw new RuntimeException("카카오 API 호출 실패: " + e.getResponseBodyAsString(), e);
+        }
+    }
+}

src/main/java/com/example/demo/auth/client/KakaoUserInfo.java

@@ -0,0 +1,37 @@
+package com.example.demo.auth.client;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+public class KakaoUserInfo {
+
+    private String id;
+    private Properties properties;
+    @JsonProperty("kakao_account")
+    private KakaoAccount kakaoAccount;
+
+    @Getter
+    @Setter
+    @NoArgsConstructor
+    public static class Properties {
+        private String nickname;
+    }
+
+    @Getter
+    @Setter
+    @NoArgsConstructor
+    public static class KakaoAccount {
+        private String email;
+    }
+
+    public String getNickName() {
+        return this.properties.nickname;
+    }
+
+    public String getEmail() {
+        return this.kakaoAccount.email;
+    }
+}

src/main/java/com/example/demo/auth/dto/AccessTokenRequest.java

@@ -0,0 +1,6 @@
+package com.example.demo.auth.dto;
+
+public record AccessTokenRequest(
+        String accessToken
+) {
+}

src/main/java/com/example/demo/auth/dto/RefreshTokenRequest.java

@@ -0,0 +1,6 @@
+package com.example.demo.auth.dto;
+
+public record RefreshTokenRequest(
+        String refreshToken
+) {
+}

src/main/java/com/example/demo/auth/dto/TokenResponse.java

@@ -0,0 +1,10 @@
+package com.example.demo.auth.dto;
+
+import lombok.Builder;
+
+@Builder
+public record TokenResponse(
+        String accessToken,
+        String refreshToken
+) {
+}

src/main/java/com/example/demo/auth/entity/Member.java

@@ -0,0 +1,24 @@
+package com.example.demo.auth.entity;
+
+import jakarta.persistence.*;
+import lombok.*;
+
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@AllArgsConstructor
+@Builder
+@Getter
+public class Member {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private String socialId;
+
+    @Column(nullable = false)
+    private String name;
+
+    @Column(nullable = false)
+    private String email;
+}

src/main/java/com/example/demo/auth/entity/RefreshToken.java

@@ -0,0 +1,27 @@
+package com.example.demo.auth.entity;
+
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.NoArgsConstructor;
+
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@AllArgsConstructor
+@Builder
+public class RefreshToken {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private Long memberId;
+
+    @Column(length = 500, nullable = false)
+    private String token;
+
+    public void updateToken(String token) {
+        this.token = token;
+    }
+}

src/main/java/com/example/demo/auth/jwt/JwtAuthenticationFilter.java

@@ -0,0 +1,49 @@
+package com.example.demo.auth.jwt;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+
+@Component
+public class JwtAuthenticationFilter extends OncePerRequestFilter {
+
+    private final JwtTokenProvider jwtTokenProvider;
+
+    public JwtAuthenticationFilter(JwtTokenProvider jwtTokenProvider) {
+        this.jwtTokenProvider = jwtTokenProvider;
+    }
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request,
+                                    HttpServletResponse response,
+                                    FilterChain filterChain)
+            throws ServletException, IOException {
+
+        String token = extractToken(request);
+        if (token != null) {
+            var authentication = jwtTokenProvider.getAuthentication(token);
+            SecurityContextHolder.getContext().setAuthentication(authentication);
+        }
+
+        filterChain.doFilter(request, response);
+    }
+
+    private String extractToken(HttpServletRequest request) {
+        String header = "Authorization";
+        String prefix = "Bearer ";
+        String bearerToken = request.getHeader(header);
+
+        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith(prefix)) {
+            return bearerToken.substring(prefix.length());
+        }
+
+        return null;
+    }
+}

src/main/java/com/example/demo/auth/jwt/JwtProperties.java

@@ -0,0 +1,20 @@
+package com.example.demo.auth.jwt;
+
+
+import lombok.Getter;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@Getter
+public class JwtProperties {
+    @Value("${jwt.secret}")
+    private String secret;
+
+    @Value("${jwt.access-token-expiration-time}")
+    private long accessTokenExpirationTime;
+
+    @Value("${jwt.refresh-token-expiration-time}")
+    private long refreshTokenExpirationTime;
+
+}

src/main/java/com/example/demo/auth/jwt/JwtTokenProvider.java

@@ -0,0 +1,89 @@
+package com.example.demo.auth.jwt;
+
+import com.example.demo.auth.dto.TokenResponse;
+import com.example.demo.auth.service.RefreshTokenService;
+import io.jsonwebtoken.*;
+import io.jsonwebtoken.io.Decoders;
+import io.jsonwebtoken.security.Keys;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.User;
+import org.springframework.stereotype.Component;
+
+import javax.crypto.SecretKey;
+import java.util.Collections;
+import java.util.Date;
+
+@Component
+public class JwtTokenProvider {
+
+    private final JwtProperties jwtProperties;
+    private final RefreshTokenService refreshTokenService;
+    private final SecretKey key;
+
+    public JwtTokenProvider(JwtProperties jwtProperties, RefreshTokenService refreshTokenService) {
+        this.jwtProperties = jwtProperties;
+        this.refreshTokenService = refreshTokenService;
+        this.key = Keys.hmacShaKeyFor(Decoders.BASE64.decode(jwtProperties.getSecret()));
+    }
+
+    public String createAccessToken(Long userId) {
+        return createToken(userId, jwtProperties.getAccessTokenExpirationTime());
+    }
+
+    public String createRefreshToken(Long userId) {
+        return createToken(userId, jwtProperties.getRefreshTokenExpirationTime());
+    }
+
+    private String createToken(Long userId, long expireTime) {
+        Date now = new Date();
+        return Jwts.builder()
+                .issuer("wisecard")
+                .claim("id", userId.toString())
+                .issuedAt(now)
+                .expiration(new Date(now.getTime() + expireTime))
+                .signWith(key)
+                .compact();
+    }
+
+    public TokenResponse reissueToken(String token) {
+        if (!refreshTokenService.existsToken(token)) {
+            throw new RuntimeException("refresh token을 찾을 수 없습니다.");
+        }
+
+        Claims claims = validateToken(token);
+        Long userId = Long.parseLong(claims.get("id").toString());
+
+        String accessToken = createAccessToken(userId);
+        String refreshToken = createRefreshToken(userId);
+
+        refreshTokenService.updateToken(userId, refreshToken);
+
+        return new TokenResponse(accessToken, refreshToken);
+    }
+
+    public Claims validateToken(String token) {
+        try {
+            return Jwts.parser()
+                    .verifyWith(key)
+                    .build()
+                    .parseSignedClaims(token)
+                    .getPayload();
+        } catch (IllegalArgumentException | UnsupportedJwtException | MalformedJwtException | SecurityException e) {
+            throw new RuntimeException("잘못된 토큰입니다.");
+        } catch (ExpiredJwtException e) {
+            throw new RuntimeException("만료된 토큰입니다.");
+        } catch (Exception e) {
+            throw new RuntimeException("토큰 검증 중 알 수 없는 오류가 발생했습니다.");
+        }
+    }
+
+    public Authentication getAuthentication(String token) {
+        Claims claims = validateToken(token);
+        String userId = claims.get("id").toString();
+
+        User user = new User(userId, "", Collections.singleton(new SimpleGrantedAuthority("ROLE_USER")));
+        return new UsernamePasswordAuthenticationToken(user, "", user.getAuthorities());
+    }
+}

src/main/java/com/example/demo/auth/repository/MemberRepository.java

@@ -0,0 +1,10 @@
+package com.example.demo.auth.repository;
+
+import com.example.demo.auth.entity.Member;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface MemberRepository extends JpaRepository<Member, Long> {
+    Optional<Member> findBySocialId(String socialId);
+}

src/main/java/com/example/demo/auth/repository/RefreshTokenRepository.java

@@ -0,0 +1,12 @@
+package com.example.demo.auth.repository;
+
+import com.example.demo.auth.entity.RefreshToken;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface RefreshTokenRepository extends JpaRepository<RefreshToken, Long> {
+    Optional<RefreshToken> findByMemberId(Long memberId);
+
+    Boolean existsByToken(String token);
+}