[이지현] sprint12 #302

jhlee-codes · 2025-09-08T09:46:05Z

기본 요구사항

웹소켓 구현하기

웹소켓 환경 구성
- spring-boot-starter-websocket 의존성을 추가하세요.
```
implementation 'org.springframework.boot:spring-boot-starter-   websocket'
```
- 웹소켓 메시지 브로커 설정
```
@Configuration 
@EnableWebSocketMessageBroker 
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {...}
```
  - 메모리 기반 SimpleBroker를 사용하세요.
```
@Override 
public void configureMessageBroker(MessageBrokerRegistry config) {...}
```
    - SimpleBroker의 Destination Prefix는 /sub 으로 설정하세요.
      - 클라이언트에서 메시지를 구독할 때 사용합니다.
    - Application Destination Prefix는 /pub 으로 설정하세요.
      - 클라이언트에서 메시지를 발행할 때 사용합니다.
```
@Override 
public void registerStompEndpoints(StompEndpointRegistry registry) {...}
```
    - STOMP 엔드포인트는 /ws로 설정하고, SockJS 연결을 지원해야 합니다.
메시지 송신
- 첨부파일이 없는 단순 텍스트 메시지인 경우 STOMP를 통해 메시지를 전송할 수 있도록 컨트롤러를 구현하세요.
```
@Controller 
public class MessageWebSocketController {    
 ...     
@MessageMapping(...) 
}
```
  - 클라이언트는 웹소켓으로 /pub/messages 엔드포인트에 메시지를 전송할 수 있어야 합니다.
    - @MessageMapping을 활용하세요.
  - 메시지 전송 요청의 페이로드 타입은 MessageCreateRequest 를 그대로 활용합니다.
- 첨부파일이 포함된 메시지는 기존의 API (POST /api/messages)를 그대로 활용합니다.
메시지 수신
- 클라이언트는 채널 입장 시 웹소켓으로 /sub/channels.{channelId}.messages 를 구독해 메시지를 수신합니다.
- 이를 고려해 메시지가 생성되면 해당 엔드포인트로 메시지를 보내는 컴포넌트를 구현하세요.
```
@Component 
public class WebSocketRequiredEventListener {     
...     
private final SimpMessagingTemplate messagingTemplate;        @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)   public void handleMessage(MessageCreatedEvent event) {...} }
```
  - MessageCreatedEvent를 통해 새로운 메시지 생성 이벤트를 확인하세요.
  - SimpMessagingTemplate를 통해 적절한 엔드포인트로 메시지를 전송하세요.

SSE 구현하기

SSE 환경을 구성하세요.
- 클라이언트에서 SSE 연결을 위한 엔드포인트를 구현하세요.
  - GET /api/sse
- 사용자별 SseEmitter 객체를 생성하고 메시지를 전송하는 컴포넌트를 구현하세요.
```
@Service
public class SseService {

  public SseEmitter connect(UUID receiverId, UUID lastEventId) {...}

  public void send(Collection<UUID> receiverIds, String eventName, Object data) {...}

  public void broadcast(String eventName, Object data) {...}

  @Scheduled(fixedDelay = 1000 * 60 * 30)
  public void cleanUp() {...}

  private boolean ping(SseEmitter sseEmitter) {...}
}
```
  - connect: SseEmitter 객체를 생성합니다.
  - send, broadcast: SseEmitter 객체를 통해 이벤트를 전송합니다.
  - cleanUp: 주기적으로 ping을 보내서 만료된 SseEmitter 객체를 삭제합니다.
  - ping: 최초 연결 또는 만료 여부를 확인하기 위한 용도로 더미 이벤트를 보냅니다.
- SseEmitter 객체를 메모리에서 저장하는 컴포넌트를 구현하세요.
```
@Repository
public class SseEmitterRepository {
  private final ConcurrentMap<UUID, List<SseEmitter>> data = new ConcurrentHashMap<>();
    ...
}
```
  - ConcurrentMap: 스레드 세이프한 자료구조를 사용합니다.
  - List<SseEmitter>: 사용자 당 N개의 연결을 허용할 수 있도록 합니다. (예: 다중 탭)
- 이벤트 유실 복원을 위해 SSE 메시지를 저장하는 컴포넌트를 구현하세요.
```
@Repository
public class SseMessageRepository {

  private final ConcurrentLinkedDeque<UUID> eventIdQueue = new ConcurrentLinkedDeque<>();
  private final Map<UUID, SseMessage> messages = new ConcurrentHashMap<>();
    ...
}
```
  - 각 메시지 별로 고유한 ID를 부여합니다.
  - 클라이언트에서 LastEventId를 전송해 이벤트 유실 복원이 가능하도록 해야 합니다.
기존에 클라이언트에서 폴링 방식으로 주기적으로 요청하던 데이터를 SSE를 이용해 서버에서 실시간으로 전달하는 방식으로 리팩토링하세요.
- 새로운 알림 이벤트 전송
  - 새 알림이 생성되었을 때 클라이언트에 이벤트를 전송하세요.
  - 클라이언트는 이 이벤트를 수신하면 알림 목록에 알림을 추가합니다.
  - 이벤트 명세
    
    id 이벤트 고유 ID
    
    name notifications.created
    
    data NotificationDto
- 파일 업로드 상태 변경 이벤트 전송
  - 파일 업로드 상태가 변경될 때 이벤트를 발송하세요.
  - 클라이언트는 해당 상태를 수신하면 파일 상태 UI를 다시 렌더링합니다.
  - 이벤트 명세
    
    id 이벤트 고유 ID
    
    name binaryContents.updated
    
    data BinaryContentDto
- 채널 갱신 이벤트 전송
  - 채널 정보가 변경될 때, 이벤트를 발송하세요.
  - 클라이언트는 해당 이벤트를 수신하면 채널 UI를 다시 렌더링합니다.
  - 이벤트 명세
    
    id 이벤트 고유 ID
    
    name channels.created or updated or deleted
    
    data ChannelDto
- 사용자 갱신 이벤트 전송
  - 사용자 정보 또는 로그인 상태가 변경될 때, 이벤트를 발송하세요.
  - 클라이언트는 해당 이벤트를 수신하면 사용자 UI를 다시 렌더링합니다.
  - 이벤트 명세
    
    id 이벤트 고유 ID
    
    name users.created or updated or deleted
    
    data UserDto

배포 아키텍처 구성하기

다음의 다이어그램에 부합하는 배포 아키텍처를 Docker Compose를 통해 구현하세요.
- Reverse Proxy
  - Nginx 기반의 리버스 프록시 컨테이너를 구성하세요.
  - 역할 및 설정은 다음과 같습니다:
    - /api/*, /ws/* 요청은 Backend 컨테이너로 프록시 처리합니다.
    - 이 외의 모든 요청은 **정적 리소스(프론트엔드 빌드 결과)**를 서빙합니다.
      - 프론트엔드 정적 리소스는 Nginx 컨테이너 내부의 적절한 경로(/usr/share/nginx/html 등)에 복사하세요.
  - 외부에서 접근 가능한 유일한 컨테이너이며, 3000번 포트를 통해 접근할 수 있어야 합니다.
- Backend
  - Spring Boot 기반의 백엔드 서버를 Docker 컨테이너로 구성하세요.
  - Reverse Proxy를 통해 /api/*, /ws/* 요청이 이 서버로 전달됩니다.
- DB, Memory DB, Message Broker
  - Backend 컨테이너가 접근 가능한 다음의 인프라 컨테이너들을 구성하세요
    - DB: PostgreSQL
    - Memory DB: Redis
    - Message Broker: Kafka
  - 각 컨테이너는 Docker Compose 네트워크를 통해 백엔드에서 통신할 수 있어야 합니다.
  - 외부 네트워크와 단절되어야 합니다.

심화 요구사항

웹소켓 인증/인가 처리하기

인증 처리

디스코드잇 클라이언트는 CONNECT 프레임의 헤더에 다음과 같이 Authorization 토큰을 포함합니다.

CONNECT
Authorization:Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ3b29keSIsImV4cCI6MTc0OTM5MzA0OCwiaWF0IjoxNzQ5MzkyNDQ4LCJ1c2VyRHRvIjp7ImlkIjoiMDQwZTk2ZWMtMjdmNC00Y2MxLWI4MWQtNTMyM2ExZWQ5NTZhIiwidXNlcm5hbWUiOiJ3b29keSIsImVtYWlsIjoid29vZHlAZGlzY29kZWl0LmNvbSIsInByb2ZpbGUiOm51bGwsIm9ubGluZSI6bnVsbCwicm9sZSI6IlVTRVIifX0.JOkvCpnR0e0KMQYLh_hUWglgTvUIlfQOT58eD4Cym5o
accept-version:1.2,1.1,1.0
heart-beat:4000,4000

서버 측에서는 ChannelInterceptor를 구현하여 연결 시 토큰을 검증하고, 인증된 사용자 정보를 SecurityContext에 설정해야 합니다.

참고 문서: Spring 공식 문서

@Configuration
@EnableWebSocketMessageBroker
@RequiredArgsConstructor
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    ...
  @Override
  public void configureClientInboundChannel(ChannelRegistration registration) {
    registration.interceptors(...);
  }
}

CONNECT 프레임일 때 엑세스 토큰을 검증하는 JwtAuthenticationChannelInterceptor 구현체를 정의하세요.

public class JwtAuthenticationChannelInterceptor implements ChannelInterceptor {
    
    @Override
  public Message<?> preSend(Message<?> message, MessageChannel channel) {
        StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message,
        StompHeaderAccessor.class);
      if (StompCommand.CONNECT.equals(accessor.getCommand())) {
          ... // 검증 로직
          
          UsernamePasswordAuthenticationToken authentication = ...
          accessor.setUser(authentication);
      }
      return message;
  }
  
}

검증 로직은 이전에 구현한 JwtAuthenticationFilter를 참고하세요.
인증이 완료되면 SecurityContext에 인증정보를 저장하는 대신 accessor 객체에 저장하세요.

SecurityContextChannelInterceptor를 등록하여 이후 메시지 처리 흐름에서도 인증 정보를 활용할 수 있도록 구성하세요.

```java
@Override
public void configureClientInboundChannel(ChannelRegistration registration) {
  registration.interceptors(
      jwtAuthenticationChannelInterceptor,
    new SecurityContextChannelInterceptor(),
  );
}

인가 처리

AuthorizationChannelInterceptor를 사용해 메시지 권한 검사를 수행합니다.
AuthorizationChannelInterceptor를 활용하기 위해의존성을 추가하세요.
```
implementation 'org.springframework.security:spring-security-messaging'
```

MessageMatcherDelegatingAuthorizationManager를 활용해 인가 정책을 정의하고, 채널에 추가하세요.

```java
private AuthorizationChannelInterceptor authorizationChannelInterceptor() {
  return new AuthorizationChannelInterceptor(
      MessageMatcherDelegatingAuthorizationManager.builder()
          .anyMessage().hasRole(Role.USER.name())
          .build()
  );
}


  ```java
  @Override
  public void configureClientInboundChannel(ChannelRegistration registration) {
    registration.interceptors(
        jwtAuthenticationChannelInterceptor,
      new SecurityContextChannelInterceptor(),
        authorizationChannelInterceptor()
    );
  }

분산 환경 배포 아키텍처 구성하기

다음의 다이어그램에 부합하는 배포 아키텍처를 Docker Compose를 통해 구현하세요.
- Backend-*
  - deploy.replicas 설정을 활용하세요.
- Reverse Proxy
  - upstream 블록을 수정해 다음의 로드밸런싱 전략을 적용해 Backend로 트래픽을 분산시켜보세요.
    - Round Robin 기본값
    - Least Connections
    - IP Hash
    - Weight
  - $upstream_addr 변수를 활용해 실제 요청을 처리하는 서버의 IP를 헤더에 추가하고 브라우저 개발자 도구를 활용해 비교해보세요.
```
  ```
      location ^~ /api/sse {
              ...
        add_header X-Upstream-Server $upstream_addr;
      }
    
      location ^~ /api/ {
          ...
        add_header X-Upstream-Server $upstream_addr;
      }
    
      location ^~ /ws/ {
          ...
        add_header X-Upstream-Server $upstream_addr;
      }
```

분산환경에 따른 InMemoryJwtRegistry의 한계점을 식별하고 Redis를 활용해 리팩토링하세요.

어떤 한계가 있는지 식별하고 PR에 남겨주세요.
- InMemoryJwtRegistry는 JWT 토큰 정보를 각 컨테이너의 메모리에 저장하고 관리한다.
- 따라서 사용자가 backend-1에서 로그인해 토큰을 발급받어라도, 해당 정보는 backend-1 컨테이너에만 저장된다.
- 이후 사용자의 요청이 로드밸런서를 통해 다른 컨테이너(backend-2)로 전달되면, 그 컨테이너의 InMemoryJwtRegistry에는 해당 토큰 정보가 없으므로 토큰을 유효하지 않다고 판단한다.
- 즉, 분산 환경에서는 인스턴스 간 토큰 상태를 공유하지 못하므로 토큰 관리가 올바르게 동작하지 않는다.

RedisJwtRegistry 구현체를 활용하세요.

@Configuration
public class RedisConfig {

  @Bean
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory,
      @Qualifier("redisSerializer") GenericJackson2JsonRedisSerializer redisSerializer) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(connectionFactory);

    // Use String serializer for keys
    template.setKeySerializer(new StringRedisSerializer());
    template.setHashKeySerializer(new StringRedisSerializer());

    // Use JSON serializer for values
    template.setValueSerializer(redisSerializer);
    template.setHashValueSerializer(redisSerializer);

    template.afterPropertiesSet();
    return template;
  }

  @Bean("redisSerializer")
  public GenericJackson2JsonRedisSerializer redisSerializer(ObjectMapper objectMapper) {
    ObjectMapper redisObjectMapper = objectMapper.copy();
    redisObjectMapper.activateDefaultTyping(
        LaissezFaireSubTypeValidator.instance,
        DefaultTyping.EVERYTHING,
        As.PROPERTY
    );
    return new GenericJackson2JsonRedisSerializer(redisObjectMapper);
  }
}

package com.sprint.mission.discodeit.redis;

import java.time.Duration;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

@Slf4j
@RequiredArgsConstructor
@Component
public class RedisLockProvider {

  private static final Duration LOCK_TIMEOUT = Duration.ofSeconds(10);
  private static final String LOCK_KEY_PREFIX = "lock:";

  private final RedisTemplate<String, Object> redisTemplate;

  public void acquireLock(String key) {
    String lockKey = LOCK_KEY_PREFIX + key;
    String lockValue = Thread.currentThread().getName() + "-" + System.currentTimeMillis();
    ValueOperations<String, Object> valueOps = redisTemplate.opsForValue();

    // SETNX: 키가 없으면 설정하고 TTL 지정
    Boolean acquired = valueOps.setIfAbsent(lockKey, lockValue, LOCK_TIMEOUT);

    if (Boolean.TRUE.equals(acquired)) {
      log.debug("분산 락 획득 성공: {} (값: {})", lockKey, lockValue);
    } else {
      log.debug("분산 락 획득 실패: {}", lockKey);
      throw new RedisLockAcquisitionException("분산 락 획득 실패: " + lockKey);
    }
  }

  public void releaseLock(String key) {
    String lockKey = LOCK_KEY_PREFIX + key;
    try {
      redisTemplate.delete(lockKey);
      log.debug("분산 락 해제 완료: {}", lockKey);
    } catch (Exception e) {
      log.warn("분산 락 해제 실패: {}", lockKey, e);
    }
  }
  public static class RedisLockAcquisitionException extends RuntimeException {

    public RedisLockAcquisitionException(String message) {
      super(message);
    }
  }
}

원자적 연산을 위해 분산락을 사용합니다.

package com.sprint.mission.discodeit.security.jwt;

import com.sprint.mission.discodeit.dto.data.JwtInformation;
import com.sprint.mission.discodeit.event.message.UserLogInOutEvent;
import com.sprint.mission.discodeit.redis.RedisLockProvider.RedisLockAcquisitionException;
import com.sprint.mission.discodeit.redis.RedisLockProvider;
import java.time.Duration;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.scheduling.annotation.Scheduled;

@Slf4j
@RequiredArgsConstructor
public class RedisJwtRegistry implements JwtRegistry {

  private static final String USER_JWT_KEY_PREFIX = "jwt:user:";
  private static final String ACCESS_TOKEN_INDEX_KEY = "jwt:access_tokens";
  private static final String REFRESH_TOKEN_INDEX_KEY = "jwt:refresh_tokens";
  private static final Duration DEFAULT_TTL = Duration.ofMinutes(30);

  private final int maxActiveJwtCount;
  private final JwtTokenProvider jwtTokenProvider;
  private final ApplicationEventPublisher eventPublisher;
  private final RedisTemplate<String, Object> redisTemplate;
  private final RedisLockProvider redisLockProvider;

  @CacheEvict(value = "users", key = "'all'")
  @Retryable(retryFor = RedisLockAcquisitionException.class, maxAttempts = 10,
      backoff = @Backoff(delay = 100, multiplier = 2))
  @Override
  public void registerJwtInformation(JwtInformation jwtInformation) {
    String userKey = getUserKey(jwtInformation.getUserDto().id());
    String lockKey = jwtInformation.getUserDto().id().toString();

    redisLockProvider.acquireLock(lockKey);
    try {
      Long currentSize = redisTemplate.opsForList().size(userKey);

      while (currentSize != null && currentSize >= maxActiveJwtCount) {
        Object oldestTokenObj = redisTemplate.opsForList().leftPop(userKey);
        if (oldestTokenObj instanceof JwtInformation oldestToken) {
          removeTokenIndex(oldestToken.getAccessToken(), oldestToken.getRefreshToken());
        }
        currentSize = redisTemplate.opsForList().size(userKey);
      }

      redisTemplate.opsForList().rightPush(userKey, jwtInformation);
      redisTemplate.expire(userKey, DEFAULT_TTL);
      addTokenIndex(jwtInformation.getAccessToken(), jwtInformation.getRefreshToken());

    } finally {
      redisLockProvider.releaseLock(lockKey);
    }

    eventPublisher.publishEvent(
        new UserLogInOutEvent(jwtInformation.getUserDto().id(), true)
    );
  }

  @CacheEvict(value = "users", key = "'all'")
  @Override
  public void invalidateJwtInformationByUserId(UUID userId) {
    String userKey = getUserKey(userId);

    List<Object> tokens = redisTemplate.opsForList().range(userKey, 0, -1);
    if (tokens != null) {
      tokens.forEach(tokenObj -> {
        if (tokenObj instanceof JwtInformation jwtInfo) {
          removeTokenIndex(jwtInfo.getAccessToken(), jwtInfo.getRefreshToken());
        }
      });
    }

    redisTemplate.delete(userKey);
    eventPublisher.publishEvent(new UserLogInOutEvent(userId, false));
  }

  @Override
  public boolean hasActiveJwtInformationByUserId(UUID userId) {
    String userKey = getUserKey(userId);
    Long size = redisTemplate.opsForList().size(userKey);
    return size != null && size > 0;
  }

  @Override
  public boolean hasActiveJwtInformationByAccessToken(String accessToken) {
    return Boolean.TRUE.equals(
        redisTemplate.opsForSet().isMember(ACCESS_TOKEN_INDEX_KEY, accessToken)
    );
  }

  @Override
  public boolean hasActiveJwtInformationByRefreshToken(String refreshToken) {
    return Boolean.TRUE.equals(
        redisTemplate.opsForSet().isMember(REFRESH_TOKEN_INDEX_KEY, refreshToken)
    );
  }

  @Retryable(retryFor = RedisLockAcquisitionException.class, maxAttempts = 10,
      backoff = @Backoff(delay = 100, multiplier = 2))
  @Override
  public void rotateJwtInformation(String refreshToken, JwtInformation newJwtInformation) {
    String userKey = getUserKey(newJwtInformation.getUserDto().id());
    String lockKey = newJwtInformation.getUserDto().id().toString();

    redisLockProvider.acquireLock(lockKey);
    try {
      List<Object> tokens = redisTemplate.opsForList().range(userKey, 0, -1);

      if (tokens != null) {
        for (int i = 0; i < tokens.size(); i++) {
          if (tokens.get(i) instanceof JwtInformation jwtInfo &&
              jwtInfo.getRefreshToken().equals(refreshToken)) {

            removeTokenIndex(jwtInfo.getAccessToken(), jwtInfo.getRefreshToken());
            jwtInfo.rotate(newJwtInformation.getAccessToken(),
                newJwtInformation.getRefreshToken());
            redisTemplate.opsForList().set(userKey, i, jwtInfo);
            addTokenIndex(newJwtInformation.getAccessToken(),
                newJwtInformation.getRefreshToken());
            redisTemplate.expire(userKey, DEFAULT_TTL);
            break;
          }
        }
      }

    } finally {
      redisLockProvider.releaseLock(lockKey);
    }
  }

  @Scheduled(fixedDelay = 1000 * 60 * 5)
  @Override
  public void clearExpiredJwtInformation() {
    Set<String> userKeys = redisTemplate.keys(USER_JWT_KEY_PREFIX + "*");

    for (String userKey : userKeys) {
      List<Object> tokens = redisTemplate.opsForList().range(userKey, 0, -1);

      if (tokens != null) {
        boolean hasValidTokens = false;

        for (int i = tokens.size() - 1; i >= 0; i--) {
          if (tokens.get(i) instanceof JwtInformation jwtInfo) {
            boolean isExpired =
                !jwtTokenProvider.validateAccessToken(jwtInfo.getAccessToken()) ||
                    !jwtTokenProvider.validateRefreshToken(jwtInfo.getRefreshToken());

            if (isExpired) {
              redisTemplate.opsForList().set(userKey, i, "EXPIRED");
              redisTemplate.opsForList().remove(userKey, 1, "EXPIRED");
              removeTokenIndex(jwtInfo.getAccessToken(), jwtInfo.getRefreshToken());
            } else {
              hasValidTokens = true;
            }
          }
        }

        if (!hasValidTokens) {
          redisTemplate.delete(userKey);
        }
      }
    }
  }
  
  private String getUserKey(UUID userId) {
    return USER_JWT_KEY_PREFIX + userId.toString();
  }

  private void addTokenIndex(String accessToken, String refreshToken) {
    // Set에 토큰 추가 (add: 중복되면 무시됨)
    redisTemplate.opsForSet().add(ACCESS_TOKEN_INDEX_KEY, accessToken);
    redisTemplate.opsForSet().add(REFRESH_TOKEN_INDEX_KEY, refreshToken);

    // 인덱스 키에도 만료 시간 설정 (메모리 누수 방지)
    redisTemplate.expire(ACCESS_TOKEN_INDEX_KEY, DEFAULT_TTL);
    redisTemplate.expire(REFRESH_TOKEN_INDEX_KEY, DEFAULT_TTL);
  }

  private void removeTokenIndex(String accessToken, String refreshToken) {
    // Set에서 토큰 제거
    redisTemplate.opsForSet().remove(ACCESS_TOKEN_INDEX_KEY, accessToken);
    redisTemplate.opsForSet().remove(REFRESH_TOKEN_INDEX_KEY, refreshToken);
  }
}

분산환경에 따른 웹소켓과 SSE의 한계점을 식별하고 Kafka를 활용해 리팩토링하세요.
- 어떤 한계가 있는지 식별하고 PR에 남겨주세요.
  - WebSocket과 SSE는 기본 구현이 노드 로컬 메모리 상태에 의존하기 때문에 분산 환경에서는 세션/구독/이벤트가 공유되지 않는다.
  - 이로 인해 컨테이너 A에서 발생한 이벤트는 컨테이너 B에 연결된 클라이언트로 직접 전달되지 않아, 실시간 동기화가 깨진다.
  - Kafka 같은 중앙 메시지 브로커를 사용해야 컨테이너 간 이벤트를 전파하고, 모든 노드가 동일한 세션·구독 정보를 기준으로 이벤트를 전달해야 한다.
- 일반적인 카프카 이벤트와 다르게 각 서버 인스턴스마다 이벤트를 받을 수 있어야 합니다. 따라서 컨슈머 group id를 적절히 설정하세요.

주요 변경사항

1. 프로젝트 버전이 변경되었습니다. `v3.0-M12`

세부 사항
```
# build.gradle 
  ... 
  version = '2.3-M11' 
  version = '3.0-M12' 
...
```
- 3.0: api-doc 버전을 따릅니다.
- M12: 미션 12을 의미합니다.

2. 프론트엔드가 변경되었습니다.

v3.0.0
- 폴링이 삭제되고, 웹소켓, SSE 기능이 추가되었습니다.

스크린샷

멘토에게

셀프 코드 리뷰를 통해 질문 이어가겠습니다.

ssjf409 · 2025-09-14T23:03:18Z

지현님 죄송한데, 이전에 리뷰했던 내용도 다 변경사항에 들어와서..
코드량이 너무 많아서 이번에 하는 변경 사항이 눈에 안 들어옵니다.

이전에 했던건 안 보이게 해주실 수 있을까요

ssjf409 · 2025-09-14T23:04:02Z

아, 제가 10, 11 꺼 머지 하면 될까요 ?

ssjf409 · 2025-09-14T23:06:50Z

머지를 해도 마찬가지네요. base 브랜치 (codeit-bootcamp-spring:이지현)에 10, 11 때 리뷰 했던 커밋들이 들어있게해주세요.

jhlee-codes · 2025-09-15T03:44:41Z

지현님 죄송한데, 이전에 리뷰했던 내용도 다 변경사항에 들어와서.. 코드량이 너무 많아서 이번에 하는 변경 사항이 눈에 안 들어옵니다.

이전에 했던건 안 보이게 해주실 수 있을까요

넵! 스프린트 미션 11 이후 커밋들만 남겨두었습니다!

ssjf409 · 2025-09-16T12:22:04Z

src/main/java/com/sprint/mission/discodeit/repository/SseEmitterRepository.java

+    /**
+     * SseEmitter 제거
+     */
+    public void remove(UUID receiverId, SseEmitter sseEmitter) {


이것도 add처럼 원자성 있게 처리해야할것 같아요.

public void remove(UUID receiverId, SseEmitter sseEmitter) { data.computeIfPresent(receiverId, (key, emitters) -> { emitters.remove(sseEmitter); return emitters.isEmpty() ? null : emitters; }); }

ssjf409 · 2025-09-16T12:27:36Z

src/main/java/com/sprint/mission/discodeit/service/basic/BasicNotificationService.java

+        List<Notification> notifications = notificationRepository.findAllByReceiverId(receiverId,
+            Sort.by(Sort.Direction.DESC, "createdAt"));


findAll 처럼 전체 조회하는거면.. DB에서 정렬하는 것 보다, application에서 정렬하는게 DB 리소스를 덜 쓰는 일일거 같아요.

ssjf409 · 2025-09-16T12:41:03Z

src/main/java/com/sprint/mission/discodeit/auth/jwt/store/RedisJwtRegistry.java

+            }
+
+            redisTemplate.opsForList().rightPush(userKey, jwtInformation);
+            redisTemplate.expire(userKey, DEFAULT_TTL);


이렇게 하면 userKey 하나하나에 TTL을 건게 아니라,
List에 TTL을 건거인데, 의도하신거가요?

해당 코드는 코드잇에서 제공하는 코드였습니다..!! (심화 요구사항 - 분산 환경 배포 아키텍처 구성하기)

ssjf409 · 2025-09-16T12:55:02Z

캐시에서 전체를 다 읽는 코드 부분이 많아요.
전에도 코멘트 남겼지만, 그렇게 하면 매번 전체 데이터를 읽어보고 날리고 반복하는건 너무 비효율적인거 같아요.

jhlee-codes · 2025-09-18T00:20:53Z

남겨주신 리뷰들 참고해 앞으로 수정해보겠습니다!
그동안 꼼꼼하게 리뷰 남겨주셔서 정말 감사드립니다!! 많은 도움이 되었습니다! 🙇‍♂️👍

jhlee-codes requested a review from ssjf409 September 8, 2025 09:46

jhlee-codes added the 매운맛🔥 뒤는 없습니다. 그냥 필터 없이 말해주세요. 책임은 제가 집니다. label Sep 8, 2025

jhlee-codes added 21 commits September 15, 2025 12:43

refactor: 알림 엔티티 구조 변경 및 서비스 리팩토링

24f6988

refactor: 캐시 적용 관련 리팩토링

a168e86

refactor: Caffeine 캐시 매니저 등록 빈 삭제

2157958

refactor: Caffeine 캐시 매니저 등록 빈 삭제

7d65d51

refactor: KafkaTemplate send로직 완료 여부 콜백으로 확인 추가

7f38128

chore: 스프린트 미션 12 주요 변경 사항 적용

95e6de7

feat: 웹소켓 환경 구성

a353c66

feat: 메시지 송수신 기능 구현

1142a3b

feat: SSE 환경 구성 및 구현

7b0ddd3

fix: User 온라인 여부 표시 안되는 현상 해결 (캐시 모든 항목 삭제)

de2a4a6

feat: Docker Compose를 통한 배포 아키텍처 구현

178c694

feat: 웹소켓 인증 처리 구현 (ChannelInterceptor 구현)

882cf61

feat: 웹소켓 인가 처리 구현 및 웹소켓 인증 경로에 역할 계층 매핑 적용

1b5d9f2

feat: LB 환경 구축 + RedisJwtRegistry 구현 + Admin 초기화 분산락 적용

bb9363b

feat: Kafka 기반 SSE/WebSocket 이벤트 전파 및 인증 구현

ae0e2e9

feat: UserEvent 관련 SSE 전송시 eventName 오타 수정 ('user.*' -> 'users.*')

7b31739

refactor: 분산 환경을 위한 이벤트 처리 로직 개선

7a2f042

fix: ReadStatus 업데이트시 notificationEnabled값 반영 안되던 문제 해결

2a00490

chore: nginx 설정 파일 수정

038c679

refactor: 이벤트 패키지 구조 수정

c1b8e67

fix: 개인 채팅방 생성시 receiverIds 지정하도록 수정

7901fd5

jhlee-codes force-pushed the 이지현-sprint12 branch from 5c11c55 to 7901fd5 Compare September 15, 2025 03:43

ssjf409 reviewed Sep 16, 2025

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

[이지현] sprint12 #302

[이지현] sprint12 #302

Uh oh!

jhlee-codes commented Sep 8, 2025 •

edited

Loading

Uh oh!

ssjf409 commented Sep 14, 2025

Uh oh!

ssjf409 commented Sep 14, 2025

Uh oh!

ssjf409 commented Sep 14, 2025

Uh oh!

jhlee-codes commented Sep 15, 2025

Uh oh!

ssjf409 Sep 16, 2025

Uh oh!

ssjf409 Sep 16, 2025

Uh oh!

ssjf409 Sep 16, 2025

Uh oh!

jhlee-codes Sep 18, 2025

Uh oh!

ssjf409 commented Sep 16, 2025

Uh oh!

jhlee-codes commented Sep 18, 2025 •

edited

Loading

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

id	이벤트 고유 ID
name	`channels.created` or `updated` or `deleted`
data	`ChannelDto`

		List<Notification> notifications = notificationRepository.findAllByReceiverId(receiverId,
		Sort.by(Sort.Direction.DESC, "createdAt"));

[이지현] sprint12 #302

Are you sure you want to change the base?

[이지현] sprint12 #302

Uh oh!

Conversation

jhlee-codes commented Sep 8, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

기본 요구사항

웹소켓 구현하기

SSE 구현하기

배포 아키텍처 구성하기

심화 요구사항

웹소켓 인증/인가 처리하기

분산 환경 배포 아키텍처 구성하기

주요 변경사항

1. 프로젝트 버전이 변경되었습니다. v3.0-M12

2. 프론트엔드가 변경되었습니다.

스크린샷

멘토에게

Uh oh!

ssjf409 commented Sep 14, 2025

Uh oh!

ssjf409 commented Sep 14, 2025

Uh oh!

ssjf409 commented Sep 14, 2025

Uh oh!

jhlee-codes commented Sep 15, 2025

Uh oh!

ssjf409 Sep 16, 2025

Choose a reason for hiding this comment

Uh oh!

ssjf409 Sep 16, 2025

Choose a reason for hiding this comment

Uh oh!

ssjf409 Sep 16, 2025

Choose a reason for hiding this comment

Uh oh!

jhlee-codes Sep 18, 2025

Choose a reason for hiding this comment

Uh oh!

ssjf409 commented Sep 16, 2025

Uh oh!

jhlee-codes commented Sep 18, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

jhlee-codes commented Sep 8, 2025 •

edited

Loading

1. 프로젝트 버전이 변경되었습니다. `v3.0-M12`

jhlee-codes commented Sep 18, 2025 •

edited

Loading