[REFACTOR] DB Flush 호출 최소화 및 전역 Soft Delete 적용

.github/workflows/cicd.yml

@@ -40,8 +40,8 @@ jobs:
 
       - name: Run tests
         run: |
-          echo ">>> [CI] Running tests..."
-          ./gradlew test --no-daemon
+          echo ">>> [CI] Running tests without integration tests..."
+          ./gradlew test -PskipIntegrationTests --no-daemon
           echo ">>> [CI] Tests passed"
 
   docker-build-and-push:

build.gradle

@@ -94,6 +94,10 @@ dependencies {
 
 tasks.named('test') {
     useJUnitPlatform()
+
+    if (project.hasProperty('skipIntegrationTests')) {
+        exclude '**/*IntegrationTest.class'
+    }
 }
 
 def generated = "$buildDir/generated/sources/annotationProcessor/java/main"

src/main/java/com/project/dorumdorum/domain/chat/domain/entity/ChatMessage.java

@@ -4,12 +4,14 @@
 import io.hypersistence.utils.hibernate.id.Tsid;
 import jakarta.persistence.*;
 import lombok.*;
+import org.hibernate.annotations.SQLRestriction;
 
 @Entity
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @AllArgsConstructor(access = AccessLevel.PROTECTED)
 @Builder
+@SQLRestriction("deleted_at is null")
 @Table(
     indexes = @Index(name = "idx_chat_message_room_created_message", columnList = "chat_room_no, created_at, message_no")
 )

src/main/java/com/project/dorumdorum/domain/chat/domain/entity/ChatRoom.java

@@ -10,10 +10,12 @@
 import jakarta.persistence.Index;
 import jakarta.persistence.Table;
 import lombok.*;
+import org.hibernate.annotations.SQLRestriction;
 
 import java.time.LocalDateTime;
 
 @Entity
+@SQLRestriction("deleted_at is null")
 @Table(
         indexes = {
                 @Index(name = "idx_chat_room_last_message_at", columnList = "last_message_at"),

src/main/java/com/project/dorumdorum/domain/chat/domain/entity/ChatRoomMember.java

@@ -4,6 +4,7 @@
 import io.hypersistence.utils.hibernate.id.Tsid;
 import jakarta.persistence.*;
 import lombok.*;
+import org.hibernate.annotations.SQLRestriction;
 
 import java.time.LocalDateTime;
 
@@ -12,14 +13,11 @@
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @AllArgsConstructor(access = AccessLevel.PROTECTED)
 @Builder
+@SQLRestriction("deleted_at is null")
 @Table(
     indexes = {
         @Index(name = "idx_chat_room_member_user_room", columnList = "user_no, chat_room_no")
-    },
-    uniqueConstraints = @UniqueConstraint(
-        name = "uk_chat_room_member_room_user",
-        columnNames = {"chat_room_no", "user_no"}
-    )
+    }
 )
 public class ChatRoomMember extends BaseEntity {
 

src/main/java/com/project/dorumdorum/domain/chat/domain/repository/ChatMessageRepository.java

@@ -20,7 +20,7 @@ int decreaseUnreadCount(@Param("chatRoomNo") String chatRoomNo,
                             @Param("fromTime") LocalDateTime fromTime,
                             @Param("userNo") String userNo);
 
-    @Modifying(clearAutomatically = true)
-    @Query("DELETE FROM ChatMessage m WHERE m.chatRoom.chatRoomNo = :chatRoomNo")
+    @Modifying(clearAutomatically = true, flushAutomatically = true)
+    @Query("UPDATE ChatMessage m SET m.deletedAt = CURRENT_TIMESTAMP WHERE m.chatRoom.chatRoomNo = :chatRoomNo AND m.deletedAt IS NULL")
     void deleteByChatRoomNo(@Param("chatRoomNo") String chatRoomNo);
 }

src/main/java/com/project/dorumdorum/domain/chat/domain/repository/ChatRoomMemberRepository.java

@@ -37,6 +37,6 @@ Optional<ChatRoomMember> findByChatRoomNoAndUserNoForUpdate(
     boolean existsByChatRoom_ChatRoomNoAndUserNo(String chatRoomNo, String userNo);
 
     @Modifying(clearAutomatically = true, flushAutomatically = true)
-    @Query("DELETE FROM ChatRoomMember m WHERE m.chatRoom = :chatRoom")
+    @Query("UPDATE ChatRoomMember m SET m.deletedAt = CURRENT_TIMESTAMP WHERE m.chatRoom = :chatRoom AND m.deletedAt IS NULL")
     void deleteAllByChatRoom(@Param("chatRoom") ChatRoom chatRoom);
 }

src/main/java/com/project/dorumdorum/domain/chat/domain/repository/ChatRoomRepository.java

@@ -24,6 +24,6 @@ Optional<ChatRoom> findByRoomNoAndChatRoomTypeAndApplicantUserNo(
             String roomNo, ChatRoomType chatRoomType, String applicantUserNo);
 
     @Modifying(clearAutomatically = true, flushAutomatically = true)
-    @Query("DELETE FROM ChatRoom c WHERE c.chatRoomNo = :chatRoomNo")
+    @Query("UPDATE ChatRoom c SET c.deletedAt = CURRENT_TIMESTAMP WHERE c.chatRoomNo = :chatRoomNo AND c.deletedAt IS NULL")
     void deleteByChatRoomNo(@Param("chatRoomNo") String chatRoomNo);
 }

src/main/java/com/project/dorumdorum/domain/chat/domain/service/ChatRoomMemberService.java

@@ -67,7 +67,8 @@ public boolean isMemberByChatRoomNo(String chatRoomNo, String userNo) {
     }
 
     public void leave(ChatRoomMember member) {
-        chatRoomMemberRepository.delete(member);
+        member.delete();
+        chatRoomMemberRepository.save(member);
     }
 
     public void deleteAllByChatRoom(ChatRoom chatRoom) {

src/main/java/com/project/dorumdorum/domain/chat/domain/service/ChatRoomService.java

@@ -64,7 +64,8 @@ public void updateLastMessage(ChatRoom chatRoom, String content, String senderNo
     }
 
     public void delete(ChatRoom chatRoom) {
-        chatRoomRepository.delete(chatRoom);
+        chatRoom.delete();
+        chatRoomRepository.save(chatRoom);
     }
 
     public void deleteByChatRoomNo(String chatRoomNo) {

src/main/java/com/project/dorumdorum/domain/checklist/domain/entity/ChecklistBase.java

@@ -123,6 +123,17 @@ public abstract class ChecklistBase {
     @Column(name = "updated_at", nullable = false)
     private LocalDateTime updatedAt;
 
+    @Column(name = "deleted_at")
+    private LocalDateTime deletedAt;
+
+    public boolean isDeleted() {
+        return deletedAt != null;
+    }
+
+    public void delete() {
+        deletedAt = LocalDateTime.now();
+    }
+
     public void updateChecklist(
             String bedtime,
             String wakeUp,

src/main/java/com/project/dorumdorum/domain/checklist/domain/entity/RoomRule.java

@@ -6,8 +6,10 @@
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
+import org.hibernate.annotations.SQLRestriction;
 
 @Entity
+@SQLRestriction("deleted_at is null")
 @Table(
         name = "room_rule",
         indexes = {

src/main/java/com/project/dorumdorum/domain/checklist/domain/repository/RoomRuleRepository.java

@@ -14,6 +14,6 @@ public interface RoomRuleRepository extends JpaRepository<RoomRule, String> {
     Optional<RoomRule> findByRoomNo(@Param("roomNo") String roomNo);
 
     @Modifying(clearAutomatically = true, flushAutomatically = true)
-    @Query("DELETE FROM RoomRule rr WHERE rr.room.roomNo = :roomNo")
+    @Query("UPDATE RoomRule rr SET rr.deletedAt = CURRENT_TIMESTAMP WHERE rr.room.roomNo = :roomNo AND rr.deletedAt IS NULL")
     void deleteByRoomNo(@Param("roomNo") String roomNo);
 }

src/main/java/com/project/dorumdorum/domain/room/application/usecase/DeleteRoomUseCase.java

@@ -33,8 +33,8 @@ public class DeleteRoomUseCase {
      * 방 삭제
      * - 방장 권한 검증
      * - 방장 외 룸메이트 존재 시 삭제 불가
-     * - 방 소프트 삭제 → 룸메이트 퇴실 처리 → flush(deletedAt DB 반영)
-     * - RoomRequest, RoomRule, RoomLike 연관 데이터 삭제
+     * - 방 소프트 삭제 → 룸메이트 퇴실 처리
+     * - RoomRequest, RoomRule, RoomLike 연관 데이터 삭제 (@Modifying flushAutomatically로 자동 flush)
      * - 채팅방 삭제 이벤트 발행
      */
     public void execute(String requesterNo, String roomNo) {
@@ -54,7 +54,6 @@ public void execute(String requesterNo, String roomNo) {
 
         room.delete();
         roommateService.leaveRoom(requesterNo, roomNo);
-        roomService.flush();
 
         roomRequestService.deleteAllByRoom(room);
         roomRuleService.deleteByRoomNo(roomNo);

src/main/java/com/project/dorumdorum/domain/room/application/usecase/KickRoommateUseCase.java

@@ -41,7 +41,6 @@ public void execute(String requesterNo, String roomNo, String kickedUserNo) {
 
         roommateService.leaveRoom(kickedUserNo, roomNo);
         room.minusCurrentMate();
-        roomService.flush();
 
         eventPublisher.publishEvent(new RoommateKickedEvent(roomNo, kickedUserNo));
     }

src/main/java/com/project/dorumdorum/domain/room/domain/entity/RoomLike.java

@@ -4,16 +4,15 @@
 import io.hypersistence.utils.hibernate.id.Tsid;
 import jakarta.persistence.*;
 import lombok.*;
+import org.hibernate.annotations.SQLRestriction;
 
 @Entity
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @AllArgsConstructor(access = AccessLevel.PROTECTED)
 @Builder
+@SQLRestriction("deleted_at is null")
 @Table(
-        uniqueConstraints = {
-                @UniqueConstraint(name = "uk_room_like_user_room", columnNames = {"user_no", "room_no"})
-        },
         indexes = {
         }
 )

src/main/java/com/project/dorumdorum/domain/room/domain/entity/RoomRequest.java

@@ -4,16 +4,15 @@
 import io.hypersistence.utils.hibernate.id.Tsid;
 import jakarta.persistence.*;
 import lombok.*;
+import org.hibernate.annotations.SQLRestriction;
 
 @Entity
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @AllArgsConstructor(access = AccessLevel.PROTECTED)
 @Builder
+@SQLRestriction("deleted_at is null")
 @Table(
-        uniqueConstraints = {
-                @UniqueConstraint(name = "uk_room_request_user_room_direction", columnNames = {"user_no", "room_no", "direction"})
-        },
         indexes = {
                 @Index(name = "idx_room_request_room_created", columnList = "room_no, created_at")
         }

src/main/java/com/project/dorumdorum/domain/room/domain/repository/RoomLikeRepository.java

@@ -10,11 +10,13 @@
 public interface RoomLikeRepository extends JpaRepository<RoomLike, String> {
 
     boolean existsByUserNoAndRoom(String userNo, Room room);
-    void deleteByUserNoAndRoom(String userNo, Room room);
 
-    // N+1 DELETE 문제 — @Modifying JPQL 벌크 DELETE로 교체
     @Modifying(clearAutomatically = true, flushAutomatically = true)
-    @Query("DELETE FROM RoomLike l WHERE l.room = :room")
+    @Query("UPDATE RoomLike l SET l.deletedAt = CURRENT_TIMESTAMP WHERE l.userNo = :userNo AND l.room = :room AND l.deletedAt IS NULL")
+    void deleteByUserNoAndRoom(@Param("userNo") String userNo, @Param("room") Room room);
+
+    @Modifying(clearAutomatically = true, flushAutomatically = true)
+    @Query("UPDATE RoomLike l SET l.deletedAt = CURRENT_TIMESTAMP WHERE l.room = :room AND l.deletedAt IS NULL")
     void deleteAllByRoom(@Param("room") Room room);
 }
 

src/main/java/com/project/dorumdorum/domain/room/domain/repository/RoomRequestRepository.java

@@ -15,9 +15,8 @@ public interface RoomRequestRepository extends JpaRepository<RoomRequest, String
     boolean existsByUserNoAndRoom(String userNo, Room room);
     Optional<RoomRequest> findByUserNoAndRoomAndDirection(String userNo, Room room, Direction direction);
 
-    // N+1 DELETE 문제 — @Modifying JPQL 벌크 DELETE로 교체
     @Modifying(clearAutomatically = true, flushAutomatically = true)
-    @Query("DELETE FROM RoomRequest r WHERE r.room = :room")
+    @Query("UPDATE RoomRequest r SET r.deletedAt = CURRENT_TIMESTAMP WHERE r.room = :room AND r.deletedAt IS NULL")
     void deleteAllByRoom(@Param("room") Room room);
 }
 

src/main/java/com/project/dorumdorum/domain/room/domain/service/RoomRequestService.java

@@ -42,7 +42,8 @@ public RoomRequest findById(String requestNo) {
     }
 
     public void delete(RoomRequest entity) {
-        roomRequestRepository.delete(entity);
+        entity.delete();
+        roomRequestRepository.save(entity);
     }
 
     public List<RoomRequestApplicationResponse> findApplicationsByRoom(Room room) {
@@ -54,7 +55,8 @@ public void cancelJoinRequest(String userNo, Room room) {
                 .findByUserNoAndRoomAndDirection(userNo, room, Direction.USER_TO_ROOM)
                 .orElseThrow(() -> new RestApiException(ROOM_REQUEST_NOT_FOUND));
 
-        roomRequestRepository.delete(request);
+        request.delete();
+        roomRequestRepository.save(request);
     }
 
     public void deleteAllByRoom(Room room) {

src/main/java/com/project/dorumdorum/domain/room/domain/service/RoomService.java

@@ -61,10 +61,6 @@ public FindRoomsResponse findMyRoom(String userNo) {
                 .orElseThrow(() -> new RestApiException(ROOM_NOT_FOUND));
     }
 
-    public void flush() {
-        roomRepository.flush();
-    }
-
     public List<FindRoomsResponse> findLikedRooms(String userNo) {
         return roomRepository.findLikedRooms(userNo);
     }

src/main/java/com/project/dorumdorum/domain/roommate/domain/entity/Roommate.java

@@ -5,16 +5,15 @@
 import io.hypersistence.utils.hibernate.id.Tsid;
 import jakarta.persistence.*;
 import lombok.*;
+import org.hibernate.annotations.SQLRestriction;
 
 @Entity
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @AllArgsConstructor(access = AccessLevel.PROTECTED)
 @Builder
+@SQLRestriction("deleted_at is null")
 @Table(
-        uniqueConstraints = {
-                @UniqueConstraint(name = "uk_roommate_user_no", columnNames = "user_no")
-        },
         indexes = {
                 @Index(name = "idx_roommate_room_no", columnList = "room_no")
         }

src/main/java/com/project/dorumdorum/domain/roommate/domain/service/RoommateService.java

@@ -66,8 +66,8 @@ public boolean isHostOfRoom(String userNo, String roomNo) {
     public void leaveRoom(String userNo, String roomNo) {
         Roommate roommate = roommateRepository.findByUserNoAndRoomNo(userNo, roomNo)
                 .orElseThrow(() -> new RestApiException(_NOT_FOUND));
-        // uk_roommate_user_no 유니크 제약으로 인해 소프트 삭제 불가 — 하드 삭제 유지
-        roommateRepository.delete(roommate);
+        roommate.delete();
+        roommateRepository.save(roommate);
     }
 
     public List<MyRoommateResponse> findMyRoommates(String userNo) {

src/main/resources/schema.sql

@@ -4,17 +4,34 @@ CREATE UNIQUE INDEX IF NOT EXISTS uk_user_email
 CREATE UNIQUE INDEX IF NOT EXISTS uk_user_student_no
     ON users (student_no);
 
+ALTER TABLE IF EXISTS room_rule ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP;
+
+ALTER TABLE IF EXISTS roommate DROP CONSTRAINT IF EXISTS uk_roommate_user_no;
+DROP INDEX IF EXISTS uk_roommate_user_no;
 CREATE UNIQUE INDEX IF NOT EXISTS uk_roommate_user_no
-    ON roommate (user_no);
+    ON roommate (user_no)
+    WHERE deleted_at IS NULL;
 
+ALTER TABLE IF EXISTS room_like DROP CONSTRAINT IF EXISTS uk_room_like_user_room;
+DROP INDEX IF EXISTS uk_room_like_user_room;
 CREATE UNIQUE INDEX IF NOT EXISTS uk_room_like_user_room
-    ON room_like (user_no, room_no);
+    ON room_like (user_no, room_no)
+    WHERE deleted_at IS NULL;
 
 CREATE UNIQUE INDEX IF NOT EXISTS uk_device_user_device
     ON devices (user_no, device_id);
 
+ALTER TABLE IF EXISTS room_request DROP CONSTRAINT IF EXISTS uk_room_request_user_room_direction;
+DROP INDEX IF EXISTS uk_room_request_user_room_direction;
 CREATE UNIQUE INDEX IF NOT EXISTS uk_room_request_user_room_direction
-    ON room_request (user_no, room_no, direction);
+    ON room_request (user_no, room_no, direction)
+    WHERE deleted_at IS NULL;
+
+ALTER TABLE IF EXISTS chat_room_member DROP CONSTRAINT IF EXISTS uk_chat_room_member_room_user;
+DROP INDEX IF EXISTS uk_chat_room_member_room_user;
+CREATE UNIQUE INDEX IF NOT EXISTS uk_chat_room_member_room_user
+    ON chat_room_member (chat_room_no, user_no)
+    WHERE deleted_at IS NULL;
 
 ALTER TABLE IF EXISTS users
     ALTER COLUMN gender SET NOT NULL;
@@ -30,13 +47,15 @@ CREATE INDEX IF NOT EXISTS idx_room_status_gender_remaining_created
 ALTER TABLE IF EXISTS chat_room
     DROP CONSTRAINT IF EXISTS uk_chat_room_direct;
 
+DROP INDEX IF EXISTS uk_chat_room_group;
 CREATE UNIQUE INDEX IF NOT EXISTS uk_chat_room_group
     ON chat_room (room_no)
-    WHERE chat_room_type = 'GROUP';
+    WHERE chat_room_type = 'GROUP' AND deleted_at IS NULL;
 
+DROP INDEX IF EXISTS uk_chat_room_direct;
 CREATE UNIQUE INDEX IF NOT EXISTS uk_chat_room_direct
     ON chat_room (room_no, applicant_user_no)
-    WHERE chat_room_type = 'DIRECT';
+    WHERE chat_room_type = 'DIRECT' AND deleted_at IS NULL;
 
 CREATE INDEX IF NOT EXISTS idx_chat_room_room_no
     ON chat_room (room_no);