chore: Java 스타일 수정

Author: github-actions

backend/src/main/java/io/f1/backend/domain/game/app/ChatService.java

@@ -8,8 +8,8 @@
 import io.f1.backend.domain.game.model.Room;
 import io.f1.backend.domain.game.websocket.MessageSender;
 import io.f1.backend.domain.question.entity.Question;
-
 import io.f1.backend.domain.user.dto.UserPrincipal;
+
 import lombok.RequiredArgsConstructor;
 
 import org.springframework.context.ApplicationEventPublisher;
@@ -25,7 +25,7 @@ public class ChatService {
     private final ApplicationEventPublisher eventPublisher;
 
     // todo 동시성적용
-    public void chat(Long roomId, UserPrincipal userPrincipal,ChatMessage chatMessage) {
+    public void chat(Long roomId, UserPrincipal userPrincipal, ChatMessage chatMessage) {
 
         Room room = roomService.findRoom(roomId);
 
@@ -43,7 +43,8 @@ public void chat(Long roomId, UserPrincipal userPrincipal,ChatMessage chatMessag
 
         if (answer.equals(chatMessage.message())) {
             eventPublisher.publishEvent(
-                    new GameCorrectAnswerEvent(room, userPrincipal.getUserId(), chatMessage, answer));
+                    new GameCorrectAnswerEvent(
+                            room, userPrincipal.getUserId(), chatMessage, answer));
         }
     }
 }

backend/src/main/java/io/f1/backend/domain/game/app/RoomService.java

@@ -45,15 +45,18 @@
 import io.f1.backend.global.exception.CustomException;
 import io.f1.backend.global.exception.errorcode.RoomErrorCode;
 import io.f1.backend.global.exception.errorcode.UserErrorCode;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.stereotype.Service;
+
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicLong;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.stereotype.Service;
 
 @Slf4j
 @Service
@@ -98,7 +101,6 @@ public RoomCreateResponse saveRoom(RoomCreateRequest request) {
         eventPublisher.publishEvent(new RoomCreatedEvent(room, quiz));
 
         return new RoomCreateResponse(newId);
-
     }
 
     public void enterRoom(RoomValidationRequest request) {
@@ -131,7 +133,7 @@ public void enterRoom(RoomValidationRequest request) {
             }
 
             if (room.getRoomSetting().locked()
-                && !room.getRoomSetting().password().equals(request.password())) {
+                    && !room.getRoomSetting().password().equals(request.password())) {
                 throw new CustomException(RoomErrorCode.WRONG_PASSWORD);
             }
 
@@ -143,14 +145,14 @@ private void exitIfInAnotherRoom(Room room, Long userId) {
 
         Long joinedRoomId = userRoomRepository.getRoomId(userId);
 
-        if (joinedRoomId!=null && !room.getId().equals(joinedRoomId)) {
+        if (joinedRoomId != null && !room.getId().equals(joinedRoomId)) {
 
-             if(room.isPlaying()){
-                 changeConnectedStatus(userId, ConnectionState.DISCONNECTED);
-             }else{
-                 exitRoom(joinedRoomId,getCurrentUserPrincipal());
-             }
-         }
+            if (room.isPlaying()) {
+                changeConnectedStatus(userId, ConnectionState.DISCONNECTED);
+            } else {
+                exitRoom(joinedRoomId, getCurrentUserPrincipal());
+            }
+        }
     }
 
     public void initializeRoomSocket(Long roomId, UserPrincipal principal) {
@@ -163,10 +165,10 @@ public void initializeRoomSocket(Long roomId, UserPrincipal principal) {
         }
 
         /* 재연결 */
-        if(room.getPlayerState(userId).equals(ConnectionState.DISCONNECTED)) {
-            changeConnectedStatus(userId,ConnectionState.CONNECTED);
+        if (room.getPlayerState(userId).equals(ConnectionState.DISCONNECTED)) {
+            changeConnectedStatus(userId, ConnectionState.CONNECTED);
             cancelTask(userId);
-            reconnectSendResponse(roomId,principal);
+            reconnectSendResponse(roomId, principal);
             return;
         }
 
@@ -178,19 +180,19 @@ public void initializeRoomSocket(Long roomId, UserPrincipal principal) {
         Quiz quiz = quizService.getQuizWithQuestionsById(quizId);
 
         GameSettingResponse gameSettingResponse =
-            toGameSettingResponse(room.getGameSetting(), quiz);
+                toGameSettingResponse(room.getGameSetting(), quiz);
 
         PlayerListResponse playerListResponse = toPlayerListResponse(room);
 
         SystemNoticeResponse systemNoticeResponse =
-            ofPlayerEvent(player.getNickname(), RoomEventType.ENTER);
+                ofPlayerEvent(player.getNickname(), RoomEventType.ENTER);
 
         String destination = getDestination(roomId);
 
         userRoomRepository.addUser(player, room);
 
         messageSender.sendPersonal(
-            getUserDestination(), MessageType.GAME_SETTING, gameSettingResponse, principal);
+                getUserDestination(), MessageType.GAME_SETTING, gameSettingResponse, principal);
 
         messageSender.sendBroadcast(destination, MessageType.ROOM_SETTING, roomSettingResponse);
         messageSender.sendBroadcast(destination, MessageType.PLAYER_LIST, playerListResponse);
@@ -215,66 +217,65 @@ public void exitRoom(Long roomId, UserPrincipal principal) {
             cleanRoom(room, removePlayer);
 
             messageSender.sendPersonal(
-                getUserDestination(),
-                MessageType.EXIT_SUCCESS,
-                new ExitSuccessResponse(true),
-                principal);
+                    getUserDestination(),
+                    MessageType.EXIT_SUCCESS,
+                    new ExitSuccessResponse(true),
+                    principal);
 
             SystemNoticeResponse systemNoticeResponse =
-                ofPlayerEvent(removePlayer.nickname, RoomEventType.EXIT);
+                    ofPlayerEvent(removePlayer.nickname, RoomEventType.EXIT);
 
             PlayerListResponse playerListResponse = toPlayerListResponse(room);
 
             messageSender.sendBroadcast(destination, MessageType.PLAYER_LIST, playerListResponse);
             messageSender.sendBroadcast(
-                destination, MessageType.SYSTEM_NOTICE, systemNoticeResponse);
+                    destination, MessageType.SYSTEM_NOTICE, systemNoticeResponse);
         }
     }
 
     public RoomListResponse getAllRooms() {
         List<Room> rooms = roomRepository.findAll();
         List<RoomResponse> roomResponses =
-            rooms.stream()
-                .map(
-                    room -> {
-                        Long quizId = room.getGameSetting().getQuizId();
-                        Quiz quiz = quizService.getQuizWithQuestionsById(quizId);
-
-                        return toRoomResponse(room, quiz);
-                    })
-                .toList();
+                rooms.stream()
+                        .map(
+                                room -> {
+                                    Long quizId = room.getGameSetting().getQuizId();
+                                    Quiz quiz = quizService.getQuizWithQuestionsById(quizId);
+
+                                    return toRoomResponse(room, quiz);
+                                })
+                        .toList();
         return new RoomListResponse(roomResponses);
     }
 
-    public void reconnectSendResponse(
-        Long roomId, UserPrincipal principal) {
+    public void reconnectSendResponse(Long roomId, UserPrincipal principal) {
         Room room = findRoom(roomId);
 
         String destination = getDestination(roomId);
         String userDestination = getUserDestination();
 
         messageSender.sendBroadcast(
-            destination,
-            MessageType.SYSTEM_NOTICE,
-            ofPlayerEvent(principal.getUserNickname(), RoomEventType.RECONNECT));
+                destination,
+                MessageType.SYSTEM_NOTICE,
+                ofPlayerEvent(principal.getUserNickname(), RoomEventType.RECONNECT));
 
         if (room.isPlaying()) {
             messageSender.sendPersonal(
-                userDestination,
-                MessageType.SYSTEM_NOTICE,
-                ofPlayerEvent(
-                    principal.getUserNickname(), RoomEventType.RECONNECT_PRIVATE_NOTICE),
-                principal);
+                    userDestination,
+                    MessageType.SYSTEM_NOTICE,
+                    ofPlayerEvent(
+                            principal.getUserNickname(), RoomEventType.RECONNECT_PRIVATE_NOTICE),
+                    principal);
             messageSender.sendPersonal(
-                userDestination,
-                MessageType.RANK_UPDATE,
-                toRankUpdateResponse(room),
-                principal);
+                    userDestination,
+                    MessageType.RANK_UPDATE,
+                    toRankUpdateResponse(room),
+                    principal);
             messageSender.sendPersonal(
-                userDestination,
-                MessageType.GAME_START,
-                toGameStartResponse(room.getQuestions()),
-                principal);
+                    userDestination,
+                    MessageType.GAME_START,
+                    toGameStartResponse(room.getQuestions()),
+                    principal);
         } else {
             RoomSettingResponse roomSettingResponse = toRoomSettingResponse(room);
 
@@ -283,16 +284,16 @@ public void reconnectSendResponse(
             Quiz quiz = quizService.getQuizWithQuestionsById(quizId);
 
             GameSettingResponse gameSettingResponse =
-                toGameSettingResponse(room.getGameSetting(), quiz);
+                    toGameSettingResponse(room.getGameSetting(), quiz);
 
             PlayerListResponse playerListResponse = toPlayerListResponse(room);
 
             messageSender.sendPersonal(
-                userDestination, MessageType.ROOM_SETTING, roomSettingResponse, principal);
+                    userDestination, MessageType.ROOM_SETTING, roomSettingResponse, principal);
             messageSender.sendPersonal(
-                userDestination, MessageType.PLAYER_LIST, playerListResponse, principal);
+                    userDestination, MessageType.PLAYER_LIST, playerListResponse, principal);
             messageSender.sendPersonal(
-                userDestination, MessageType.GAME_SETTING, gameSettingResponse, principal);
+                    userDestination, MessageType.GAME_SETTING, gameSettingResponse, principal);
         }
     }
 
@@ -305,15 +306,15 @@ public Long changeConnectedStatus(Long userId, ConnectionState newState) {
         return roomId;
     }
 
-    public void cancelTask(Long userId){
+    public void cancelTask(Long userId) {
         disconnectTasks.cancelDisconnectTask(userId);
     }
 
     public void exitIfNotPlaying(Long roomId, UserPrincipal principal) {
         Room room = findRoom(roomId);
         if (room.isPlaying()) {
             removeUserRepository(principal.getUserId(), roomId);
-        }else{
+        } else {
             exitRoom(roomId, principal);
         }
     }
@@ -328,8 +329,8 @@ private Player createPlayer() {
 
     public Room findRoom(Long roomId) {
         return roomRepository
-            .findRoom(roomId)
-            .orElseThrow(() -> new CustomException(RoomErrorCode.ROOM_NOT_FOUND));
+                .findRoom(roomId)
+                .orElseThrow(() -> new CustomException(RoomErrorCode.ROOM_NOT_FOUND));
     }
 
     private void removeRoom(Room room) {
@@ -342,14 +343,15 @@ private void removeRoom(Room room) {
     private void changeHost(Room room, Player host) {
         Map<Long, Player> playerMap = room.getPlayerMap();
 
-        Optional<Player> nextHost = playerMap.entrySet().stream()
-            .filter(entry -> !entry.getKey().equals(host.getId()))
-            .filter(entry -> entry.getValue().getState() == ConnectionState.CONNECTED)
-            .map(Map.Entry::getValue)
-            .findFirst();
+        Optional<Player> nextHost =
+                playerMap.entrySet().stream()
+                        .filter(entry -> !entry.getKey().equals(host.getId()))
+                        .filter(entry -> entry.getValue().getState() == ConnectionState.CONNECTED)
+                        .map(Map.Entry::getValue)
+                        .findFirst();
 
         room.updateHost(
-            nextHost.orElseThrow(() -> new CustomException(RoomErrorCode.PLAYER_NOT_FOUND)));
+                nextHost.orElseThrow(() -> new CustomException(RoomErrorCode.PLAYER_NOT_FOUND)));
     }
 
     private String getUserDestination() {
@@ -369,12 +371,12 @@ public void exitRoomForDisconnectedPlayer(Long roomId, Player player) {
             String destination = getDestination(roomId);
 
             SystemNoticeResponse systemNoticeResponse =
-                ofPlayerEvent(player.nickname, RoomEventType.EXIT);
+                    ofPlayerEvent(player.nickname, RoomEventType.EXIT);
 
             messageSender.sendBroadcast(
-                destination, MessageType.SYSTEM_NOTICE, systemNoticeResponse);
+                    destination, MessageType.SYSTEM_NOTICE, systemNoticeResponse);
             messageSender.sendBroadcast(
-                destination, MessageType.PLAYER_LIST, toPlayerListResponse(room));
+                    destination, MessageType.PLAYER_LIST, toPlayerListResponse(room));
         }
     }
 
@@ -417,7 +419,7 @@ public void removeUserRepository(Long userId, Long roomId) {
         userRoomRepository.removeUser(userId, roomId);
     }
 
-    public boolean isUserInAnyRoom(Long userId){
+    public boolean isUserInAnyRoom(Long userId) {
         return userRoomRepository.isUserInAnyRoom(userId);
     }
 }

backend/src/main/java/io/f1/backend/domain/game/mapper/RoomMapper.java

@@ -128,7 +128,7 @@ public static GameResultListResponse toGameResultListResponse(
             Map<Long, Player> playerMap, int round) {
 
         List<Player> rankedPlayers =
-            playerMap.values().stream()
+                playerMap.values().stream()
                         .sorted(Comparator.comparingInt(Player::getCorrectCount).reversed())
                         .toList();
 

backend/src/main/java/io/f1/backend/domain/game/model/Room.java

@@ -4,6 +4,9 @@
 import io.f1.backend.domain.question.entity.Question;
 import io.f1.backend.global.exception.CustomException;
 import io.f1.backend.global.exception.errorcode.RoomErrorCode;
+
+import lombok.Getter;
+
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
@@ -13,7 +16,6 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
-import lombok.Getter;
 
 @Getter
 public class Room {
@@ -84,7 +86,6 @@ public void removePlayer(Player removePlayer) {
         playerMap.remove(removePlayer.getId());
     }
 
-
     public void increasePlayerCorrectCount(Long userId) {
         this.playerMap.get(userId).increaseCorrectCount();
     }

backend/src/main/java/io/f1/backend/domain/game/store/UserRoomRepository.java

@@ -2,9 +2,11 @@
 
 import io.f1.backend.domain.game.model.Player;
 import io.f1.backend.domain.game.model.Room;
+
+import org.springframework.stereotype.Repository;
+
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
-import org.springframework.stereotype.Repository;
 
 @Repository
 public class UserRoomRepository {
@@ -26,5 +28,4 @@ public void removeUser(Long userId, Long roomId) {
     public boolean isUserInAnyRoom(Long userId) {
         return userRoomMap.containsKey(userId);
     }
-
 }