[Feat] 인증 중앙화로 인한 베이스 코드 변경사항 (#556)

build.gradle

@@ -84,10 +84,14 @@ dependencies {
     // aws-s3
     implementation 'software.amazon.awssdk:s3'
 
-
     // retry
     implementation 'org.springframework.retry:spring-retry:2.0.6'
 
+    // jwt
+    implementation 'com.nimbusds:nimbus-jose-jwt:9.37.3'
+    implementation 'com.github.ben-manes.caffeine:caffeine:3.1.8'
+    implementation 'org.springframework.boot:spring-boot-starter-webflux'
+
     // test
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'org.springframework.security:spring-security-test'

src/main/java/org/sopt/app/AppApplication.java

@@ -1,8 +1,10 @@
 package org.sopt.app;
 
 import jakarta.annotation.PostConstruct;
+import org.sopt.app.common.external.auth.AuthClientProperty;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 import org.springframework.scheduling.annotation.EnableAsync;
 
@@ -13,6 +15,7 @@
 @EnableAsync
 @EnableScheduling
 @SpringBootApplication
+@EnableConfigurationProperties(AuthClientProperty.class)
 public class AppApplication {
 
     public static void main(String[] args) {

src/main/java/org/sopt/app/application/auth/CustomUserDetailService.java

@@ -1,21 +1,21 @@
-package org.sopt.app.application.auth;
-
-import lombok.RequiredArgsConstructor;
-import org.sopt.app.common.exception.NotFoundException;
-import org.sopt.app.common.response.ErrorCode;
-import org.sopt.app.interfaces.postgres.UserRepository;
-import org.springframework.security.core.userdetails.UserDetails;
-import org.springframework.security.core.userdetails.UserDetailsService;
-import org.springframework.stereotype.Service;
-
-@RequiredArgsConstructor
-@Service
-public class CustomUserDetailService implements UserDetailsService {
-
-    private final UserRepository userRepository;
-
-    public UserDetails loadUserByUsername(String username) throws NotFoundException {
-        return userRepository.findUserById(Long.parseLong(username))
-                .orElseThrow(() -> new NotFoundException(ErrorCode.USER_NOT_FOUND));
-    }
-}
+// package org.sopt.app.application.auth;
+//
+// import lombok.RequiredArgsConstructor;
+// import org.sopt.app.common.exception.NotFoundException;
+// import org.sopt.app.common.response.ErrorCode;
+// import org.sopt.app.interfaces.postgres.UserRepository;
+// import org.springframework.security.core.userdetails.UserDetails;
+// import org.springframework.security.core.userdetails.UserDetailsService;
+// import org.springframework.stereotype.Service;
+//
+// @RequiredArgsConstructor
+// @Service
+// public class CustomUserDetailService implements UserDetailsService {
+//
+//     private final UserRepository userRepository;
+//
+//     public UserDetails loadUserByUsername(String username) throws NotFoundException {
+//         return userRepository.findUserById(Long.parseLong(username))
+//                 .orElseThrow(() -> new NotFoundException(ErrorCode.USER_NOT_FOUND));
+//     }
+// }

src/main/java/org/sopt/app/application/auth/JwtTokenService.java

@@ -1,111 +1,111 @@
-package org.sopt.app.application.auth;
-
-import io.jsonwebtoken.*;
-import io.jsonwebtoken.io.Decoders;
-import io.jsonwebtoken.security.Keys;
-import java.nio.charset.StandardCharsets;
-import java.security.Key;
-import java.time.LocalDateTime;
-import java.time.ZoneId;
-import java.util.Base64;
-import java.util.Date;
-import jakarta.servlet.http.HttpServletRequest;
-import lombok.RequiredArgsConstructor;
-import lombok.val;
-
-import org.sopt.app.application.auth.dto.PlaygroundAuthTokenInfo.AppToken;
-import org.sopt.app.common.exception.UnauthorizedException;
-import org.sopt.app.common.response.ErrorCode;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
-import org.springframework.security.core.Authentication;
-import org.springframework.stereotype.Component;
-
-@Component
-@RequiredArgsConstructor
-public class JwtTokenService {
-
-    private final CustomUserDetailService customUserDetailsService;
-    @Value("${jwt.secret}")
-    private String JWT_SECRET;
-
-    private String encodeKey(String secretKey) {
-        return Base64.getEncoder().encodeToString(secretKey.getBytes(StandardCharsets.UTF_8));
-    }
-
-    private Key getSigningKey(String keyString) {
-        val secretKey = this.encodeKey(keyString);
-        return Keys.hmacShaKeyFor(Decoders.BASE64.decode(secretKey));
-    }
-
-    public AppToken issueNewTokens(Long userId, Long playgroundId) {
-        val accessToken = this.encodeJwtToken(userId, playgroundId);
-        val refreshToken = this.encodeJwtRefreshToken(userId);
-        return AppToken.builder().accessToken(accessToken).refreshToken(refreshToken).build();
-    }
-
-    private String encodeJwtToken(Long userId, Long playgroundId) {
-        val now = LocalDateTime.now();
-        val nowDate = Date.from(now.atZone(ZoneId.systemDefault()).toInstant());
-        val nowDate1PlusDays = Date.from(now.plusDays(1).atZone(ZoneId.systemDefault()).toInstant());
-        return Jwts.builder()
-                .setHeaderParam(Header.TYPE, Header.JWT_TYPE)
-                .setIssuer("sopt-makers")
-                .setIssuedAt(nowDate)
-                .setSubject(userId.toString())
-                .setExpiration(nowDate1PlusDays)
-                .claim("id", userId)
-                .claim("playgroundId", playgroundId)
-                .claim("roles", "USER")
-                .signWith(getSigningKey(JWT_SECRET), SignatureAlgorithm.HS256)
-                .compact();
-    }
-
-    private String encodeJwtRefreshToken(Long userId) {
-        val now = LocalDateTime.now();
-        val nowDate = Date.from(now.atZone(ZoneId.systemDefault()).toInstant());
-        val nowDate30PlusDays = Date.from(now.plusDays(30).atZone(ZoneId.systemDefault()).toInstant());
-        return Jwts.builder()
-                .setIssuedAt(nowDate)
-                .setSubject(userId.toString())
-                .setExpiration(nowDate30PlusDays)
-                .claim("id", userId)
-                .claim("roles", "USER")
-                .signWith(getSigningKey(JWT_SECRET), SignatureAlgorithm.HS256)
-                .compact();
-    }
-
-    public Long getUserIdFromJwtToken(String token) {
-        try {
-            val claims = Jwts.parser()
-                .setSigningKey(this.encodeKey(JWT_SECRET))
-                .parseClaimsJws(token)
-                .getBody();
-        return Long.parseLong(claims.getSubject());
-        } catch (ExpiredJwtException e) {
-            throw new UnauthorizedException(ErrorCode.TOKEN_EXPIRED);
-        } catch (Exception e) {
-            throw new UnauthorizedException(ErrorCode.INVALID_ACCESS_TOKEN);
-        }
-    }
-
-    public Authentication getAuthentication(String token) {
-        val userDetails = customUserDetailsService.loadUserByUsername(this.getUserIdFromJwtToken(token).toString());
-        return new UsernamePasswordAuthenticationToken(userDetails, "", userDetails.getAuthorities());
-    }
-
-
-    public Boolean validateToken(String token) {
-        try {
-            val claims = Jwts.parser().setSigningKey(this.encodeKey(JWT_SECRET)).parseClaimsJws(token);
-
-            return !claims.getBody().getExpiration().before(new Date());
-        } catch (Exception e) {
-            return false;
-        }
-    }
-
-    public String getToken(HttpServletRequest request) {
-        return request.getHeader("Authorization");
-    }
-}
+// package org.sopt.app.application.auth;
+//
+// import io.jsonwebtoken.*;
+// import io.jsonwebtoken.io.Decoders;
+// import io.jsonwebtoken.security.Keys;
+// import java.nio.charset.StandardCharsets;
+// import java.security.Key;
+// import java.time.LocalDateTime;
+// import java.time.ZoneId;
+// import java.util.Base64;
+// import java.util.Date;
+// import jakarta.servlet.http.HttpServletRequest;
+// import lombok.RequiredArgsConstructor;
+// import lombok.val;
+//
+// import org.sopt.app.application.auth.dto.PlaygroundAuthTokenInfo.AppToken;
+// import org.sopt.app.common.exception.UnauthorizedException;
+// import org.sopt.app.common.response.ErrorCode;
+// import org.springframework.beans.factory.annotation.Value;
+// import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+// import org.springframework.security.core.Authentication;
+// import org.springframework.stereotype.Component;
+//
+// @Component
+// @RequiredArgsConstructor
+// public class JwtTokenService {
+//
+//     private final CustomUserDetailService customUserDetailsService;
+//     @Value("${jwt.secret}")
+//     private String JWT_SECRET;
+//
+//     private String encodeKey(String secretKey) {
+//         return Base64.getEncoder().encodeToString(secretKey.getBytes(StandardCharsets.UTF_8));
+//     }
+//
+//     private Key getSigningKey(String keyString) {
+//         val secretKey = this.encodeKey(keyString);
+//         return Keys.hmacShaKeyFor(Decoders.BASE64.decode(secretKey));
+//     }
+//
+//     public AppToken issueNewTokens(Long userId, Long playgroundId) {
+//         val accessToken = this.encodeJwtToken(userId, playgroundId);
+//         val refreshToken = this.encodeJwtRefreshToken(userId);
+//         return AppToken.builder().accessToken(accessToken).refreshToken(refreshToken).build();
+//     }
+//
+//     private String encodeJwtToken(Long userId, Long playgroundId) {
+//         val now = LocalDateTime.now();
+//         val nowDate = Date.from(now.atZone(ZoneId.systemDefault()).toInstant());
+//         val nowDate1PlusDays = Date.from(now.plusDays(1).atZone(ZoneId.systemDefault()).toInstant());
+//         return Jwts.builder()
+//                 .setHeaderParam(Header.TYPE, Header.JWT_TYPE)
+//                 .setIssuer("sopt-makers")
+//                 .setIssuedAt(nowDate)
+//                 .setSubject(userId.toString())
+//                 .setExpiration(nowDate1PlusDays)
+//                 .claim("id", userId)
+//                 .claim("playgroundId", playgroundId)
+//                 .claim("roles", "USER")
+//                 .signWith(getSigningKey(JWT_SECRET), SignatureAlgorithm.HS256)
+//                 .compact();
+//     }
+//
+//     private String encodeJwtRefreshToken(Long userId) {
+//         val now = LocalDateTime.now();
+//         val nowDate = Date.from(now.atZone(ZoneId.systemDefault()).toInstant());
+//         val nowDate30PlusDays = Date.from(now.plusDays(30).atZone(ZoneId.systemDefault()).toInstant());
+//         return Jwts.builder()
+//                 .setIssuedAt(nowDate)
+//                 .setSubject(userId.toString())
+//                 .setExpiration(nowDate30PlusDays)
+//                 .claim("id", userId)
+//                 .claim("roles", "USER")
+//                 .signWith(getSigningKey(JWT_SECRET), SignatureAlgorithm.HS256)
+//                 .compact();
+//     }
+//
+//     public Long getUserIdFromJwtToken(String token) {
+//         try {
+//             val claims = Jwts.parser()
+//                 .setSigningKey(this.encodeKey(JWT_SECRET))
+//                 .parseClaimsJws(token)
+//                 .getBody();
+//         return Long.parseLong(claims.getSubject());
+//         } catch (ExpiredJwtException e) {
+//             throw new UnauthorizedException(ErrorCode.TOKEN_EXPIRED);
+//         } catch (Exception e) {
+//             throw new UnauthorizedException(ErrorCode.INVALID_ACCESS_TOKEN);
+//         }
+//     }
+//
+//     public Authentication getAuthentication(String token) {
+//         val userDetails = customUserDetailsService.loadUserByUsername(this.getUserIdFromJwtToken(token).toString());
+//         return new UsernamePasswordAuthenticationToken(userDetails, "", userDetails.getAuthorities());
+//     }
+//
+//
+//     public Boolean validateToken(String token) {
+//         try {
+//             val claims = Jwts.parser().setSigningKey(this.encodeKey(JWT_SECRET)).parseClaimsJws(token);
+//
+//             return !claims.getBody().getExpiration().before(new Date());
+//         } catch (Exception e) {
+//             return false;
+//         }
+//     }
+//
+//     public String getToken(HttpServletRequest request) {
+//         return request.getHeader("Authorization");
+//     }
+// }

src/main/java/org/sopt/app/application/friend/FriendRecommender.java

@@ -5,13 +5,14 @@
 import java.util.Optional;
 import java.util.Set;
 import lombok.RequiredArgsConstructor;
+
+import org.sopt.app.application.platform.PlatformService;
 import org.sopt.app.application.playground.PlaygroundAuthService;
 import org.sopt.app.application.playground.dto.PlaygroundProfileInfo.*;
 import org.sopt.app.application.playground.user_finder.PlaygroundUserIdsProvider;
 import org.sopt.app.application.user.UserProfile;
 import org.sopt.app.application.user.UserService;
 import org.sopt.app.common.utils.RandomPicker;
-import org.sopt.app.domain.entity.User;
 import org.sopt.app.domain.enums.FriendRecommendType;
 import org.sopt.app.presentation.poke.PokeResponse.*;
 import org.springframework.stereotype.Service;
@@ -24,22 +25,23 @@ public class FriendRecommender {
     private final UserService userService;
     private final FriendService friendService;
     private final PlaygroundUserIdsProvider playgroundUserIdsProvider;
+    private final PlatformService platformService;
 
     public RecommendedFriendsRequest recommendFriendsByTypeList(List<FriendRecommendType> typeList, int size,
-            User user) {
+        Long userId) {
         typeList = this.adjustTypeList(typeList);
 
-        OwnPlaygroundProfile ownProfile = playgroundAuthService.getOwnPlaygroundProfile(user.getPlaygroundToken());
+        OwnPlaygroundProfile ownProfile = playgroundAuthService.getOwnPlaygroundProfile(userId);
         FriendFilter friendFilter =
-                new FriendFilter(friendService.findAllFriendIdsByUserId(user.getId()), user.getId());
+                new FriendFilter(friendService.findAllFriendIdsByUserId(userId), userId);
         List<RecommendedFriendsByType> recommendedFriends = new ArrayList<>();
         for (FriendRecommendType type : typeList) {
             List<UserProfile> recommendableUserProfiles =
                     this.getRecommendableUserProfiles(type, ownProfile, friendFilter);
             if (!recommendableUserProfiles.isEmpty()) {
                 List<UserProfile> pickedUserProfiles = RandomPicker.pickRandom(recommendableUserProfiles, size);
                 List<SimplePokeProfile> simplePokeProfiles =
-                        this.convertUserProfilesToSimplePokeProfiles(pickedUserProfiles, user);
+                        this.convertUserProfilesToSimplePokeProfiles(pickedUserProfiles);
 
                 recommendedFriends.add(RecommendedFriendsByType.builder()
                         .randomType(type)
@@ -52,10 +54,9 @@ public RecommendedFriendsRequest recommendFriendsByTypeList(List<FriendRecommend
     }
 
     private List<SimplePokeProfile> convertUserProfilesToSimplePokeProfiles(
-            List<UserProfile> pickedUserProfiles, User user) {
-        List<Long> pickedPlaygroundIds = pickedUserProfiles.stream().map(UserProfile::getPlaygroundId).toList();
-        List<PlaygroundProfile> pickedPlaygroundProfiles = playgroundAuthService.getPlaygroundMemberProfiles(
-                user.getPlaygroundToken(), pickedPlaygroundIds);
+            List<UserProfile> pickedUserProfiles) {
+        List<Long> pickedPlaygroundIds = pickedUserProfiles.stream().map(UserProfile::getUserId).toList();
+        List<PlaygroundProfile> pickedPlaygroundProfiles = playgroundAuthService.getPlaygroundMemberProfiles(pickedPlaygroundIds);
         return this.makeSimplePokeProfilesForNotFriend(pickedPlaygroundProfiles, pickedUserProfiles);
     }
 
@@ -64,7 +65,7 @@ private List<SimplePokeProfile> makeSimplePokeProfilesForNotFriend(
     ) {
         return userProfiles.stream()
                 .map(userProfile -> playgroundProfiles.stream()
-                        .filter(profile -> profile.getMemberId().equals(userProfile.getPlaygroundId()))
+                        .filter(profile -> profile.getMemberId().equals(userProfile.getUserId()))
                         .findFirst()
                         .map(playgroundProfile ->
                                 SimplePokeProfile.createNonFriendPokeProfile(playgroundProfile, userProfile))
@@ -75,14 +76,16 @@ private List<SimplePokeProfile> makeSimplePokeProfilesForNotFriend(
 
     private List<UserProfile> getRecommendableUserProfiles(
             FriendRecommendType type, OwnPlaygroundProfile ownProfile, FriendFilter friendFilter) {
-        Set<Long> playgroundIds;
+        Set<Long> userIds;
         if (type == FriendRecommendType.ALL_USER) {
-            playgroundIds = Set.copyOf(userService.getAllPlaygroundIds());
+            userIds = Set.copyOf(userService.getAllUserIds());
         } else {
-            playgroundIds = playgroundUserIdsProvider.findPlaygroundIdsByType(ownProfile, type);
+            userIds = playgroundUserIdsProvider.findPlaygroundIdsByType(ownProfile, type);
         }
-        List<UserProfile> unFilteredUserProfiles = userService.getUserProfilesByPlaygroundIds(
-                List.copyOf(playgroundIds));
+
+        List <UserProfile> unFilteredUserProfiles = platformService.getPlatformUserInfosResponse(List.copyOf(userIds))
+                .stream()
+                .map(user -> UserProfile.of((long)user.userId(), user.name())).toList();
         return friendFilter.excludeAlreadyFriendUserIds(unFilteredUserProfiles);
     }