[DEPLOY] v1.2.6

[DEPLOY] v1.2.6

Author: sung-silver

src/main/java/sopt/makers/authentication/adapter/out/cache/UserCacheRepositoryImpl.java

@@ -7,46 +7,57 @@
 import sopt.makers.authentication.application.port.out.user.UserCacheRepository;
 import sopt.makers.authentication.domain.user.User;
 
-import java.util.HashSet;
+import java.time.Duration;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
 
-import org.redisson.api.RMapCache;
+import org.redisson.api.BatchResult;
+import org.redisson.api.RBatch;
 import org.redisson.api.RedissonClient;
+import org.redisson.client.codec.Codec;
 import org.redisson.codec.TypedJsonJacksonCodec;
 import org.springframework.stereotype.Component;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 
 @Component
 public class UserCacheRepositoryImpl implements UserCacheRepository {
-  private static final long TTL_DAYS = 1;
-  private final RMapCache<Long, CachedUserProfile> cache;
+  private static final Duration TTL = Duration.ofDays(1);
+  private static final String KEY_PREFIX = USER_CACHE_NAME + ":";
+
+  private final RedissonClient redissonClient;
   private final UserMapper userMapper;
+  private final Codec codec;
 
   public UserCacheRepositoryImpl(
       RedissonClient redissonClient, UserMapper userMapper, ObjectMapper objectMapper) {
-    this.cache =
-        redissonClient.getMapCache(
-            USER_CACHE_NAME,
-            new TypedJsonJacksonCodec(Long.class, CachedUserProfile.class, objectMapper));
+    this.redissonClient = redissonClient;
     this.userMapper = userMapper;
+    this.codec = new TypedJsonJacksonCodec(CachedUserProfile.class, objectMapper);
   }
 
   @Override
   public Map<Long, User> getAllPresent(List<Long> userIds) {
     if (userIds.isEmpty()) return Map.of();
 
-    Map<Long, CachedUserProfile> cachedProfiles = cache.getAll(new HashSet<>(userIds));
-
-    return cachedProfiles.entrySet().stream()
-        .collect(Collectors.toMap(Map.Entry::getKey, e -> userMapper.toDomain(e.getValue())));
+    RBatch batch = redissonClient.createBatch();
+    userIds.forEach(id -> batch.getBucket(KEY_PREFIX + id, codec).getAsync());
+    BatchResult<?> result = batch.execute();
+
+    List<?> responses = result.getResponses();
+    Map<Long, User> users = new HashMap<>();
+    for (int i = 0; i < userIds.size(); i++) {
+      CachedUserProfile profile = (CachedUserProfile) responses.get(i);
+      if (profile != null) {
+        users.put(userIds.get(i), userMapper.toDomain(profile));
+      }
+    }
+    return users;
   }
 
   @Override
   public void put(User user) {
-    cache.put(user.getId(), userMapper.toCache(user), TTL_DAYS, TimeUnit.DAYS);
+    redissonClient.getBucket(KEY_PREFIX + user.getId(), codec).set(userMapper.toCache(user), TTL);
   }
 }

src/main/java/sopt/makers/authentication/adapter/out/persistence/repository/user/UserJpaRepository.java

@@ -37,18 +37,36 @@ Optional<UserEntity> findByAuthPlatformTypeAndAuthPlatformId(
   Optional<UserEntity> findWithActivityHistoriesById(@Param("userId") Long userId);
 
   @Query(
-      "SELECT DISTINCT u "
+      "SELECT u.id "
           + "FROM UserEntity u "
-          + "JOIN FETCH u.userActivityHistoryList "
+          + "JOIN u.userActivityHistoryList a "
           + "WHERE (:name IS NULL OR u.name LIKE %:name%) "
-          + "AND EXISTS ("
-          + "SELECT 1 FROM UserActivityHistoryEntity a "
-          + "WHERE a.user = u "
           + "AND (:generation IS NULL OR a.generation = :generation) "
           + "AND (:part IS NULL OR a.part = :part) "
           + "AND (:team IS NULL OR a.team = :team) "
-          + "AND (:isAdmin IS NULL OR :isAdmin = FALSE OR a.role <> 'MEMBER'))")
-  Page<UserEntity> findAllWithActivityHistoriesByGenerationAndPartAndNameAndTeam(
+          + "AND (:isAdmin IS NULL OR :isAdmin = FALSE OR a.role <> 'MEMBER') "
+          + "GROUP BY u.id "
+          + "ORDER BY u.id DESC")
+  Page<Long> findUserIdsOrderByRegisteredDesc(
+      @Param("generation") Integer generation,
+      @Param("part") Part part,
+      @Param("name") String name,
+      @Param("team") Team team,
+      @Param("isAdmin") Boolean isAdmin,
+      Pageable pageable);
+
+  @Query(
+      "SELECT u.id "
+          + "FROM UserEntity u "
+          + "JOIN u.userActivityHistoryList a "
+          + "WHERE (:name IS NULL OR u.name LIKE %:name%) "
+          + "AND (:generation IS NULL OR a.generation = :generation) "
+          + "AND (:part IS NULL OR a.part = :part) "
+          + "AND (:team IS NULL OR a.team = :team) "
+          + "AND (:isAdmin IS NULL OR :isAdmin = FALSE OR a.role <> 'MEMBER') "
+          + "GROUP BY u.id "
+          + "ORDER BY u.id ASC")
+  Page<Long> findUserIdsOrderByRegisteredAsc(
       @Param("generation") Integer generation,
       @Param("part") Part part,
       @Param("name") String name,

src/main/java/sopt/makers/authentication/adapter/out/persistence/repository/user/UserRetriever.java

@@ -73,13 +73,10 @@ public Page<User> findAllByGenerationAndPartAndNameAndTeam(
     if (orderBy.isGenerationOrder()) {
       return findByGenerationOrder(generation, part, name, team, isAdmin, pageable, orderBy);
     }
-    return userJpaRepository
-        .findAllWithActivityHistoriesByGenerationAndPartAndNameAndTeam(
-            generation, part, name, team, isAdmin, pageable)
-        .map(UserEntity::toDomain);
+    return findByRegisteredOrder(generation, part, name, team, isAdmin, pageable, orderBy);
   }
 
-  private Page<User> findByGenerationOrder(
+  private Page<User> findByRegisteredOrder(
       Integer generation,
       Part part,
       String name,
@@ -88,12 +85,16 @@ private Page<User> findByGenerationOrder(
       Pageable pageable,
       UserOrderBy orderBy) {
     Page<Long> userIdPage =
-        orderBy == UserOrderBy.LATEST_GENERATION
-            ? userJpaRepository.findUserIdsOrderByMatchedGenerationDesc(
+        orderBy == UserOrderBy.LATEST_REGISTERED
+            ? userJpaRepository.findUserIdsOrderByRegisteredDesc(
                 generation, part, name, team, isAdmin, pageable)
-            : userJpaRepository.findUserIdsOrderByMatchedGenerationAsc(
+            : userJpaRepository.findUserIdsOrderByRegisteredAsc(
                 generation, part, name, team, isAdmin, pageable);
 
+    return getUsers(pageable, userIdPage);
+  }
+
+  private Page<User> getUsers(Pageable pageable, Page<Long> userIdPage) {
     List<Long> orderedIds = userIdPage.getContent();
     if (orderedIds.isEmpty()) {
       return new PageImpl<>(List.of(), pageable, userIdPage.getTotalElements());
@@ -114,6 +115,24 @@ private Page<User> findByGenerationOrder(
     return new PageImpl<>(orderedUsers, pageable, userIdPage.getTotalElements());
   }
 
+  private Page<User> findByGenerationOrder(
+      Integer generation,
+      Part part,
+      String name,
+      Team team,
+      Boolean isAdmin,
+      Pageable pageable,
+      UserOrderBy orderBy) {
+    Page<Long> userIdPage =
+        orderBy == UserOrderBy.LATEST_GENERATION
+            ? userJpaRepository.findUserIdsOrderByMatchedGenerationDesc(
+                generation, part, name, team, isAdmin, pageable)
+            : userJpaRepository.findUserIdsOrderByMatchedGenerationAsc(
+                generation, part, name, team, isAdmin, pageable);
+
+    return getUsers(pageable, userIdPage);
+  }
+
   public int countByGenerationAndIsSopt(int generation, boolean isSopt) {
     return userJpaRepository.countByGenerationAndIsSopt(generation, isSopt);
   }