Seminar/#7

build.gradle

@@ -58,6 +58,8 @@ dependencies {
     // redis
     implementation 'org.springframework.boot:spring-boot-starter-data-redis'
 
+    // web socket
+    implementation 'org.springframework.boot:spring-boot-starter-websocket'
 }
 
 tasks.named('test') {

src/main/java/org/sopt/assignment/article/controller/ArticleController.java

@@ -3,7 +3,6 @@
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.sopt.assignment.article.domain.ESearchType;
-import org.sopt.assignment.article.domain.ETag;
 import org.sopt.assignment.article.dto.command.SaveArticleCommandDto;
 import org.sopt.assignment.article.dto.request.SaveArticleRequestDto;
 import org.sopt.assignment.article.dto.response.ArticleResponseDto;

src/main/java/org/sopt/assignment/article/domain/Article.java

@@ -14,8 +14,8 @@
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @Getter
 @Table(name = "articles", indexes = {
-        @Index(name = "idx_member_id", columnList = "member_id"),
-        @Index(name = "idx_title", columnList = "title"),
+        @Index(name = "idx_member_created", columnList = "member_id, created_at"),
+
         @Index(name = "idx_created_at", columnList = "created_at")
 })
 public class Article extends BaseTimeEntity {

src/main/java/org/sopt/assignment/article/domain/ETag.java

@@ -1,7 +1,6 @@
 package org.sopt.assignment.article.domain;
 
 import lombok.Getter;
-import lombok.RequiredArgsConstructor;
 
 @Getter
 public enum ETag {

src/main/java/org/sopt/assignment/article/service/ArticleService.java

@@ -63,6 +63,18 @@ public GetListArticleResponseDto searchArticle(ESearchType searchType, String ke
         return GetListArticleResponseDto.of(articlePage.map(GetListArticleResponse::from));
     }
 
+    @Transactional(readOnly = true)
+    public Article get(Long articleId){
+        return articleRepository.findById(articleId)
+                .orElseThrow(()-> BaseException.type(ArticleErrorCode.NOT_FOUND_ARTICLE));
+    }
+
+    @Transactional(readOnly = true)
+    public void validateArticleExists(Long articleId){
+        if(!articleRepository.existsById(articleId))
+            throw BaseException.type(ArticleErrorCode.NOT_FOUND_ARTICLE);
+    }
+
     private void validateDuplicateTitle(String title){
         if(articleRepository.existsByTitle(title)){
             throw BaseException.type(ArticleErrorCode.ALREADY_USED_ARTICLE_TITLE);

src/main/java/org/sopt/assignment/chat/controller/ChatController.java

@@ -0,0 +1,33 @@
+package org.sopt.assignment.chat.controller;
+
+import lombok.RequiredArgsConstructor;
+import org.sopt.assignment.chat.domain.ChatMessage;
+import org.sopt.assignment.chat.domain.ConnectedUser;
+import org.sopt.assignment.chat.service.ChatService;
+import org.sopt.assignment.chat.service.ChatSessionManager;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/chat")
+@RequiredArgsConstructor
+public class ChatController {
+    private final ChatService chatService;
+    private final ChatSessionManager  chatSessionManager;
+
+    @GetMapping("/messages")
+    public List<ChatMessage> getMessages(
+            @RequestParam(defaultValue = "50") int count
+    ) {
+        return chatService.getRecentMessages(count);
+    }
+
+    @GetMapping("/users")
+    public List<ConnectedUser> getConnectedUsers() {
+        return chatSessionManager.getConnectedUsers();
+    }
+}

src/main/java/org/sopt/assignment/chat/domain/ChatMessage.java

@@ -0,0 +1,19 @@
+package org.sopt.assignment.chat.domain;
+
+import java.time.LocalDateTime;
+
+public record ChatMessage(
+    EMessageType type,
+
+    String sender,
+
+    String content,
+
+    LocalDateTime timestamp
+
+) {
+
+    public static ChatMessage of(EMessageType type, String sender, String content) {
+        return new ChatMessage(type, sender, content, LocalDateTime.now());
+    }
+}

src/main/java/org/sopt/assignment/chat/domain/ConnectedUser.java

@@ -0,0 +1,13 @@
+package org.sopt.assignment.chat.domain;
+
+public record ConnectedUser(
+        Long userId,
+
+        String userName,
+
+        String sessionId
+) {
+    public static ConnectedUser of(Long userId, String userName, String sessionId) {
+        return new ConnectedUser(userId, userName, sessionId);
+    }
+}

src/main/java/org/sopt/assignment/chat/domain/EMessageType.java

@@ -0,0 +1,9 @@
+package org.sopt.assignment.chat.domain;
+
+public enum EMessageType {
+    CHAT,
+    ENTER,
+    LEAVE,
+    TYPING_START,
+    TYPING_END
+}

src/main/java/org/sopt/assignment/chat/exception/ChatErrorCode.java

@@ -0,0 +1,18 @@
+package org.sopt.assignment.chat.exception;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.sopt.assignment.global.exception.ErrorCode;
+import org.springframework.http.HttpStatus;
+
+@RequiredArgsConstructor
+@Getter
+public enum ChatErrorCode implements ErrorCode {
+
+    FAILED_SAVE_MESSAGE(HttpStatus.INTERNAL_SERVER_ERROR, "CHAT_001", "메시지 저장에 실패했습니다."),;
+
+    private final HttpStatus status;
+    private final String errorCode;
+    private final String message;
+
+}

src/main/java/org/sopt/assignment/chat/handler/ChatWebSocketHandler.java

@@ -0,0 +1,92 @@
+package org.sopt.assignment.chat.handler;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.sopt.assignment.chat.domain.ChatMessage;
+import org.sopt.assignment.chat.service.ChatService;
+import org.sopt.assignment.chat.service.ChatSessionManager;
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.CloseStatus;
+import org.springframework.web.socket.TextMessage;
+import org.springframework.web.socket.WebSocketSession;
+import org.springframework.web.socket.handler.TextWebSocketHandler;
+
+import java.io.IOException;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class ChatWebSocketHandler extends TextWebSocketHandler {
+
+    private final Set<WebSocketSession> sessions = new CopyOnWriteArraySet<>();
+    private final ObjectMapper objectMapper;
+    private final ChatService chatService;
+    private final ChatSessionManager chatSessionManager;
+
+    @Override
+    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
+        sessions.add(session);
+
+        Long memberId = getUserId(session);
+        log.info("새로운 연결: {}, 현재 접속자: {}", session.getId(), sessions.size());
+
+        chatSessionManager.addUser(memberId, session.getId());
+
+        ChatMessage enterMessage = chatService.createEnterMessage(memberId);
+        broadcast(enterMessage);
+    }
+
+
+    @Override
+    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
+        String payload = message.getPayload();
+        Long memberId = getUserId(session);
+        log.info("받은 메시지: {} from {}", payload, session.getId());
+
+        try {
+            ChatMessage chatMessage = chatService.processMessage(payload, memberId);
+            broadcast(chatMessage);
+        } catch (Exception e) {
+            log.error("메시지 처리 실패: sessionId = {}", session.getId(), e);
+        }
+    }
+
+
+    @Override
+    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
+        sessions.remove(session);
+        log.info("연결 종료: {}, 현재 접속자: {}", session.getId(), sessions.size());
+        Long memberId = getUserId(session);
+        chatSessionManager.removeUserBySessionId(session.getId());
+        ChatMessage leaveMessage = chatService.createLeaveMessage(memberId);
+        broadcast(leaveMessage);
+    }
+
+    @Override
+    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
+        log.error("에러 발생: {}", session.getId(), exception);
+        if (!session.isOpen()) {
+            log.warn("세션이 실제로 닫혔음, 제거 처리: sessionId={}", session.getId());
+            sessions.remove(session);
+            chatSessionManager.removeUserBySessionId(session.getId());
+        }
+    }
+
+    private void broadcast(ChatMessage message) {
+        sessions.forEach(session -> {
+            try{
+                String json =  objectMapper.writeValueAsString(message);
+                session.sendMessage(new TextMessage(json));
+            } catch (IOException e){
+                log.error("메시지 전송 실패: {}", session.getId(), e);
+            }
+        });
+    }
+
+    private Long getUserId(WebSocketSession session) {
+        return (Long) session.getAttributes().get("userId");
+    }
+}

src/main/java/org/sopt/assignment/chat/service/ChatService.java

@@ -0,0 +1,111 @@
+package org.sopt.assignment.chat.service;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.sopt.assignment.chat.domain.EMessageType;
+import org.sopt.assignment.chat.domain.ChatMessage;
+import org.sopt.assignment.chat.exception.ChatErrorCode;
+import org.sopt.assignment.global.constants.Constants;
+import org.sopt.assignment.global.exception.BaseException;
+import org.sopt.assignment.member.service.MemberService;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.sopt.assignment.global.constants.Constants.CHAT_MESSAGES_KEY;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class ChatService {
+
+    private final ObjectMapper objectMapper;
+    private final RedisTemplate<String, String> redisTemplate;
+    private final MemberService memberService;
+
+    public ChatMessage processMessage(String payload, Long memberId){
+        try{
+            ChatMessage message = objectMapper.readValue(payload, ChatMessage.class);
+
+            String memberName = memberService.getMemberById(memberId).getName();
+
+            if(message.type() == EMessageType.TYPING_START || message.type() == EMessageType.TYPING_END){
+                return ChatMessage.of(message.type(), memberName, "");
+            }
+
+            ChatMessage chatMessage = ChatMessage.of(message.type(), memberName, message.content());
+
+            if(message.type() == EMessageType.CHAT){
+                saveMessage(chatMessage);
+            }
+
+            return chatMessage;
+        } catch (JsonProcessingException e){
+            log.error("메시지 저장 실패", e);
+            throw BaseException.type(ChatErrorCode.FAILED_SAVE_MESSAGE);
+        }
+
+    }
+
+
+    public ChatMessage createEnterMessage(Long memberId) {
+        String memberName = memberService.getMemberById(memberId).getName();
+
+        return ChatMessage.of(
+                EMessageType.ENTER,
+                memberName,
+                memberName + "님이 입장했습니다."
+        );
+    }
+
+    // 퇴장 메시지 생성
+    public ChatMessage createLeaveMessage(Long memberId) {
+        String memberName = memberService.getMemberById(memberId).getName();
+
+        return ChatMessage.of(
+                EMessageType.LEAVE,
+                memberName,
+                memberName + "님이 퇴장했습니다."
+        );
+    }
+
+    public void saveMessage(ChatMessage message) {
+        try {
+            String json = objectMapper.writeValueAsString(message);
+
+            redisTemplate.opsForList().leftPush(CHAT_MESSAGES_KEY, json);
+
+            redisTemplate.opsForList().trim(CHAT_MESSAGES_KEY, 0, Constants.MAX_MESSAGE_COUNT - 1);
+
+            log.info("Redis 저장: {}", message.content());
+        } catch (JsonProcessingException e){
+            log.error("메시지 저장 실패", e);
+        }
+    }
+
+    public List<ChatMessage> getRecentMessages(int count) {
+        List<String> messages = redisTemplate.opsForList().range(
+                CHAT_MESSAGES_KEY,
+                0,
+                count - 1
+        );
+
+        List<ChatMessage> result = new ArrayList<>();
+        if (messages != null) {
+            for (String json : messages) {
+                try {
+                    result.add(objectMapper.readValue(json, ChatMessage.class));
+                } catch (JsonProcessingException e) {
+                    log.error("메시지 파싱 실패: {}", json, e);
+                }
+            }
+        }
+
+        return result;
+    }
+
+}