refactor: ETA 목록 조회 API web socket으로 수정

backend/build.gradle

@@ -46,6 +46,7 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-web'
 	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
 	implementation 'org.springframework.boot:spring-boot-starter-validation'
+	implementation 'org.springframework.boot:spring-boot-starter-websocket'
 	implementation "io.jsonwebtoken:jjwt:0.9.1"
 	implementation 'javax.xml.bind:jaxb-api:2.3.1'
 

backend/src/main/java/com/ody/eta/annotation/WebSocketAuthMember.java

@@ -0,0 +1,12 @@
+package com.ody.eta.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface WebSocketAuthMember {
+
+}

backend/src/main/java/com/ody/eta/argumentresolver/WebSocketArgumentResolver.java

@@ -0,0 +1,40 @@
+package com.ody.eta.argumentresolver;
+
+import com.ody.auth.service.AuthService;
+import com.ody.common.exception.OdyException;
+import com.ody.common.exception.OdyUnauthorizedException;
+import com.ody.eta.annotation.WebSocketAuthMember;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.core.MethodParameter;
+import org.springframework.http.HttpHeaders;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver;
+import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
+
+@Slf4j
+@RequiredArgsConstructor
+public class WebSocketArgumentResolver implements HandlerMethodArgumentResolver {
+
+    private final AuthService authService;
+
+    public boolean supportsParameter(MethodParameter parameter) {
+        return parameter.hasParameterAnnotation(WebSocketAuthMember.class);
+    }
+
+    @Override
+    public Object resolveArgument(
+            MethodParameter parameter,
+            Message<?> message
+    ) {
+        StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);
+        String accessToken = accessor.getFirstNativeHeader(HttpHeaders.AUTHORIZATION);
+
+        try {
+            return authService.parseAccessToken(accessToken);
+        } catch (OdyException exception) {
+            log.warn(exception.getMessage());
+            throw new OdyUnauthorizedException("액세스 토큰이 유효하지 않습니다.");
+        }
+    }
+}

backend/src/main/java/com/ody/eta/config/WebSocketConfig.java

@@ -0,0 +1,24 @@
+package com.ody.eta.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.simp.config.MessageBrokerRegistry;
+import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
+import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
+import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
+
+@Configuration
+@EnableWebSocketMessageBroker
+public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
+
+    @Override
+    public void registerStompEndpoints(StompEndpointRegistry registry) {
+        registry.addEndpoint("/connect")
+                .setAllowedOrigins("*");
+    }
+
+    @Override
+    public void configureMessageBroker(MessageBrokerRegistry registry) {
+        registry.enableSimpleBroker("/topic");
+        registry.setApplicationDestinationPrefixes("/publish");
+    }
+}

backend/src/main/java/com/ody/eta/controller/EtaSocketController.java

@@ -0,0 +1,39 @@
+package com.ody.eta.controller;
+
+import com.ody.eta.annotation.WebSocketAuthMember;
+import com.ody.eta.dto.request.MateEtaRequest;
+import com.ody.eta.service.EtaSocketService;
+import com.ody.meeting.dto.response.MateEtaResponsesV2;
+import com.ody.member.domain.Member;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.messaging.handler.annotation.DestinationVariable;
+import org.springframework.messaging.handler.annotation.MessageMapping;
+import org.springframework.messaging.handler.annotation.Payload;
+import org.springframework.messaging.handler.annotation.SendTo;
+import org.springframework.web.bind.annotation.RestController;
+
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+public class EtaSocketController {
+
+    private final EtaSocketService etaSocketService;
+
+    @MessageMapping("/open/{meetingId}")
+    public void open(@DestinationVariable Long meetingId) {
+        log.info("--- websocket open ! - {}", meetingId);
+        etaSocketService.open(meetingId);
+    }
+
+    @MessageMapping("/etas/{meetingId}")
+    @SendTo("/topic/etas/{meetingId}")
+    public MateEtaResponsesV2 etaUpdate(
+            @DestinationVariable Long meetingId,
+            @WebSocketAuthMember Member member,
+            @Payload MateEtaRequest etaRequest
+    ) {
+        log.info("--- etaUpdate 호출 ! - {}, {}, {}", meetingId, member, etaRequest);
+        return etaSocketService.etaUpdate(meetingId, member, etaRequest);
+    }
+}

backend/src/main/java/com/ody/eta/service/EtaSocketService.java

@@ -0,0 +1,74 @@
+package com.ody.eta.service;
+
+import com.ody.eta.dto.request.MateEtaRequest;
+import com.ody.mate.service.MateService;
+import com.ody.meeting.domain.Meeting;
+import com.ody.meeting.dto.response.MateEtaResponsesV2;
+import com.ody.meeting.service.MeetingService;
+import com.ody.member.domain.Member;
+import com.ody.util.TimeUtil;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.scheduling.TaskScheduler;
+import org.springframework.stereotype.Service;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class EtaSocketService {
+
+    private static final ZoneOffset KST_OFFSET = ZoneOffset.ofHours(9);
+    private static final Map<Long, LocalDateTime> LATEST_TRIGGER_TIME_CACHE = new ConcurrentHashMap<>();
+    private static final Map<Long, LocalDateTime> MEETING_TIME_CACHE = new ConcurrentHashMap<>();
+
+    private final MeetingService meetingService;
+    private final MateService mateService;
+    private final TaskScheduler taskScheduler;
+    private final SimpMessagingTemplate template;
+
+    public void open(Long meetingId) {
+        if (!MEETING_TIME_CACHE.containsKey(meetingId)) {
+            Meeting meeting = meetingService.findById(meetingId);
+            MEETING_TIME_CACHE.put(meetingId, meeting.getMeetingTime());
+        }
+        scheduleTrigger(meetingId, LocalDateTime.now().plusSeconds(1));
+    }
+
+    public MateEtaResponsesV2 etaUpdate(Long meetingId, Member member, MateEtaRequest etaRequest) {
+        if (isOverMeetingTime(meetingId)) {
+            log.info("--- websocket disconnect ! - {}", meetingId);
+            template.convertAndSend("/topic/disconnect/" + meetingId, "");
+        } else if (isTimeToSchedule(meetingId)) {
+            scheduleTrigger(meetingId, LocalDateTime.now().plusSeconds(10));
+        }
+        return mateService.findAllMateEtas(etaRequest, meetingId, member);
+    }
+
+    private boolean isOverMeetingTime(Long meetingId) {
+        LocalDateTime meetingTime = MEETING_TIME_CACHE.get(meetingId);
+        LocalDateTime lastTriggerTime = meetingTime.plusMinutes(1L);
+        return TimeUtil.nowWithTrim().isAfter(lastTriggerTime);
+    }
+
+    private boolean isTimeToSchedule(Long meetingId) {
+        LocalDateTime lastTriggerTime = LATEST_TRIGGER_TIME_CACHE.get(meetingId);
+        Duration duration = Duration.between(lastTriggerTime, LocalDateTime.now());
+        return duration.toSeconds() >= 10;
+    }
+
+    private void scheduleTrigger(Long meetingId, LocalDateTime triggerTime) {
+        Instant startTime = triggerTime.toInstant(KST_OFFSET);
+        taskScheduler.schedule(
+                () -> template.convertAndSend("topic/coordinates/" + meetingId, ""), startTime
+        );
+        LATEST_TRIGGER_TIME_CACHE.put(meetingId, LocalDateTime.now());
+        log.info("--- schedule 예약 완료 ! - {}, {}", meetingId, triggerTime);
+    }
+}

backend/src/test/java/com/ody/common/websocket/BaseStompTest.java

@@ -0,0 +1,87 @@
+package com.ody.common.websocket;
+
+import com.ody.common.DatabaseCleaner;
+import com.ody.common.TestAuthConfig;
+import com.ody.common.TestRouteConfig;
+import com.ody.common.config.JpaAuditingConfig;
+import com.ody.eta.config.WebSocketConfig;
+import com.ody.notification.config.FcmConfig;
+import com.ody.notification.service.FcmPushSender;
+import com.ody.notification.service.FcmSubscriber;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.context.annotation.Import;
+import org.springframework.messaging.converter.MappingJackson2MessageConverter;
+import org.springframework.messaging.simp.stomp.StompSession;
+import org.springframework.messaging.simp.stomp.StompSessionHandlerAdapter;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.annotation.DirtiesContext.ClassMode;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.springframework.web.socket.client.standard.StandardWebSocketClient;
+import org.springframework.web.socket.messaging.WebSocketStompClient;
+
+@Import({JpaAuditingConfig.class, TestRouteConfig.class, TestAuthConfig.class, WebSocketConfig.class})
+@ExtendWith(SpringExtension.class)
+@ActiveProfiles("test")
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@DirtiesContext(classMode = ClassMode.BEFORE_EACH_TEST_METHOD)
+public class BaseStompTest {
+
+    private static final String ENDPOINT = "/connect";
+
+    @MockBean
+    private FcmConfig fcmConfig;
+
+    @MockBean
+    protected FcmSubscriber fcmSubscriber;
+
+    @MockBean
+    protected FcmPushSender fcmPushSender;
+
+    @Autowired
+    private DatabaseCleaner databaseCleaner;
+
+    protected StompSession stompSession;
+
+    @LocalServerPort
+    private int port;
+
+    private final String url;
+
+    private final WebSocketStompClient websocketClient;
+
+    public BaseStompTest() {
+        this.websocketClient = new WebSocketStompClient(new StandardWebSocketClient());
+        this.websocketClient.setMessageConverter(new MappingJackson2MessageConverter());
+        this.url = "ws://localhost:";
+    }
+
+    @BeforeEach
+    public void connect() throws ExecutionException, InterruptedException, TimeoutException {
+        this.stompSession = this.websocketClient
+                .connect(url + port + ENDPOINT, new StompSessionHandlerAdapter() {
+                })
+                .get(3, TimeUnit.SECONDS);
+    }
+
+    @BeforeEach
+    void databaseCleanUp() {
+        databaseCleaner.cleanUp();
+    }
+
+    @AfterEach
+    public void disconnect() {
+        if (this.stompSession.isConnected()) {
+            this.stompSession.disconnect();
+        }
+    }
+}

backend/src/test/java/com/ody/common/websocket/MessageFrameHandler.java

@@ -0,0 +1,33 @@
+package com.ody.common.websocket;
+
+import java.lang.reflect.Type;
+import java.util.concurrent.CompletableFuture;
+import org.springframework.messaging.simp.stomp.StompFrameHandler;
+import org.springframework.messaging.simp.stomp.StompHeaders;
+
+public class MessageFrameHandler<T> implements StompFrameHandler {
+
+    private final CompletableFuture<T> completableFuture = new CompletableFuture<>();
+
+    private final Class<T> tClass;
+
+    public MessageFrameHandler(Class<T> tClass) {
+        this.tClass = tClass;
+    }
+
+    @Override
+    public Type getPayloadType(StompHeaders headers) {
+        return this.tClass;
+    }
+
+    @Override
+    public void handleFrame(StompHeaders headers, Object payload) {
+        if(completableFuture.complete((T)payload)){
+            System.out.println("끝남");
+        }
+    }
+
+    public CompletableFuture<T> getCompletableFuture() {
+        return completableFuture;
+    }
+}