[식구하자_MSA] 🚀 채팅&알림 마이크로 서비스: 채팅 기능 개발(Stomp, Kafka, MongoDB) - 2편

목차

1. 소개
2. Eureka Client 등록
3. Kafka, Zookeeper, MongoDB 설치와 세팅
4. Spring 세팅
   • 4.1. Kafka 설정
   • 4.2. MongoDB 설정
   • 4.3. WebSocket 설정
5. 도메인 모델
6. 서비스 로직
7. 컨트롤러
8. 마무리

1. 소개

---

지난 포스팅에 이어 채팅 마이크로 서비스 개발 과정을 포스팅 하도록 하겠습니다. 주요 코드만 다룰 예정이라 다루지 않는 코드들은 아래 github를 통해 참고하시길 바랍니다🙏🙏(msa-master 브랜치)

+) Spring Cloud를 통한 MSA를 구축하시는 분이 아니라면 목차 3번부터 진행하시면 됩니다!

👉 참고 코드 : https://github.com/LminWoo99/PlantBackend/tree/msa-master

2. Eureka Client 등록

---

1️⃣ 의존성 추가

implementation 'org.springframework.cloud:spring-cloud-starter-netflix-eureka-client'
ext {
    set('springCloudVersion', "2021.0.4")
}

2️⃣ yml 작성

server:
  port: 0
spring:
  application:
    name: [서비스 명]
eureka:
  instance:
    prefer-ip-address: true
    instance-id: ${spring.application.name}:${spring.application.instance_id:${random.value}}
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://[도메인]:8761/eureka

3️⃣ @EurekaClient 등록

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
@EnableJpaAuditing
@EnableWebMvc
public class PlantChatServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(PlantChatServiceApplication.class, args);
    }

}

3. Kafka, Zookeeper, MongoDB 설치와 세팅

---

3.1. docker-compose.yml 작성

version: '3'
networks:
  plant-network:
    external: true
    name: plant-network

services:
  zookeeper:
    image: wurstmeister/zookeeper
    container_name: zookeeper
    ports:
      - "2181:2181"
    networks:
      - plant-network
  kafka:
    image: wurstmeister/kafka
    container_name: kafka
    ports:
      - "9092:9092"
    environment:
      KAFKA_ADVERTISED_HOST_NAME: localhost
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    depends_on:
      - zookeeper
    networks:
      - plant-network
  mongo:
    image: mongo:latest
    container_name: mongo
    ports:
      - "27017:27017"
    environment:
      MONGO_INITDB_ROOT_USERNAME: [유저name]
      MONGO_INITDB_ROOT_PASSWORD: [유저 password]
    networks:
      - plant-network

docker-compose.yml 파일에 위에 작성된 코드를 붙여 넣어 주시고 프로젝트 최상단 위치에서 아래의 명령어를 입력해줍니다.

docker-compose up -d

🚨 주의사항!

MongoDB 구축 시 username과 password를 설정하지 않으면 심각한 보안 이슈가 발생할 수 있습니다. 최근 많은 사례에서 보안이 취약한 MongoDB 인스턴스가 랜섬웨어 공격의 대상이 되어 데이터가 암호화되거나 삭제되는 사고가 발생했습니다. 이를 예방하기 위해 반드시 강력한 인증 정보를 설정하고, 필요한 경우에만 외부에서 접근 가능하도록 네트워크 설정을 해야 합니다.

3.2. Zookeeper 설정

• zookeeper docker 접속

   docker exec -it zookeeper bash
  

• Zookeeper 서버를 실행

  bash bin/zkServer.sh start /opt/zookeeper-3.4.13/conf/zoo.cfg -demon
  

3.3. Kafka 설정

• Kafka Docker 접속

docker exec -it kafka bash

• Kafka 서버를 실행

kafka-server-start.sh -daemon

Kafka 서버 설정까지 완료 되었습니다.

Kafka 토픽 설정 및 테스트

Kafka 서버 설정이 완료되었습니다. 이제 Kafka의 핵심 개념인 Topic에 대해 알아보고, 테스트를 진행하겠습니다.

Kafka Topic 이해하기

Kafka에서 Topic은 메시지를 구분하는 단위입니다. pub/sub 모델을 통해 메시지의 생산과 소비가 이루어지며, 이를 위해서는 Topic을 먼저 생성해야 합니다.

💡참고: 실제 채팅 기능에 사용할 Topic은 Spring 애플리케이션에서 자동으로 생성할 예정입니다.

테스트 Topic 생성 및 확인

Kafka가 정상적으로 작동하는지 확인하기 위해 테스트용 Topic을 생성해보겠습니다.

1. Kafka Bash에 접속합니다.
2. 다음 명령어로 테스트 Topic을 생성합니다:

kafka-topics.sh --create --zookeeper zookeeper:2181 --topic test-topic --partitions 1 --replication-factor 1

1. Topic이 잘 생성되었는지 확인합니다:

kafka-topics.sh --list --zookeeper zookeeper

이 명령어를 실행하면 test-topic이 목록에 표시되어야 합니다.

🚀 Tip: 실제 프로덕션 환경에서는 보안과 성능을 고려하여 Topic의 파티션 수와 복제 팩터를 적절히 조정해야 합니다.

4. Spring 세팅

---

4.1. Kafka 설정

Kafka 컨슈머 설정

@EnableKafka
@Configuration
public class KafkaConsumerConfig {
    @Value("${kafka.url}")
    private String kafkaServerUrl;

    @Bean
    ConcurrentKafkaListenerContainerFactory<String, Message> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, Message> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        return factory;
    }

    @Bean
    public ConsumerFactory<String, Message> consumerFactory() {
        JsonDeserializer<ChatMessage> deserializer = new JsonDeserializer<>();
        deserializer.addTrustedPackages("*");
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, kafkaServerUrl);
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "chat");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, deserializer);
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "latest");

        return new DefaultKafkaConsumerFactory<>(props, new StringDeserializer(), deserializer);
    }
}

Kafka 프로듀서 설정

@EnableKafka
@Configuration
public class KafkaProducerConfig {
    @Value("${kafka.url}")
    private String kafkaServerUrl;
    @Bean
    public ProducerFactory<String, Message> producerFactory() {
        return new DefaultKafkaProducerFactory<>(producerConfigurations());
    }

   // Kafka Producer 구성을 위한 설정값들을 포함한 맵을 반환하는 메서드
    @Bean
    public Map<String, Object> producerConfigurations() {
        return ImmutableMap.<String, Object>builder()
                .put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, kafkaServerUrl)
                .put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class)
                .put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class)
                //멱등성 프로듀서 명시적 설정
                .put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true)
                .build();
    }
}

4.2. MongoDB 설정

mongodb:
  client: mongodb://{ip주소}:27017
  name : {db 이름}

설정 클래스에 사용할 properties 파일을 작성

@Data
@Component
@ConfigurationProperties(prefix = "mongo-db")
public class MongoDbProperties {
    private String connectionString;
    private String databaseName;
}

MongoConfig 클래스 작성

// MongoDB 설정 클래스
@Configuration
@RequiredArgsConstructor
@EnableMongoRepositories(basePackages = "com.example.plantchatservice.repository.mongo")
public class MongoDbConfiguration {
    private final MongoDbSettings mongoDbSettings;

    // MongoDB 클라이언트 빈 생성
    @Bean
    public MongoClient createMongoClient() {
        return MongoClients.create(mongoDbSettings.getConnectionString());
    }

    // MongoTemplate 빈 생성
    @Bean
    public MongoTemplate createMongoTemplate() {
        return new MongoTemplate(createMongoClient(), mongoDbSettings.getDatabaseName());
    }
}

4.3. WebSocket 설정

@Configuration
@RequiredArgsConstructor
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    private final StompHandler stompHandler;

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/chat")
                .setAllowedOriginPatterns("*")
                .withSockJS();
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/subscribe");
        registry.setApplicationDestinationPrefixes("/publish");
    }

    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {
        registration.interceptors(stompHandler);
    }
}

웹소켓 설정 정보는 중요하니 메서드별로 자세히 알아보도록 하겠습니다!

1. STOMP 엔드포인트 등록

@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
    registry.addEndpoint("/chat")
            .setAllowedOriginPatterns("*")
            .withSockJS();
}

• 엔드포인트: /chat
• 목적: 프론트엔드에서 STOMP 연결 시도 시 사용할 엔드포인트 지정
• ⚠️ 주의사항:
  • setAllowedOriginPatterns("*"): 모든 오리진 허용 (개발 환경)
  • 프로덕션 환경에서는 보안을 위해 특정 오리진만 허용해야 함
• withSockJS(): SockJS 지원 활성화

2. 메시지 브로커 구성

@Override
public void configureMessageBroker(MessageBrokerRegistry registry) {
    registry.enableSimpleBroker("/subscribe");
    registry.setApplicationDestinationPrefixes("/publish");
}

• 구독 접두사: /subscribe
  • 사용 예: /subscribe/{chatNo} (채팅방 번호로 구독)
• 메시지 전송 접두사: /publish
  • 사용 예: /publish/message (메시지 전송 컨트롤러로 라우팅)

3. 클라이언트 인바운드 채널 구성

@Override
public void configureClientInboundChannel(ChannelRegistration registration) {
    registration.interceptors(stompHandler);
}

• 목적: STOMP 메시지 핸들링
• stompHandler를 인터셉터로 등록
  • 들어오는 STOMP 메시지 처리
  • 필요시 추가적인 로직 구현 가능 (예: 인증, 로깅 등)

---

💡 핵심 포인트

1. 엔드포인트: /chat을 통해 WebSocket 연결
2. 구독: /subscribe/{chatNo}로 특정 채팅방 구독
3. 발행: /publish/message로 메시지 전송
4. 보안: StompHandler를 통한 메시지 처리 및 추가 로직 구현 가능

이 설정을 통해 채팅방별로 효과적인 메시지 관리 및 전달이 가능합니다.

5. 도메인 모델

---

MongoDB에서 메시지 저장에 사용할 도메인 (채팅 내역 데이터)

@Document(collection="chatting")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Chatting {
    @Id
    private String id;
    private Integer chatRoomNo;
    private Integer senderNo;
    private String senderName;
    private String contentType;
    private String content;
    private LocalDateTime sendDate;
    private long readCount;

    @Builder
    public Chatting(String id, Integer chatRoomNo, Integer senderNo, String senderName, String contentType, String content, LocalDateTime sendDate, long readCount) {
        this.id = id;
        this.chatRoomNo = chatRoomNo;
        this.senderNo = senderNo;
        this.senderName = senderName;
        this.contentType = contentType;
        this.content = content;
        this.sendDate = sendDate;
        this.readCount = readCount;
    }
}

Kafka에서 메시지 전달에 사용할 도메인 모델

+) 추가로 msa를 구축하시는 분들은 웹소켓은 ws 프로토콜을 사용하기 떄문에 gateway yml에 아래 코드를 추가해줘야 합니다!!

        - id: plant-chat-service
          uri: lb:ws://PLANT-CHAT-SERVICE
          predicates:
            - Path=/plant-chat-service/chat/**
          filters:
            - RemoveRequestHeader=Cookie
            - RewritePath=/plant-chat-service/(?<segment>.*), /$\{segment}

6. 서비스 로직

---

먼저 저는 plant-service(중고 거래 게시글 마이크로 서비스)에 중고 거래 게시글 데이터가 있기 떄문에 FeignCleint를 통해 필요한 정보를 가져왔습니다.

그래서 호출할 엔드포인트와 메서드에 맞게 아래와 같은 형식으로 작성시면 됩니다!!

FeignClient 코드

@FeignClient(name="plant-service")
public interface PlantServiceClient {
    @GetMapping("{엔드포인트}")
    ResponseEntity<ResponseTradeBoardDto> boardContent(@PathVariable(value = "id") Long id);

    @GetMapping("{엔드포인트}")
    ResponseEntity<MemberDto> findById(@RequestParam Long id);

    @GetMapping("{엔드포인트}")
    ResponseEntity<MemberDto> findByUsername(@RequestParam String username);


    @GetMapping("{엔드포인트}")
    ResponseEntity<MemberDto> getJoinMember(@RequestHeader("Authorization") String jwtToken);
}

채팅 서비스 로직

@Slf4j
@Service
@RequiredArgsConstructor
public class ChatService {

    private final ChatRepository chatRepository;
    private final MongoChatRepository mongoChatRepository;
    private final MessageSender sender;
    private final AggregationSender aggregationSender;
    private final MongoTemplate mongoTemplate;
    private final ChatRoomService chatRoomService;
    private final PlantServiceClient plantServiceClient;
    private final CircuitBreakerFactory circuitBreakerFactory;
    private final TokenHandler tokenHandler;

    private final NotificationService notificationService;

    /**
     * 채팅방 생성 메서드
     * 거래 게시글을 올리지 않은 사람만 호출하는 메서드
     * 구매 희망자만 채팅방을 생성 가능
     * FeignCLient를 통해 plant-service에서 거래가능 여부 확인
     * @param : MemberDto memberDto, ChatRequestDto requestDto
     */
    @Transactional
    public Chat makeChatRoom(Integer memberNo, ChatRequestDto requestDto) {
        CircuitBreaker circuitBreaker = circuitBreakerFactory.create("circuitbreaker");
        // 채팅을 걸려고 하는 거래글이 거래 가능 상태인지 조회해본다.
        ResponseEntity<ResponseTradeBoardDto> tradeBoardDto = circuitBreaker.run(() ->
                        plantServiceClient.boardContent(requestDto.getTradeBoardNo().longValue()),
                throwable -> ResponseEntity.ok(null));

        // 조회해온 거래글 상태가 거래완료 이라면 거래가 불가능한 상태이다.
        if (tradeBoardDto.getBody().getStatus().equals("거래완료")) {
            throw new IllegalStateException("현재 거래가능 상태가 아닙니다.");
        }
        Integer tradeBoardNo = tradeBoardDto.getBody().getId().intValue();

        //이미 해당글 기준으로 채팅을 요청한 사람과 받는 사람이 일치할 경우 체크
        if (chatRepository.existChatRoomByBuyer(tradeBoardNo, requestDto.getCreateMember(), memberNo)) {
            Chat existedChat = chatRepository.findByTradeBoardNoAndChatNo(tradeBoardNo, requestDto.getCreateMember());
            return existedChat;

        }
        if (!chatRepository.existChatRoomByBuyer(tradeBoardNo, requestDto.getCreateMember(), memberNo)) {
            Chat chat = Chat.builder()
                    .tradeBoardNo(requestDto.getTradeBoardNo())
                    .createMember(requestDto.getCreateMember())
                    .joinMember(memberNo)
                    .regDate(LocalDateTime.now())
                    .build();

            Chat savedChat = chatRepository.save(chat);

            return savedChat;
        }
        throw new IllegalArgumentException("존재하지 않는 게시글 입니다");
    }
    /**
     * 채팅방 리스트 조회 메서드
     * FeignCLient를 통해 plant-service에서 유저 정보 조회후 채팅방 만든 사람인지 확인
     * mongodb에서 채팅 메세지 보낸 시간을 내림차순으로 정렬후 첫번째 값 마지막 메세지로 세팅
     * @param : Integer memberNo, Integer tradeBoardNo
     */
    public List<ChatRoomResponseDto> getChatList(Integer memberNo, Integer tradeBoardNo) {
        List<ChatRoomResponseDto> chatRoomList = chatRepository.getChattingList(memberNo, tradeBoardNo);
        //Participant 채워야됨(username)
            chatRoomList
                    .forEach(chatRoomDto -> {
                        //param으로 넘어온 멤버가 채팅 만든 멤버일 경우 => Participant에 참가한 멤버
//                        ResponseEntity<MemberDto> byId = plantServiceClient.findById(chatRoomDto.getCreateMember().longValue());
                        if (memberNo.equals(chatRoomDto.getCreateMember())) {
                            ResponseEntity<MemberDto> memberDtoResponse = plantServiceClient.findById(chatRoomDto.getJoinMember().longValue());

                            chatRoomDto.setParticipant(new ChatRoomResponseDto.Participant(memberDtoResponse.getBody().getUsername(), memberDtoResponse.getBody().getNickname()));
                        }
                        //param으로 넘어온 멤버가 채팅방에 참가한 멤버일 경우 => Participant에 채팅방 만든 멤버
                        if (!memberNo.equals(chatRoomDto.getCreateMember())){
                            ResponseEntity<MemberDto> memberDtoResponse = plantServiceClient.findById(chatRoomDto.getCreateMember().longValue());
                            chatRoomDto.setParticipant(new ChatRoomResponseDto.Participant(memberDtoResponse.getBody().getUsername(), memberDtoResponse.getBody().getNickname()));
                        }
//                      // 채팅방별로 읽지 않은 메시지 개수를 셋팅
                        long unReadCount = countUnReadMessage(chatRoomDto.getChatNo(), memberNo);
                        chatRoomDto.setUnReadCount(unReadCount);

                        // 채팅방별로 마지막 채팅내용과 시간을 셋팅
                        Page<Chatting> chatting =
                                mongoChatRepository.findByChatRoomNoOrderBySendDateDesc(chatRoomDto.getChatNo(), PageRequest.of(0, 1));
                        if (chatting.hasContent()) {
                            Chatting chat = chatting.getContent().get(0);
                            ChatRoomResponseDto.LatestMessage latestMessage = ChatRoomResponseDto.LatestMessage.builder()
                                    .context(chat.getContent())
                                    .sendAt(chat.getSendDate())
                                    .build();
                            chatRoomDto.setLatestMessage(latestMessage);
                        }
                    });

        return chatRoomList;
    }
    /**
     * 채팅 메세지 조회 메서드
     * 채팅 메세지 조회시 해당 메세지를 읽은 것이므로 메세지 읽음 처리도 진행
     * @param : Integer chatRoomNo, Integer memberNo
     */
    public ChattingHistoryResponseDto getChattingList(Integer chatRoomNo, Integer memberNo) {
        CircuitBreaker circuitBreaker = circuitBreakerFactory.create("circuitbreaker");
        // member id로 조화
        ResponseEntity<MemberDto> memberDto = circuitBreaker.run(() -> plantServiceClient.findById(memberNo.longValue()),
                throwable -> ResponseEntity.ok(null));

        updateCountAllZero(chatRoomNo, memberDto.getBody().getUsername());
        List<ChatResponseDto> chattingList = mongoChatRepository.findByChatRoomNo(chatRoomNo)
                .stream()
                .map(chat -> new ChatResponseDto(chat, memberNo)
                )
                .collect(Collectors.toList());

        return ChattingHistoryResponseDto.builder()
                .chatList(chattingList)
                .email(memberDto.getBody().getEmail())
                .build();
    }
    /**
     * 메세지 전송 메서드
     * jwt 토큰에서 username 추출
     * 카프카 토픽으로 메세 전송
     * @param : Message message, String accessToken
     */
    public void sendMessage(Message message, String accessToken) {
        // member id로 조화
        ResponseEntity<MemberDto> memberDto = plantServiceClient.findByUsername(tokenHandler.getUid(accessToken));

        // 채팅방에 모든 유저가 참여중인지 확인한다.
        boolean isConnectedAll = chatRoomService.isAllConnected(message.getChatNo());
        // 1:1 채팅이므로 2명 접속시 readCount 0, 한명 접속시 1
        Integer readCount = isConnectedAll ? 0 : 1;
        // message 객체에 보낸시간, 보낸사람 memberNo, 닉네임을 셋팅해준다.
        message.setSendTimeAndSender(LocalDateTime.now(), memberDto.getBody().getId().intValue(), memberDto.getBody().getNickname(), readCount);
	// 보낸 사람일 경우에만 메시지를 저장 -> 중복 저장 방지
if (message.getSenderEmail().equals(memberDto.getBody().getEmail())) {
    // Message 객체를 채팅 엔티티로 변환
    Chatting chatting = message.convertEntity();
    // 채팅 내용을 저장
    Chatting savedChat = mongoChatRepository.save(chatting);
    // 저장된 고유 ID를 반환
    message.setId(savedChat.getId());
}

        // 메시지를 전송한다.
        sender.send(KafkaUtil.KAFKA_TOPIC, message);
    }
    /
    /**
     * 참가자 입장 알림 메서드
     * @param : String email, Integer chatRoomNo
     */
    public void updateMessage(String email, Integer chatRoomNo) {
        Message message = Message.builder()
                .contentType("notice")
                .chatNo(chatRoomNo)
                .content(email + " 님이 돌아오셨습니다.")
                .build();

        sender.send(KafkaUtil.KAFKA_TOPIC, message);
    }


    /**
     * 판매자가 참가한  채팅방이 존재하는지 유무 처리 메서드
     * 단순 조회용 메서드라 readOnly = true
     *
     * @param : Integer tradeBoardNo,  Integer memberNo
     */
    @Transactional(readOnly = true)
    public Boolean existChatRoomBySeller(Integer tradeBoardNo, Integer memberNo) {
        return chatRepository.existChatRoomBySeller(tradeBoardNo, memberNo);
    }

 }

코드의 중요한 내용은 주석 달아놨습니다!

위에서 만든 마이크로 서비스간에 통신을 하기 위해 PlantServiceClient(FeignClient)에서 메서드를 호출했고, 외부 api간에 장애 관리를 하기 위해 CircuitBreaker를 사용했습니다.

• 메세지를 보낸 유저와 현재 접속한 유저가 동일하면 DB에 채팅 내역을 저장합니다.
• sender.send : Kafka 프로듀서는 KafkaUtil.KAFKA_TOPIC에 지정된 토픽으로 message 객체를 전송합니다.

7. 컨트롤러

---

@Slf4j
@RestController
@RequiredArgsConstructor
public class ChatController {
    private final ChatRoomService chatRoomService;
    private final ChatService chatService;

    @PostMapping("/chatroom")
    public ResponseEntity<StatusResponseDto> createChatRoom(@RequestBody @Valid final ChatRequestDto requestDto, @RequestParam(required = false) Integer memberNo,
                                                            BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResponseEntity.badRequest().body(StatusResponseDto.addStatus(400));
        }

        // 채팅방을 만들어준다.
        Chat chat = chatService.makeChatRoom(memberNo, requestDto);
        return ResponseEntity.ok(StatusResponseDto.addStatus(200, chat));
    }

    // 채팅내역 조회
    @GetMapping("/chatroom/{roomNo}")
    public ResponseEntity<ChattingHistoryResponseDto> chattingList(@PathVariable("roomNo") Integer roomNo, @RequestParam(required = false) Integer memberNo) {
        ChattingHistoryResponseDto chattingList = chatService.getChattingList(roomNo, memberNo);
        return ResponseEntity.ok().body(chattingList);
    }

    // 채팅방 리스트 조회
    @GetMapping("/chatroom")
    public ResponseEntity<List<ChatRoomResponseDto>> chatRoomList(@RequestParam(value = "tradeBoardNo", required = false) Integer tradeBoardNo,
                                                                  @RequestParam(value = "memberNo", required = false) Integer memberNo) {
        List<ChatRoomResponseDto> chatList = chatService.getChatList(memberNo, tradeBoardNo);
        return ResponseEntity.ok(chatList);
    }

    @MessageMapping("/message")
    public void sendMessage(@Valid Message message, @Header("Authorization") final String accessToken) {
        chatService.sendMessage(message, accessToken);
    }

    @MessageExceptionHandler
    @SendTo("/error")
    public String handleException(Exception e) {

        return "WebSocket 메시지 핸들러에서 예외가 발생했습니다: " + e;
    }

    // 채팅방 접속 끊기
    @PostMapping("/chatroom/{chatroomNo}")
    public ResponseEntity<HttpStatus> disconnectChat(@PathVariable("chatroomNo") Integer chatroomNo,
                                                     @RequestParam(value = "nickname", required = false) String nickname) {
        chatRoomService.disconnectChatRoom(chatroomNo, nickname);
        return ResponseEntity.ok(HttpStatus.ACCEPTED);
    }

    // 판매자가 참가한 채팅방 존재하는지 조회
    @GetMapping("/chatroom/exist/seller")
    public Boolean existChatRoomBySeller(@RequestParam Integer tradeBoardNo, @RequestParam Integer memberNo) {
        return chatService.existChatRoomBySeller(tradeBoardNo, memberNo);
    }
}

8. 마무리

---

이번 포스팅에서 채팅 기능 구현 과정을 포스팅 해봤습니다. 다음 포스팅에서는 SSE를 활용한 알림 기능에 관해 포스팅 하도록 하겠습니다!!

참고

---

https://velog.io/@joonghyun/Springboot-MongoDB-Springboot%EC%99%80-MongoDB-%EC%97%B0%EA%B2%B0%ED%95%98%EA%B8%B0
https://velog.io/@ch4570/Stomp-Kafka%EB%A5%BC-%EC%9D%B4%EC%9A%A9%ED%95%9C-%EC%B1%84%ED%8C%85-%EA%B8%B0%EB%8A%A5-%EA%B0%9C%EB%B0%9C%ED%95%98%EA%B8%B0-with-Spring-Boot-2-Kafka-%EC%84%A4%EC%B9%98-MongoDB-Stomp-%EC%84%A4%EC%A0%95