[백은호] Sprint7

.gitignore

@@ -4,6 +4,12 @@ build/
 !**/src/main/**/build/
 !**/src/test/**/build/
 file-data
+storage
+
+### Logs ###
+.logs/
+*.log
+
 ### IntelliJ IDEA ###
 .idea
 .idea/modules.xml

build.gradle

@@ -30,16 +30,16 @@ dependencies {
 	implementation 'org.springframework.data:spring-data-commons'
 	implementation 'org.postgresql:postgresql'
 	implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.6'
-
-	// MapStruct
-	implementation 'org.mapstruct:mapstruct:1.5.5.Final'
-
+	implementation 'org.mapstruct:mapstruct:1.5.5.Final'	// MapStruct
+	implementation 'org.springframework.boot:spring-boot-starter-actuator'	// Actuator
+
 	compileOnly 'org.projectlombok:lombok'
 	annotationProcessor 'org.projectlombok:lombok'
 	annotationProcessor 'org.projectlombok:lombok-mapstruct-binding:0.2.0'
 	annotationProcessor 'org.mapstruct:mapstruct-processor:1.5.5.Final'
 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+	testImplementation 'com.h2database:h2'
 }
 
 tasks.named('test') {

src/main/java/com/sprint/mission/discodeit/controller/AuthController.java

@@ -6,6 +6,7 @@
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
+import jakarta.validation.Valid;
 
 import com.sprint.mission.discodeit.controller.api.AuthApi;
 import com.sprint.mission.discodeit.dto.mapper.ResponseMapper;
@@ -24,7 +25,7 @@ public class AuthController implements AuthApi {
   private final AuthService authService;
 
   @PostMapping(path = "login")
-  public ResponseEntity<UserResponse> login(@RequestBody LoginRequest loginRequest) {
+  public ResponseEntity<UserResponse> login(@Valid @RequestBody LoginRequest loginRequest) {
     User user = authService.login(loginRequest);
     UserResponse userResponse = ResponseMapper.toResponse(user);
     return ResponseEntity

src/main/java/com/sprint/mission/discodeit/controller/BinaryContentController.java

@@ -9,6 +9,7 @@
 import com.sprint.mission.discodeit.service.BinaryContentService;
 import com.sprint.mission.discodeit.storage.BinaryContentStorage;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
@@ -19,6 +20,7 @@
 @RequiredArgsConstructor
 @RestController
 @RequestMapping("/api/binaryContents")
+@Slf4j
 public class BinaryContentController implements BinaryContentApi {
 
   private final BinaryContentService binaryContentService;
@@ -27,8 +29,14 @@ public class BinaryContentController implements BinaryContentApi {
 
   @GetMapping(path = "{binaryContentId}")
   public ResponseEntity<BinaryContentResponse> find(@PathVariable("binaryContentId") UUID binaryContentId) {
+    log.debug("바이너리 콘텐츠 조회 API 요청 - ID: {}", binaryContentId);
+
     BinaryContent binaryContent = binaryContentService.find(binaryContentId);
     BinaryContentResponse response = ResponseMapper.toResponse(binaryContent);
+
+    log.debug("바이너리 콘텐츠 조회 API 응답 - ID: {}, 파일명: {}, 크기: {} bytes",
+        response.id(), response.fileName(), response.size());
+
     return ResponseEntity
         .status(HttpStatus.OK)
         .body(response);
@@ -37,19 +45,36 @@ public ResponseEntity<BinaryContentResponse> find(@PathVariable("binaryContentId
   @GetMapping
   public ResponseEntity<List<BinaryContentResponse>> findAllByIdIn(
       @RequestParam("binaryContentIds") List<UUID> binaryContentIds) {
+    log.debug("다중 바이너리 콘텐츠 조회 API 요청 - ID 개수: {}", binaryContentIds.size());
+
     List<BinaryContent> binaryContents = binaryContentService.findAllByIdIn(binaryContentIds);
     List<BinaryContentResponse> responses = binaryContents.stream()
         .map(ResponseMapper::toResponse)
         .toList();
+
+    log.debug("다중 바이너리 콘텐츠 조회 API 응답 - 요청: {}, 응답: {}",
+        binaryContentIds.size(), responses.size());
+
     return ResponseEntity
         .status(HttpStatus.OK)
         .body(responses);
   }
 
   @GetMapping(path = "{binaryContentId}/download")
   public ResponseEntity<?> download(@PathVariable("binaryContentId") UUID binaryContentId) {
+    log.info("파일 다운로드 API 요청 - ID: {}", binaryContentId);
+
     BinaryContent binaryContent = binaryContentService.find(binaryContentId);
     BinaryContentDto binaryContentDto = mapperFacade.toDto(binaryContent);
-    return binaryContentStorage.download(binaryContentDto);
+
+    log.info("파일 다운로드 시작 - ID: {}, 파일명: {}, 크기: {} bytes",
+        binaryContentDto.id(), binaryContentDto.fileName(), binaryContentDto.size());
+
+    ResponseEntity<?> response = binaryContentStorage.download(binaryContentDto);
+
+    log.info("파일 다운로드 완료 - ID: {}, 파일명: {}",
+        binaryContentDto.id(), binaryContentDto.fileName());
+
+    return response;
   }
 }

src/main/java/com/sprint/mission/discodeit/controller/ChannelController.java

@@ -33,9 +33,12 @@ public class ChannelController implements ChannelApi {
   @PostMapping(path = "public")
   @Transactional
   public ResponseEntity<ChannelDto> create(@Valid @RequestBody PublicChannelCreateRequest request) {
+    log.info("공개 채널 생성 API 요청 - 이름: {}, 설명: {}", request.name(), request.description());
+
     Channel createdChannel = channelService.create(request);
     ChannelDto response = mapperFacade.toDto(createdChannel);
 
+    log.info("공개 채널 생성 API 응답 - 채널 ID: {}, 이름: {}", response.id(), response.name());
     return ResponseEntity
         .status(HttpStatus.CREATED)
         .body(response);
@@ -44,9 +47,13 @@ public ResponseEntity<ChannelDto> create(@Valid @RequestBody PublicChannelCreate
   @PostMapping(path = "private")
   @Transactional
   public ResponseEntity<ChannelDto> create(@Valid @RequestBody PrivateChannelCreateRequest request) {
+    log.info("비공개 채널 생성 API 요청 - 참가자 수: {}", request.participantIds().size());
+
     Channel createdChannel = channelService.create(request);
     ChannelDto response = mapperFacade.toDto(createdChannel);
 
+    log.info("비공개 채널 생성 API 응답 - 채널 ID: {}, 참가자 수: {}",
+        response.id(), response.participants().size());
     return ResponseEntity
         .status(HttpStatus.CREATED)
         .body(response);
@@ -56,27 +63,37 @@ public ResponseEntity<ChannelDto> create(@Valid @RequestBody PrivateChannelCreat
   public ResponseEntity<ChannelResponse> update(
       @PathVariable("channelId") UUID channelId,
       @Valid @RequestBody PublicChannelUpdateRequest request) {
+    log.info("채널 수정 API 요청 - 채널 ID: {}, 새 이름: {}", channelId, request.newName());
+
     Channel updatedChannel = channelService.update(channelId, request);
     ChannelResponse response = ResponseMapper.toResponse(updatedChannel);
 
+    log.info("채널 수정 API 응답 - 채널 ID: {}, 수정된 이름: {}",
+        response.id(), response.name());
     return ResponseEntity
         .status(HttpStatus.OK)
         .body(response);
   }
 
   @DeleteMapping(path = "{channelId}")
   public ResponseEntity<Void> delete(@PathVariable("channelId") UUID channelId) {
+    log.info("채널 삭제 API 요청 - 채널 ID: {}", channelId);
+
     channelService.delete(channelId);
 
+    log.info("채널 삭제 API 완료 - 채널 ID: {}", channelId);
     return ResponseEntity
         .status(HttpStatus.NO_CONTENT)
         .build();
   }
 
   @GetMapping
   public ResponseEntity<List<ChannelDto>> findAll(@RequestParam("userId") UUID userId) {
+    log.debug("사용자 채널 목록 API 요청 - 사용자 ID: {}", userId);
+
     List<ChannelDto> channels = channelService.findAllByUserId(userId);
 
+    log.debug("사용자 채널 목록 API 응답 - 사용자 ID: {}, 채널 수: {}", userId, channels.size());
     return ResponseEntity
         .status(HttpStatus.OK)
         .body(channels);

src/main/java/com/sprint/mission/discodeit/controller/MessageController.java

@@ -7,10 +7,11 @@
 import com.sprint.mission.discodeit.dto.request.MessageUpdateRequest;
 import com.sprint.mission.discodeit.dto.response.PageResponse;
 import com.sprint.mission.discodeit.service.MessageService;
-import com.sprint.mission.discodeit.exception.CustomException;
+import com.sprint.mission.discodeit.exception.binarycontent.FileUploadFailedException;
 import com.sprint.mission.discodeit.common.Constants;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.web.PageableDefault;
 import org.springframework.http.HttpStatus;
@@ -28,6 +29,7 @@
 @RequiredArgsConstructor
 @RestController
 @RequestMapping("/api/messages")
+@Slf4j
 public class MessageController implements MessageApi {
 
   private final MessageService messageService;
@@ -36,21 +38,35 @@ public class MessageController implements MessageApi {
   public ResponseEntity<MessageDto> create(
       @Valid @RequestPart("messageCreateRequest") MessageCreateRequest messageCreateRequest,
       @RequestPart(value = "attachments", required = false) List<MultipartFile> attachments) {
+
+    int attachmentCount = Optional.ofNullable(attachments).map(List::size).orElse(0);
+    log.info("메시지 생성 API 요청 - 채널 ID: {}, 작성자 ID: {}, 첨부파일 수: {}",
+        messageCreateRequest.channelId(), messageCreateRequest.authorId(), attachmentCount);
+
     List<BinaryContentCreateRequest> attachmentRequests = Optional.ofNullable(attachments)
         .map(files -> files.stream()
             .map(file -> {
               try {
+                log.debug("첨부파일 처리 - 파일명: {}, 크기: {} bytes",
+                    file.getOriginalFilename(), file.getSize());
                 return new BinaryContentCreateRequest(
                     file.getOriginalFilename(),
                     file.getContentType(),
                     file.getBytes());
               } catch (IOException e) {
-                throw new CustomException.BinaryContentNotFoundException("첨부파일을 읽는 중 오류가 발생했습니다: " + e.getMessage());
+                log.error("첨부파일 읽기 실패 - 파일명: {}, 오류: {}",
+                    file.getOriginalFilename(), e.getMessage());
+                throw FileUploadFailedException.withCause(e);
               }
             })
             .toList())
         .orElse(new ArrayList<>());
+
     MessageDto createdMessage = messageService.create(messageCreateRequest, attachmentRequests);
+
+    log.info("메시지 생성 API 응답 - 메시지 ID: {}, 채널 ID: {}, 작성자 ID: {}",
+        createdMessage.id(), createdMessage.channelId(), createdMessage.author().id());
+
     return ResponseEntity
         .status(HttpStatus.CREATED)
         .body(createdMessage);
@@ -59,15 +75,26 @@ public ResponseEntity<MessageDto> create(
   @PatchMapping(path = "{messageId}")
   public ResponseEntity<MessageDto> update(@PathVariable("messageId") UUID messageId,
       @Valid @RequestBody MessageUpdateRequest request) {
+    log.info("메시지 수정 API 요청 - 메시지 ID: {}", messageId);
+
     MessageDto updatedMessage = messageService.update(messageId, request);
+
+    log.info("메시지 수정 API 응답 - 메시지 ID: {}, 작성자 ID: {}",
+        updatedMessage.id(), updatedMessage.author().id());
+
     return ResponseEntity
         .status(HttpStatus.OK)
         .body(updatedMessage);
   }
 
   @DeleteMapping(path = "{messageId}")
   public ResponseEntity<Void> delete(@PathVariable("messageId") UUID messageId) {
+    log.info("메시지 삭제 API 요청 - 메시지 ID: {}", messageId);
+
     messageService.delete(messageId);
+
+    log.info("메시지 삭제 API 완료 - 메시지 ID: {}", messageId);
+
     return ResponseEntity
         .status(HttpStatus.NO_CONTENT)
         .build();
@@ -78,7 +105,16 @@ public ResponseEntity<PageResponse<MessageDto>> findAllByChannelId(
       @RequestParam("channelId") UUID channelId,
       @RequestParam(value = "cursor", required = false) String cursor,
       @PageableDefault(size = Constants.Pagination.DEFAULT_PAGE_SIZE, sort = Constants.Pagination.DEFAULT_SORT_FIELD) Pageable pageable) {
-    PageResponse<MessageDto> messages = messageService.findAllByChannelIdWithCursorPaging(channelId, cursor, pageable);
+
+    log.debug("메시지 목록 API 요청 - 채널 ID: {}, 커서: {}, 페이지 크기: {}",
+        channelId, cursor, pageable.getPageSize());
+
+    PageResponse<MessageDto> messages = messageService.findAllByChannelIdWithCursorPaging(channelId, cursor,
+        pageable);
+
+    log.debug("메시지 목록 API 응답 - 채널 ID: {}, 메시지 수: {}, 다음 페이지 존재: {}",
+        channelId, messages.content().size(), messages.hasNext());
+
     return ResponseEntity
         .status(HttpStatus.OK)
         .body(messages);

src/main/java/com/sprint/mission/discodeit/controller/ReadStatusController.java

@@ -11,6 +11,7 @@
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
+import jakarta.validation.Valid;
 
 import java.util.List;
 import java.util.UUID;
@@ -23,7 +24,7 @@ public class ReadStatusController implements ReadStatusApi {
   private final ReadStatusService readStatusService;
 
   @PostMapping
-  public ResponseEntity<ReadStatusResponse> create(@RequestBody ReadStatusCreateRequest request) {
+  public ResponseEntity<ReadStatusResponse> create(@Valid @RequestBody ReadStatusCreateRequest request) {
     ReadStatus createdReadStatus = readStatusService.create(request);
     ReadStatusResponse response = ResponseMapper.toResponse(createdReadStatus);
     return ResponseEntity
@@ -33,7 +34,7 @@ public ResponseEntity<ReadStatusResponse> create(@RequestBody ReadStatusCreateRe
 
   @PatchMapping(path = "{readStatusId}")
   public ResponseEntity<ReadStatusResponse> update(@PathVariable("readStatusId") UUID readStatusId,
-      @RequestBody ReadStatusUpdateRequest request) {
+      @Valid @RequestBody ReadStatusUpdateRequest request) {
     ReadStatus updatedReadStatus = readStatusService.update(readStatusId, request);
     ReadStatusResponse response = ResponseMapper.toResponse(updatedReadStatus);
     return ResponseEntity