258 mongo entity 리팩토링

src/main/java/org/prgms/locomocoserver/chat/application/ChatActivityService.java

@@ -1,9 +1,9 @@
 package org.prgms.locomocoserver.chat.application;
 
 import lombok.RequiredArgsConstructor;
-import org.prgms.locomocoserver.chat.domain.ChatParticipant;
-import org.prgms.locomocoserver.chat.domain.mongo.ChatMessageMongoCustomRepository;
-import org.prgms.locomocoserver.chat.domain.querydsl.ChatParticipantCustomRepository;
+import org.bson.types.ObjectId;
+import org.prgms.locomocoserver.chat.domain.mongo.ChatActivity;
+import org.prgms.locomocoserver.chat.domain.mongo.ChatActivityRepository;
 import org.prgms.locomocoserver.chat.dto.request.ChatActivityRequestDto;
 import org.prgms.locomocoserver.chat.exception.ChatErrorType;
 import org.prgms.locomocoserver.chat.exception.ChatException;
@@ -14,21 +14,13 @@
 @RequiredArgsConstructor
 public class ChatActivityService {
 
-    private final ChatParticipantCustomRepository chatParticipantRepository;
-    private final ChatMessageMongoCustomRepository chatMessageMongoCustomRepository;
+    private final ChatActivityRepository chatActivityRepository;
 
     @Transactional
     public void updateLastReadMessage(Long chatRoomId, ChatActivityRequestDto requestDto) {
-        ChatParticipant chatParticipant = chatParticipantRepository.findByUserIdAndChatRoomId(requestDto.userId(), chatRoomId)
+        ChatActivity chatActivity = chatActivityRepository.findByUserIdAndChatRoomId(requestDto.userId().toString(), String.valueOf(chatRoomId))
                 .orElseThrow(() -> new ChatException(ChatErrorType.CHAT_PARTICIPANT_NOT_FOUND));
-        chatParticipant.updateLastReadMessageId(requestDto.lastReadMessageId());
+        chatActivity.updateLastReadMessage(requestDto.userId().toString(), new ObjectId(requestDto.lastReadMessageId()));
     }
 
-    @Transactional(readOnly = true)
-    public int unReadMessageCount(Long roomId, String lastReadMsgId) {
-        if (lastReadMsgId == null) {
-            return 0;
-        }
-        return chatMessageMongoCustomRepository.unReadMessageCount(roomId, lastReadMsgId);
-    }
 }

src/main/java/org/prgms/locomocoserver/chat/application/ChatRoomService.java

@@ -2,36 +2,46 @@
 
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.prgms.locomocoserver.chat.dao.ChatActivityDao;
 import org.prgms.locomocoserver.chat.domain.ChatParticipant;
-import org.prgms.locomocoserver.chat.domain.ChatParticipantRepository;
 import org.prgms.locomocoserver.chat.domain.ChatRoom;
 import org.prgms.locomocoserver.chat.domain.ChatRoomRepository;
+import org.prgms.locomocoserver.chat.domain.mongo.ChatActivity;
+import org.prgms.locomocoserver.chat.domain.mongo.ChatActivityRepository;
+import org.prgms.locomocoserver.chat.domain.mongo.ChatMessageMongoCustomRepository;
 import org.prgms.locomocoserver.chat.domain.querydsl.ChatParticipantCustomRepository;
 import org.prgms.locomocoserver.chat.domain.querydsl.ChatRoomCustomRepository;
+import org.prgms.locomocoserver.chat.dto.ChatMessageBriefDto;
 import org.prgms.locomocoserver.chat.dto.ChatMessageDto;
 import org.prgms.locomocoserver.chat.dto.ChatRoomDto;
+import org.prgms.locomocoserver.chat.dto.ChatUserInfo;
 import org.prgms.locomocoserver.chat.dto.request.ChatCreateRequestDto;
 import org.prgms.locomocoserver.chat.dto.request.ChatEnterRequestDto;
 import org.prgms.locomocoserver.chat.dto.request.ChatMessageRequestDto;
 import org.prgms.locomocoserver.chat.exception.ChatErrorType;
 import org.prgms.locomocoserver.chat.exception.ChatException;
 import org.prgms.locomocoserver.user.domain.User;
+import org.prgms.locomocoserver.user.domain.querydsl.UserCustomRepository;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.time.LocalDateTime;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.stream.Collectors;
 
 @Slf4j
 @Service
 @RequiredArgsConstructor
 public class ChatRoomService {
 
-    private final MongoChatMessageService mongoChatMessageService;
     private final ChatRoomRepository chatRoomRepository;
     private final ChatRoomCustomRepository chatRoomCustomRepository;
     private final ChatParticipantCustomRepository chatParticipantCustomRepository;
-    private final ChatActivityService chatActivityService;
+    private final UserCustomRepository userCustomRepository;
+    private final ChatMessageMongoCustomRepository chatMessageMongoCustomRepository;
+    private final ChatActivityRepository chatActivityRepository;
 
     private final StompChatService stompChatService;
     private final ChatMessagePolicy chatMessagePolicy;
@@ -46,6 +56,9 @@ public void enterChatRoom(ChatEnterRequestDto requestDto) {
             ChatParticipant chatParticipant = chatParticipantCustomRepository.save(ChatParticipant.builder().user(requestDto.participant())
                     .chatRoom(chatRoom).build()).orElseThrow(() -> new RuntimeException("채팅방 참여에 실패했습니다."));
 
+            chatActivityRepository.save(ChatActivity.builder().chatRoomId(requestDto.chatRoomId().toString())
+                    .userId(requestDto.participant().getId().toString()).build());
+
             chatRoom.addChatParticipant(chatParticipant);
             stompChatService.sendToSubscribers(chatMessageDto);
         }
@@ -59,7 +72,8 @@ public ChatRoom createChatRoom(ChatCreateRequestDto requestDto) {
 
         chatRoom.addChatParticipant(chatParticipant);
         chatRoomRepository.save(chatRoom); // mysql chat room create
-        mongoChatMessageService.createChatRoom(chatRoom.getId()); // mongo chat room create
+        chatActivityRepository.save(ChatActivity.builder()
+                .chatRoomId(chatRoom.getId().toString()).userId(requestDto.creator().getId().toString()).build());
 
         chatMessagePolicy.saveEnterMessage(chatRoom.getId(), chatParticipant.getUser());
 
@@ -68,7 +82,9 @@ public ChatRoom createChatRoom(ChatCreateRequestDto requestDto) {
 
     @Transactional
     public ChatMessageDto saveChatMessage(ChatMessageRequestDto requestDto) {
-        return chatMessagePolicy.saveChatMessage(requestDto.chatRoomId(), requestDto);
+        ChatMessageDto chatMessageDto = chatMessagePolicy.saveChatMessage(requestDto.chatRoomId(), requestDto);
+
+        return chatMessageDto;
     }
 
     @Transactional
@@ -82,21 +98,42 @@ public ChatMessageDto saveEnterMessage(ChatEnterRequestDto requestDto) {
     }
 
     @Transactional(readOnly = true)
-    public List<ChatRoomDto> getAllChatRoom(Long userId, Long cursor, int pageSize) {
-        if (cursor == null) cursor = Long.MAX_VALUE;
-        List<ChatRoom> chatRooms = chatRoomCustomRepository.findByParticipantsId(userId, cursor, pageSize);
+    public List<ChatRoomDto> getAllChatRoom(Long userId, String cursor, int pageSize) {
+        if (cursor == null) cursor = LocalDateTime.now().toString();
 
-        List<ChatRoomDto> chatRoomDtos = chatRooms.stream()
+        log.info("START findByParticipantsId");
+        List<ChatRoom> chatRooms = chatRoomCustomRepository.findByParticipantsId(userId, cursor, pageSize);
+        log.info("END findByParticipantsId");
+
+        List<String> chatRoomIds = createChatRoomIds(chatRooms);
+        log.info("START findLastMessagesAndUnReadMsgCount");
+        List<ChatActivityDao> lastMessages = chatMessageMongoCustomRepository.findLastMessagesAndUnReadMsgCount(userId.toString(), chatRoomIds);
+        log.info("END findLastMessagesAndUnreadMsgCount");
+
+        Map<Long, ChatActivityDao> lastMsgMongoMap = lastMessages.stream()
+                .collect(Collectors.toMap(
+                        dao -> Long.parseLong(dao.chatRoomId()),
+                        dao -> dao
+                ));
+
+        List<Long> userIds = createUserIds(lastMessages);
+        log.info("START findByIdIn");
+        Map<Long, User> userMap = userCustomRepository.findAllWithImageByIdIn(userIds).stream()
+                .collect(Collectors.toMap(User::getId, user -> user));
+        log.info("END findByIdIn");
+
+        log.info("START dto Change");
+        return chatRooms.stream()
                 .map(chatRoom -> {
-                    ChatMessageDto lastMessageDto = chatMessagePolicy.getLastChatMessage(chatRoom.getId());
-                    ChatParticipant chatParticipant = getChatParticipant(chatRoom, userId);
+                    ChatActivityDao dao = lastMsgMongoMap.get(chatRoom.getId());
+                    ChatMessageBriefDto lastMessageDto = ChatMessageBriefDto.of(dao.chatRoomId(), dao.chatMessageId().toString(), dao.senderId(), dao.message(), dao.createdAt());
+                    User user = userMap.get(Long.parseLong(dao.senderId()));
+                    ChatUserInfo chatUserInfo = user.getDeletedAt() == null ? ChatUserInfo.of(user) : ChatUserInfo.deletedUser(user.getId());
 
-                    int unReadMsgCnt = chatActivityService.unReadMessageCount(chatRoom.getId(), chatParticipant.getLastReadMessageId());
-                    return ChatRoomDto.of(chatRoom, unReadMsgCnt, lastMessageDto);
+                    return ChatRoomDto.of(chatRoom, Integer.parseInt(dao.unReadMsgCnt()), lastMessageDto, chatUserInfo);
                 })
-                .filter(Objects::nonNull) // null인 경우 제외
+                .filter(Objects::nonNull)
                 .toList();
-        return chatRoomDtos;
     }
 
     @Transactional(readOnly = true)
@@ -136,10 +173,15 @@ private boolean isParticipantExist(ChatRoom chatRoom, User user) {
                 .anyMatch(chatParticipant -> chatParticipant.getUser().getId().equals(user.getId()));
     }
 
-    private ChatParticipant getChatParticipant(ChatRoom chatRoom, Long userId) {
-        return chatRoom.getChatParticipants().stream()
-                .filter(p -> p.getUser().getId().equals(userId))
-                .findFirst()
-                .orElse(null);
+    private List<String> createChatRoomIds(List<ChatRoom> chatRooms) {
+        return chatRooms.stream()
+                .map(chatRoom -> chatRoom.getId().toString()).collect(Collectors.toList());
+    }
+
+    private List<Long> createUserIds(List<ChatActivityDao> lastMessages) {
+        return lastMessages.stream()
+                .map(dao -> Long.valueOf(dao.senderId()))
+                .distinct()
+                .collect(Collectors.toList());
     }
 }

src/main/java/org/prgms/locomocoserver/chat/application/MongoChatMessageService.java

@@ -5,115 +5,94 @@
 import org.prgms.locomocoserver.chat.domain.ChatRoomRepository;
 import org.prgms.locomocoserver.chat.domain.mongo.ChatMessageMongo;
 import org.prgms.locomocoserver.chat.domain.mongo.ChatMessageMongoCustomRepository;
+import org.prgms.locomocoserver.chat.domain.mongo.ChatMessageMongoRepository;
+import org.prgms.locomocoserver.chat.domain.querydsl.ChatRoomCustomRepository;
 import org.prgms.locomocoserver.chat.dto.ChatMessageDto;
 import org.prgms.locomocoserver.chat.dto.ChatUserInfo;
 import org.prgms.locomocoserver.chat.dto.request.ChatMessageRequestDto;
 import org.prgms.locomocoserver.chat.exception.ChatErrorType;
 import org.prgms.locomocoserver.chat.exception.ChatException;
-import org.prgms.locomocoserver.chat.domain.querydsl.ChatRoomCustomRepository;
 import org.prgms.locomocoserver.user.application.UserService;
 import org.prgms.locomocoserver.user.domain.User;
 import org.prgms.locomocoserver.user.exception.UserException;
 import org.springframework.context.annotation.Primary;
-import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.time.LocalDateTime;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.stream.Collectors;
 
 @Primary
 @Service
 @RequiredArgsConstructor
 public class MongoChatMessageService implements ChatMessagePolicy {
 
-    private static final String BASE_CHATROOM_NAME = "chat_messages_";
-    private final MongoTemplate mongoTemplate;
+    private final ChatMessageMongoRepository chatMessageMongoRepository;
     private final ChatMessageMongoCustomRepository chatMessageMongoCustomRepository;
     private final UserService userService;
     private final ChatRoomRepository chatRoomRepository;
     private final ChatRoomCustomRepository chatRoomCustomRepository;
 
-    @Transactional
-    public ChatRoom createChatRoom(Long roomId) {
-        String collectionName = BASE_CHATROOM_NAME + roomId;
-
-        if (!mongoTemplate.collectionExists(collectionName)) {
-            mongoTemplate.createCollection(collectionName);
-        }
-
-        return chatRoomRepository.findById(roomId).orElseThrow(() -> new ChatException(ChatErrorType.CHATROOM_NOT_FOUND));
-    }
-
     @Transactional
     public ChatMessageDto saveEnterMessage(Long roomId, User sender) {
-        String collectionName = BASE_CHATROOM_NAME + roomId;
-        ChatMessageMongo chatMessageMongo = mongoTemplate.save(toEnterMessage(sender), collectionName);
+        ChatMessageMongo chatMessageMongo = chatMessageMongoRepository.save(toEnterMessage(roomId, sender));
 
         return ChatMessageDto.of(roomId, chatMessageMongo, ChatUserInfo.of(sender));
     }
 
     @Transactional
     public ChatMessageDto saveChatMessage(Long roomId, ChatMessageRequestDto message) {
-        String collectionName = BASE_CHATROOM_NAME + roomId;
         User participant = userService.getById(message.senderId());
 
         ChatRoom chatRoom = chatRoomRepository.findByIdAndDeletedAtIsNull(roomId)
                 .orElseThrow(() -> new ChatException(ChatErrorType.CHATROOM_NOT_FOUND));
 
-        ChatMessageMongo chatMessageMongo = mongoTemplate.save(message.toChatMessageMongo(false, null), collectionName);
+        ChatMessageMongo chatMessageMongo = chatMessageMongoRepository.save(message.toChatMessageMongo(roomId, false, null));
         chatRoom.updateUpdatedAt();
 
         return ChatMessageDto.of(roomId, chatMessageMongo, ChatUserInfo.of(participant));
     }
 
-    @Override
     @Transactional
     public ChatMessageDto saveChatMessageWithImage(Long roomId, List<String> imageUrls, ChatMessageRequestDto request) {
-        String collectionName = BASE_CHATROOM_NAME + roomId;
         User participant = userService.getById(request.senderId());
 
         ChatRoom chatRoom = chatRoomRepository.findByIdAndDeletedAtIsNull(roomId)
                 .orElseThrow(() -> new ChatException(ChatErrorType.CHATROOM_NOT_FOUND));
 
-        ChatMessageMongo chatMessageMongo = mongoTemplate.save(request.toChatMessageMongo(false, imageUrls), collectionName);
+        ChatMessageMongo chatMessageMongo = chatMessageMongoRepository.save(request.toChatMessageMongo(roomId, false, imageUrls));
         chatRoom.updateUpdatedAt();
 
         return ChatMessageDto.of(roomId, imageUrls, chatMessageMongo, ChatUserInfo.of(participant));
     }
 
     @Transactional(readOnly = true)
     public List<ChatMessageDto> getAllChatMessages(Long roomId, String cursorValue, int pageSize) {
-        List<ChatMessageMongo> chatMessages = chatMessageMongoCustomRepository.findAllChatMessagesByRoomId(roomId, cursorValue, pageSize);
+        List<ChatMessageMongo> chatMessages = chatMessageMongoCustomRepository.findAllChatMessages(roomId, cursorValue, pageSize);
         Map<Long, ChatUserInfo> userMap = getUserMap(roomId);
 
         return createChatMessageDtos(roomId, chatMessages, userMap);
     }
 
     @Transactional
     public void deleteChatMessages(ChatRoom chatRoom) {
-        chatMessageMongoCustomRepository.deleteAllChatMessages(chatRoom.getId());
+        chatMessageMongoRepository.deleteByChatRoomId(chatRoom.getId().toString());
     }
 
     @Transactional(readOnly = true)
     public ChatMessageDto getLastChatMessage(Long roomId) {
-        ChatMessageMongo lastMessage = chatMessageMongoCustomRepository.findLatestMessageByRoomId(roomId)
+        ChatMessageMongo lastMessage = chatMessageMongoRepository.findTopByChatRoomIdOrderByCreatedAtDesc(roomId.toString())
                 .orElseThrow(() -> new ChatException(ChatErrorType.CHAT_MESSAGE_NOT_FOUND));
 
         ChatUserInfo chatUserInfo = getChatUserInfo(lastMessage.getSenderId());
         return ChatMessageDto.of(roomId, lastMessage, chatUserInfo);
     }
 
-    public String getChatRoomName(Long roomId) {
-        return BASE_CHATROOM_NAME + roomId;
-    }
-
-    private ChatMessageMongo toEnterMessage(User participant) {
-        return ChatMessageMongo.builder().senderId(participant.getId().toString()).createdAt(LocalDateTime.now())
+    private ChatMessageMongo toEnterMessage(Long roomId, User participant) {
+        return ChatMessageMongo.builder().chatRoomId(roomId.toString()).senderId(participant.getId().toString()).createdAt(LocalDateTime.now())
                 .message(participant.getNickname() + "님이 입장하셨습니다.").isNotice(true).build();
     }
 

src/main/java/org/prgms/locomocoserver/chat/dao/ChatActivityDao.java

@@ -0,0 +1,15 @@
+package org.prgms.locomocoserver.chat.dao;
+
+import org.bson.types.ObjectId;
+
+import java.time.LocalDateTime;
+
+public record ChatActivityDao(
+        String unReadMsgCnt,
+        String chatRoomId,
+        ObjectId chatMessageId,
+        String senderId,
+        String message,
+        LocalDateTime createdAt
+) {
+}

src/main/java/org/prgms/locomocoserver/chat/dao/ChatActivityRequestDao.java

@@ -0,0 +1,9 @@
+package org.prgms.locomocoserver.chat.dao;
+
+import org.bson.types.ObjectId;
+
+public record ChatActivityRequestDao(
+        String chatRoomId,
+        ObjectId lastReadMsgId
+) {
+}

src/main/java/org/prgms/locomocoserver/chat/domain/mongo/ChatActivity.java

@@ -0,0 +1,33 @@
+package org.prgms.locomocoserver.chat.domain.mongo;
+
+import lombok.Builder;
+import lombok.Getter;
+import org.bson.types.ObjectId;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.mongodb.core.index.CompoundIndex;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+@Getter
+@Document(collection = "chat_activity")
+@CompoundIndex(def = "{'userId': 1, 'chatRoomId': 1}", name = "user_chatRoom_idx", unique = true)
+public class ChatActivity {
+    @Id
+    private String id;
+    private String userId;
+    private String chatRoomId;
+    private ObjectId lastReadMsgId;
+
+    @Builder
+    public ChatActivity(String userId, String chatRoomId) {
+        this.userId = userId;
+        this.chatRoomId = chatRoomId;
+        this.lastReadMsgId = null;
+    }
+
+    public void updateLastReadMessage(String userId, ObjectId lastReadMsgId) {
+        if (!this.userId.equals(userId)) {
+            throw new IllegalArgumentException("Invalid User Id : " + userId);
+        }
+        this.lastReadMsgId = lastReadMsgId;
+    }
+}

src/main/java/org/prgms/locomocoserver/chat/domain/mongo/ChatActivityRepository.java

@@ -0,0 +1,11 @@
+package org.prgms.locomocoserver.chat.domain.mongo;
+
+import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface ChatActivityRepository extends MongoRepository<ChatActivity, String> {
+    Optional<ChatActivity> findByUserIdAndChatRoomId(String userId, String chatRoomId);
+}