[임정현] sprint12 #308

HuInDoL · 2025-09-14T10:04:58Z

기본 요구사항

웹소켓 구현하기

웹소켓 환경 구성
- 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

배포 아키텍처 구성하기

다음의 다이어그램에 부합하는 배포 아키텍처를 Docker Compose를 통해 구현하세요.

gtwxscalk-image.png
- 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를 등록하여 이후 메시지 처리 흐름에서도 인증 정보를 활용할 수 있도록 구성하세요.


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

인가 처리

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

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


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


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

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

다음의 다이어그램에 부합하는 배포 아키텍처를 Docker Compose를 통해 구현하세요.

zkdz2mts7-image.png

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에 남겨주세요.

<aside> 💜

이게 어떤 오류인지는 아직 정확히 잘 모르겠지만, 분산환경으로 바꾼 후 인메모리에서 작동하는 JWT 액세스 토큰이 다른 애플리케이션에서 발견되지 않아 401 UnAuthorized 에러가 뜨는 것 같음

</aside>

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 &amp;&amp; currentSize &gt;= 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&lt;Object&gt; tokens = redisTemplate.opsForList().range(userKey, 0, -1);
if (tokens != null) {
  tokens.forEach(tokenObj -&gt; {
    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&lt;Object&gt; tokens = redisTemplate.opsForList().range(userKey, 0, -1);

  if (tokens != null) {
    for (int i = 0; i &lt; tokens.size(); i++) {
      if (tokens.get(i) instanceof JwtInformation jwtInfo &amp;&amp;
          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&lt;Object&gt; tokens = redisTemplate.opsForList().range(userKey, 0, -1);

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

    for (int i = tokens.size() - 1; i &gt;= 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, &quot;EXPIRED&quot;);
          redisTemplate.opsForList().remove(userKey, 1, &quot;EXPIRED&quot;);
          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에 남겨주세요.
- 일반적인 카프카 이벤트와 다르게 각 서버 인스턴스마다 이벤트를 받을 수 있어야 합니다. 따라서 컨슈머 group id를 적절히 설정하세요.
  
  <aside> 💜
  
  대체 왜 안되나 했는데 consumer의 group ip 설정을 안해줘서 그런 것 같음.
  
  </aside>

## 기본 요구사항

웹소켓 구현하기

웹소켓 환경 구성
- 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를 통해 구현하세요.

[gtwxscalk-image.png](https://bakey-api.codeit.kr/api/files/resource?root=static&seqId=14132&version=1&directory=/gtwxscalk-image.png&name=gtwxscalk-image.png)
- 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 네트워크를 통해 백엔드에서 통신할 수 있어야 합니다.
  - 외부 네트워크와 단절되어야 합니다.

심화 요구사항

[웹소켓 인증/인가 처리하기](https://www.notion.so/2-WebSocket-25d8d8ad920781f2a4a7f25baf3040e6?pvs=21)

인증 처리

디스코드잇 클라이언트는 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를 등록하여 이후 메시지 처리 흐름에서도 인증 정보를 활용할 수 있도록 구성하세요.

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

인가 처리

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

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

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

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

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

다음의 다이어그램에 부합하는 배포 아키텍처를 Docker Compose를 통해 구현하세요.

[zkdz2mts7-image.png](https://bakey-api.codeit.kr/api/files/resource?root=static&seqId=14134&version=1&directory=/zkdz2mts7-image.png&name=zkdz2mts7-image.png)
- 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에 남겨주세요.
💜
이게 어떤 오류인지는 아직 정확히 잘 모르겠지만, 분산환경으로 바꾼 후 인메모리에서 작동하는 JWT 액세스 토큰이 다른 애플리케이션에서 발견되지 않아 401 UnAuthorized 에러가 뜨는 것 같음

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에 남겨주세요.
- 일반적인 카프카 이벤트와 다르게 각 서버 인스턴스마다 이벤트를 받을 수 있어야 합니다. 따라서 컨슈머 group id를 적절히 설정하세요.
  💜
  대체 왜 안되나 했는데 consumer의 group ip 설정을 안해줘서 그런 것 같음.

- build.gradle

- WebSocketConfig.java - MessageWebSocketController.java

- SseController.java - SseEmitterRepository.java - SseMessageRepository.java - SseService.java

- eventIds -> eventIdQueue

- BasicNotificationService.create

이벤트명 변경 - notifications.created - binaryContents.updated - channels.* - users.*

- Client -> Reverse Proxy(NginX) -> Backend -> DB, Redis, Kafka

- JwtAuthenticationChannelInterceptor.java

- docker-compose.yml - default.conf

- docker-compose.yml - default.conf - RedisConfig.java - UserLogInOutEvent.java - RedisJwtRegistry.java - RedisLockProvider.java Least Conn 방식 Nginx 로드 밸런서 구현

ssjf409 · 2025-09-14T23:13:55Z

변경 사항이 너무 많이 잡혀서 리뷰하기가 힘들어요 ㅠㅠ
베이스 브랜치에 이미 10, 11때 머지된 변경한 커밋들이 들어가도록 부탁드려요. 아마 HuInDoL:임정현-sprint12 를 머지하면 될거에요.

HuInDoL · 2025-09-15T09:31:52Z

변경 사항이 너무 많이 잡혀서 리뷰하기가 힘들어요 ㅠㅠ 베이스 브랜치에 이미 10, 11때 머지된 변경한 커밋들이 들어가도록 부탁드려요. 아마 HuInDoL:임정현-sprint12 를 머지하면 될거에요.

반영했습니다!
많이 줄긴했지만 그래도 46개네요..
항상 감사드립니당..

ssjf409 · 2025-09-16T22:44:26Z

src/main/java/com/sprint/mission/discodeit/redis/RedisJwtRegistry.java

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


token 캐싱할때랑 불러 올때 list로 관리하니
불러올때 매번 전체 리스트로 가져오는게 너무 비효율적으로 보여요.

ssjf409 · 2025-09-16T22:50:33Z

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

+    @Query("SELECT DISTINCT m.author.id " +
+            "FROM Message m JOIN m.attachments a " +
+            "WHERE a.id =:attachmentId")
+    List<UUID> findAuthorIdsByAttachmentId(UUID attachmentId);
+
+    @Query("SELECT DISTINCT m.channel.id " +
+            "FROM Message m JOIN m.attachments a " +
+            "WHERE a.id = :attachmentId")
+    List<UUID> findChannelIdsByAttachmentId(UUID attachmentId);


이 쿼리들 보니까 결국 attachmentId 가지고 데이터 조회하는건데
굳이 전체 메시지랑 attachement랑 조인할 필요가 있는지 모르겠습니다.

attchement 먼저 조회하고 거기에 meesage랑 연결 시킬 정보있으면 그걸로 한번더 조회하시는게 어떠신가요.
그렇게 하면 쿼리는 두번이지만 조인은 안해도 되거든요.

ssjf409 · 2025-09-16T22:55:37Z

src/main/java/com/sprint/mission/discodeit/security/jwt/store/InMemoryJwtRegistry.java

+        for (var e : origin.entrySet()) {
+            for (var info : e.getValue()) {
+                if (refreshToken.equals(info.refreshToken())) { targetUserId = e.getKey(); old = info; break; }


모든 토큰 전체 탐색하면서 찾는건 너무 비효율적인것 같아요.
자료구조를 잘 써서 다시 디자인 해보시는게 어떠신가요.

ssjf409 · 2025-09-16T22:57:34Z

src/main/java/com/sprint/mission/discodeit/security/jwt/store/InMemoryJwtRegistry.java

+        Queue<JwtInformation> q = origin.get(targetUserId);
+        synchronized (q) {


조금 어려울 수 있는 내용이긴한데요.
origin이 ConcurrentHashMap 으로 만드셨는데, HashMap에서 동시성 문제가 발생할 수 있는걸 방지하기 위해서 ConcurrentHashMap을 만드신걸거에요. 그래서 synchronized를 쓸 필요 없이 ConcurrentHashMap의 기능을 잘 쓰시면 될거 같아요.

ssjf409 · 2025-09-16T23:04:51Z

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

+        for (UUID channelId : channelIds) {
+            readStatusRepository.findAllByChannelIdWithUserAndNotificationEnabledTrue(channelId)
+                    .forEach(rs -> receiverIds.add(rs.getUser().getId()));
+        }


지금 처럼 channelId: UUID 하나만 받아서 쿼리 하는 대신에
channelIds:List 를 받아서 조회할 하는 쿼리를 만들어서 사용해주세요. 지금은 N + 1 문제가 있어요.

ssjf409 · 2025-09-16T23:07:55Z

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

+    private void sseAfterCommit(Collection<UUID> receiverIds, String eventName, Object dto) {
+        if (TransactionSynchronizationManager.isActualTransactionActive()) {
+            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+                @Override public void afterCommit() { sseService.send(receiverIds, eventName, dto); }
+            });
+        } else {
+            sseService.send(receiverIds, eventName, dto);
+        }


아마 이건 스프린트에서 의도한건 SpringEvent로 쏘고 그걸 컨슈밍하는 타이밍을 트랜잭션 끝날때로 하라고 요구한거 일거 같은데, 다르게 하셨네요. 덕분에 저도 새로운것 알았습니다

HuInDoL added 13 commits September 4, 2025 16:04

chore: 버전명 변경 및 정적 리소스 변경

5524979

- build.gradle

feature: 웹소컷 구현하기

649cd1f

- WebSocketConfig.java - MessageWebSocketController.java

fix: 웹소켓 적용 안되는 오류, permitAll() 처리

015b8a6

feature: SSE 환경 구성

2cda60d

- SseController.java - SseEmitterRepository.java - SseMessageRepository.java - SseService.java

refactor: messages 저장소 이름 변경

a2c447c

- eventIds -> eventIdQueue

refactor: 알림 생성 로직 리팩토링

f695752

- BasicNotificationService.create

feature: 기존 폴링 방식 요청 데이터를 실시간 SSE 통신으로 리팩토링

01f3a88

이벤트명 변경 - notifications.created - binaryContents.updated - channels.* - users.*

feature: NginX 배포 아키텍쳐 구성

1788ef6

- Client -> Reverse Proxy(NginX) -> Backend -> DB, Redis, Kafka

feature: 웹소켓 인증/인가 처리

fa31062

- JwtAuthenticationChannelInterceptor.java

refactor: 분산환경 배포 아키텍처 구성1

f6cb5fd

- docker-compose.yml - default.conf

refactor: 분산환경 배포 아키텍처 구성2

96f67e1

- docker-compose.yml - default.conf

refactor: InMemoryJwtRegistry.rotateJwtInformation 리팩토링

952c40f

env: 분산환경 배포 아키텍처 구성3

fe22c16

- docker-compose.yml - default.conf - RedisConfig.java - UserLogInOutEvent.java - RedisJwtRegistry.java - RedisLockProvider.java Least Conn 방식 Nginx 로드 밸런서 구현

HuInDoL requested a review from ssjf409 September 14, 2025 10:05

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

HuInDoL self-assigned this Sep 14, 2025

ssjf409 reviewed Sep 16, 2025

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

[임정현] sprint12 #308

[임정현] sprint12 #308

Uh oh!

HuInDoL commented Sep 14, 2025

Uh oh!

ssjf409 commented Sep 14, 2025

Uh oh!

HuInDoL commented Sep 15, 2025 •

edited

Loading

Uh oh!

ssjf409 Sep 16, 2025

Uh oh!

ssjf409 Sep 16, 2025

Uh oh!

ssjf409 Sep 16, 2025

Uh oh!

ssjf409 Sep 16, 2025

Uh oh!

ssjf409 Sep 16, 2025

Uh oh!

ssjf409 Sep 16, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

id	이벤트 고유 ID
name	`notifications.created`
data	`NotificationDto`

id	이벤트 고유 ID
name	`binaryContents.updated`
data	`BinaryContentDto`

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

id	이벤트 고유 ID
name	`users.created` or `updated` or `deleted`
data	`UserDto`

		Queue<JwtInformation> q = origin.get(targetUserId);
		synchronized (q) {

id	이벤트 고유 ID
name	notifications.created
data	NotificationDto

[임정현] sprint12 #308

Are you sure you want to change the base?

[임정현] sprint12 #308

Uh oh!

Conversation

HuInDoL commented Sep 14, 2025

기본 요구사항

웹소켓 구현하기

SSE 구현하기

배포 아키텍처 구성하기

심화 요구사항

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

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

웹소켓 구현하기

SSE 구현하기

배포 아키텍처 구성하기

심화 요구사항

[웹소켓 인증/인가 처리하기](https://www.notion.so/2-WebSocket-25d8d8ad920781f2a4a7f25baf3040e6?pvs=21)

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

Uh oh!

ssjf409 commented Sep 14, 2025

Uh oh!

HuInDoL commented Sep 15, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

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!

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!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

HuInDoL commented Sep 15, 2025 •

edited

Loading