Ping 통신을 위한 데이터 타입 변경

backend/ddang/src/main/java/com/ddang/ddang/chat/application/LastReadMessageLogEventListener.java

@@ -2,7 +2,6 @@
 
 import com.ddang.ddang.chat.application.event.CreateReadMessageLogEvent;
 import com.ddang.ddang.chat.application.event.UpdateReadMessageLogEvent;
-import com.ddang.ddang.chat.application.exception.ReadMessageLogNotFoundException;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
@@ -31,8 +30,12 @@ public void create(final CreateReadMessageLogEvent createReadMessageLogEvent) {
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void update(final UpdateReadMessageLogEvent updateReadMessageLogEvent) {
         try {
+            log.info(
+                    "LastReadMessageLogEventListener.update updateReadMessageLogEvent : {}",
+                    updateReadMessageLogEvent.toString()
+            );
             lastReadMessageLogService.update(updateReadMessageLogEvent);
-        } catch (final ReadMessageLogNotFoundException ex) {
+        } catch (final Exception ex) {
             log.error("exception type : {}, ", ex.getClass().getSimpleName(), ex);
         }
     }

backend/ddang/src/main/java/com/ddang/ddang/chat/domain/WebSocketChatSessions.java

@@ -5,7 +5,6 @@
 import org.springframework.web.socket.WebSocketSession;
 
 import java.util.Map;
-import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
 import static com.ddang.ddang.chat.domain.WebSocketSessions.CHAT_ROOM_ID_KEY;
@@ -22,10 +21,8 @@ public void add(final WebSocketSession session, final Long chatRoomId) {
         webSocketSessions.putIfAbsent(session, chatRoomId);
     }
 
-    public Set<WebSocketSession> getSessionsByChatRoomId(final Long chatRoomId) {
-        final WebSocketSessions webSocketSessions = chatRoomSessions.get(chatRoomId);
-
-        return webSocketSessions.getSessions();
+    public WebSocketSessions findSessionsByChatRoomId(final Long chatRoomId) {
+        return chatRoomSessions.get(chatRoomId);
     }
 
     public boolean containsByUserId(final Long chatRoomId, final Long userId) {

backend/ddang/src/main/java/com/ddang/ddang/chat/domain/WebSocketSessions.java

@@ -1,12 +1,17 @@
 package com.ddang.ddang.chat.domain;
 
 import lombok.Getter;
+import lombok.ToString;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.web.socket.WebSocketSession;
 
 import java.util.Collections;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+@ToString
+@Slf4j
 @Getter
 public class WebSocketSessions {
 
@@ -23,10 +28,17 @@ public void putIfAbsent(final WebSocketSession session, final Long chatRoomId) {
     }
 
     public boolean contains(final Long userId) {
+        log.info("WebSocketSessions.contains userId : {}, currentSessions : {}", userId, sessions);
         return sessions.stream()
                        .anyMatch(session -> session.getAttributes().get(USER_ID_KEY) == userId);
     }
 
+    public Optional<WebSocketSession> findByUserId(final long userId) {
+        return sessions.stream()
+                       .filter(session -> session.getAttributes().get(USER_ID_KEY).equals(userId))
+                       .findFirst();
+    }
+
     public void remove(final WebSocketSession session) {
         sessions.remove(session);
     }

backend/ddang/src/main/java/com/ddang/ddang/chat/handler/ChatHandleProvider.java

@@ -0,0 +1,19 @@
+package com.ddang.ddang.chat.handler;
+
+import com.ddang.ddang.websocket.handler.dto.ChatMessageType;
+import com.ddang.ddang.websocket.handler.dto.SendMessageDto;
+import com.ddang.ddang.websocket.handler.dto.SessionAttributeDto;
+import com.fasterxml.jackson.core.JsonProcessingException;
+
+import java.util.List;
+import java.util.Map;
+
+public interface ChatHandleProvider {
+
+    List<SendMessageDto> createResponse(
+            final SessionAttributeDto sessionAttributeDto,
+            final Map<String, String> data
+    ) throws JsonProcessingException;
+
+    ChatMessageType supportsChatType();
+}

backend/ddang/src/main/java/com/ddang/ddang/chat/handler/ChatHandleTypeProviderComposite.java

@@ -0,0 +1,23 @@
+package com.ddang.ddang.chat.handler;
+
+import com.ddang.ddang.websocket.handler.dto.ChatMessageType;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@Component
+public class ChatHandleTypeProviderComposite {
+
+    private final Map<ChatMessageType, ChatHandleProvider> mappings;
+
+    public ChatHandleTypeProviderComposite(final Set<ChatHandleProvider> providers) {
+        this.mappings = providers.stream()
+                                 .collect(Collectors.toMap(ChatHandleProvider::supportsChatType, provider -> provider));
+    }
+
+    public ChatHandleProvider findProvider(final ChatMessageType chatMessageType) {
+        return mappings.get(chatMessageType);
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/chat/handler/ChatWebSocketHandleTextMessageProvider.java

@@ -1,40 +1,30 @@
 package com.ddang.ddang.chat.handler;
 
-import com.ddang.ddang.chat.application.MessageService;
-import com.ddang.ddang.chat.application.dto.CreateMessageDto;
-import com.ddang.ddang.chat.application.event.MessageNotificationEvent;
-import com.ddang.ddang.chat.application.event.UpdateReadMessageLogEvent;
-import com.ddang.ddang.chat.domain.Message;
 import com.ddang.ddang.chat.domain.WebSocketChatSessions;
-import com.ddang.ddang.chat.handler.dto.ChatMessageDataDto;
-import com.ddang.ddang.chat.handler.dto.MessageDto;
-import com.ddang.ddang.chat.presentation.dto.request.CreateMessageRequest;
 import com.ddang.ddang.websocket.handler.WebSocketHandleTextMessageProvider;
+import com.ddang.ddang.websocket.handler.dto.ChatMessageType;
 import com.ddang.ddang.websocket.handler.dto.SendMessageDto;
 import com.ddang.ddang.websocket.handler.dto.SessionAttributeDto;
 import com.ddang.ddang.websocket.handler.dto.TextMessageType;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.RequiredArgsConstructor;
-import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Component;
-import org.springframework.web.socket.TextMessage;
 import org.springframework.web.socket.WebSocketSession;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
 @Component
 @RequiredArgsConstructor
 public class ChatWebSocketHandleTextMessageProvider implements WebSocketHandleTextMessageProvider {
 
-    private final WebSocketChatSessions sessions;
+    private static final String CHATROOM_ID_KEY = "chatRoomId";
+    private static final String TYPE_KEY = "type";
+
     private final ObjectMapper objectMapper;
-    private final MessageService messageService;
-    private final ApplicationEventPublisher messageNotificationEventPublisher;
-    private final ApplicationEventPublisher messageLogEventPublisher;
+    private final WebSocketChatSessions sessions;
+    private final ChatHandleTypeProviderComposite chatHandleTypeProviderComposite;
 
     @Override
     public TextMessageType supportTextMessageType() {
@@ -44,94 +34,25 @@ public TextMessageType supportTextMessageType() {
     @Override
     public List<SendMessageDto> handleCreateSendMessage(
             final WebSocketSession session,
-            final Map<String, String> data
+            final Map<String, String> chatMessageData
     ) throws JsonProcessingException {
-        final SessionAttributeDto sessionAttribute = getSessionAttributes(session);
-        final ChatMessageDataDto messageData = objectMapper.convertValue(data, ChatMessageDataDto.class);
-        sessions.add(session, messageData.chatRoomId());
+        final long chatRoomId = getChatRoomId(chatMessageData);
+        sessions.add(session, chatRoomId);
 
-        final Long writerId = sessionAttribute.userId();
-        final CreateMessageDto createMessageDto = createMessageDto(messageData, writerId);
-        final Message message = messageService.create(createMessageDto);
-        sendNotificationIfReceiverNotInSession(message, sessionAttribute);
+        final ChatMessageType type = ChatMessageType.findMessageType(chatMessageData.get(TYPE_KEY));
+        final ChatHandleProvider provider = chatHandleTypeProviderComposite.findProvider(type);
 
-        return createSendMessages(message, writerId, createMessageDto.chatRoomId());
+        return provider.createResponse(convertToSessionAttributeDto(session), chatMessageData);
     }
 
-    private SessionAttributeDto getSessionAttributes(final WebSocketSession session) {
+    private SessionAttributeDto convertToSessionAttributeDto(final WebSocketSession session) {
         final Map<String, Object> attributes = session.getAttributes();
 
         return objectMapper.convertValue(attributes, SessionAttributeDto.class);
     }
 
-    private CreateMessageDto createMessageDto(final ChatMessageDataDto messageData, final Long userId) {
-        final CreateMessageRequest request = new CreateMessageRequest(
-                messageData.receiverId(),
-                messageData.contents()
-        );
-
-        return CreateMessageDto.of(userId, messageData.chatRoomId(), request);
-    }
-
-    private void sendNotificationIfReceiverNotInSession(
-            final Message message,
-            final SessionAttributeDto sessionAttribute
-    ) {
-        if (!sessions.containsByUserId(message.getChatRoom().getId(), message.getReceiver().getId())) {
-            final String profileImageAbsoluteUrl = String.valueOf(sessionAttribute.baseUrl());
-            messageNotificationEventPublisher.publishEvent(new MessageNotificationEvent(
-                    message,
-                    profileImageAbsoluteUrl
-            ));
-        }
-    }
-
-    private List<SendMessageDto> createSendMessages(
-            final Message message,
-            final Long writerId,
-            final Long chatRoomId
-    ) throws JsonProcessingException {
-        final Set<WebSocketSession> groupSessions = sessions.getSessionsByChatRoomId(message.getChatRoom().getId());
-
-        final List<SendMessageDto> sendMessageDtos = new ArrayList<>();
-        for (final WebSocketSession currentSession : groupSessions) {
-            final TextMessage textMessage = createTextMessage(message, writerId, currentSession);
-            sendMessageDtos.add(new SendMessageDto(currentSession, textMessage));
-            updateReadMessageLog(currentSession, chatRoomId, message);
-        }
-
-        return sendMessageDtos;
-    }
-
-    private TextMessage createTextMessage(
-            final Message message,
-            final Long writerId,
-            final WebSocketSession session
-    ) throws JsonProcessingException {
-        final boolean isMyMessage = isMyMessage(session, writerId);
-        final MessageDto messageDto = MessageDto.of(message, isMyMessage);
-
-        return new TextMessage(objectMapper.writeValueAsString(messageDto));
-    }
-
-    private boolean isMyMessage(final WebSocketSession session, final Long writerId) {
-        final long userId = Long.parseLong(String.valueOf(session.getAttributes().get("userId")));
-
-        return writerId.equals(userId);
-    }
-
-    private void updateReadMessageLog(
-            final WebSocketSession currentSession,
-            final Long chatRoomId,
-            final Message message
-    ) {
-        final SessionAttributeDto sessionAttributes = getSessionAttributes(currentSession);
-        final UpdateReadMessageLogEvent updateReadMessageLogEvent = new UpdateReadMessageLogEvent(
-                sessionAttributes.userId(),
-                chatRoomId,
-                message.getId()
-        );
-        messageLogEventPublisher.publishEvent(updateReadMessageLogEvent);
+    private long getChatRoomId(final Map<String, String> data) {
+        return Long.parseLong(data.get(CHATROOM_ID_KEY));
     }
 
     @Override