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

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

@@ -4,6 +4,7 @@
 import org.springframework.web.socket.WebSocketSession;
 
 import java.util.Collections;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -27,6 +28,12 @@ public boolean contains(final Long userId) {
                        .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

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

@@ -0,0 +1,139 @@
+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.domain.WebSocketSessions;
+import com.ddang.ddang.chat.handler.dto.ChatMessageDataDto;
+import com.ddang.ddang.chat.handler.dto.MessageDataDto;
+import com.ddang.ddang.chat.handler.dto.MessageDto;
+import com.ddang.ddang.chat.handler.dto.SendChatResponse;
+import com.ddang.ddang.chat.handler.dto.SendMessageStatus;
+import com.ddang.ddang.chat.presentation.dto.request.CreateMessageRequest;
+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 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;
+
+@Component
+@RequiredArgsConstructor
+public class MessageTypeHandler implements ChatHandleProvider {
+
+    private final WebSocketChatSessions sessions;
+    private final ObjectMapper objectMapper;
+    private final MessageService messageService;
+    private final ApplicationEventPublisher messageLogEventPublisher;
+    private final ApplicationEventPublisher messageNotificationEventPublisher;
+
+    @Override
+    public ChatMessageType supportsChatType() {
+        return ChatMessageType.MESSAGE;
+    }
+
+    @Override
+    public List<SendMessageDto> createResponse(
+            final SessionAttributeDto sessionAttributeDto,
+            final Map<String, String> data
+    ) throws JsonProcessingException {
+        final Long writerId = sessionAttributeDto.userId();
+        final MessageDataDto messageDataDto = MessageDataDto.from(data);
+
+        final Message message = createMessage(data, writerId);
+
+        sendNotificationIfReceiverNotInSession(message, sessionAttributeDto);
+
+        return createSendMessages(message, writerId, messageDataDto.chatRoomId());
+    }
+
+    private Message createMessage(final Map<String, String> data, final long writerId) {
+        final ChatMessageDataDto messageData = objectMapper.convertValue(data, ChatMessageDataDto.class);
+        final CreateMessageDto createMessageDto = createMessageDto(messageData, writerId);
+
+        return messageService.create(createMessageDto);
+    }
+
+    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 WebSocketSessions groupSessions = sessions.findSessionsByChatRoomId(message.getChatRoom().getId());
+
+        final List<SendMessageDto> sendMessageDtos = new ArrayList<>();
+        for (final WebSocketSession currentSession : groupSessions.getSessions()) {
+            final MessageDto messageDto = MessageDto.of(message, isMyMessage(currentSession, writerId));
+            final TextMessage textMessage = createTextMessage(messageDto);
+            sendMessageDtos.add(new SendMessageDto(currentSession, textMessage));
+            updateReadMessageLog(currentSession, chatRoomId, message);
+        }
+
+        return sendMessageDtos;
+    }
+
+    private void updateReadMessageLog(
+            final WebSocketSession currentSession,
+            final Long chatRoomId,
+            final Message message
+    ) {
+        final SessionAttributeDto sessionAttributes = convertToSessionAttributeDto(currentSession);
+        final UpdateReadMessageLogEvent updateReadMessageLogEvent = new UpdateReadMessageLogEvent(
+                sessionAttributes.userId(),
+                chatRoomId,
+                message.getId()
+        );
+        messageLogEventPublisher.publishEvent(updateReadMessageLogEvent);
+    }
+
+    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 boolean isMyMessage(
+            final WebSocketSession session,
+            final Long writerId
+    ) {
+        final long userId = Long.parseLong(String.valueOf(session.getAttributes().get("userId")));
+
+        return writerId.equals(userId);
+    }
+
+    private TextMessage createTextMessage(final MessageDto messageDto) throws JsonProcessingException {
+        final SendChatResponse sendChatResponse = new SendChatResponse(SendMessageStatus.SUCCESS, List.of(messageDto));
+
+        return new TextMessage(objectMapper.writeValueAsString(sendChatResponse));
+    }
+}