refactor: Siteuser 도메인 리팩터링 (#336)

* refactor: SiteUser 엔티티

- SiteUser 엔티티의 nickname 컬럼에 unique 제약 조건 추가

* fix: site_user 테이블의 nickname 컬럼에 unique 제약 조건 추가

* refactor: SiteUser 도메인 관련

- MyPageService에서 중복 닉네임 검증 로직 제거
- 컨트롤러에서 try-catch 문을 통해 예외 처리

* refactor: 회원 정보 변경 관련 로직 수정

- 변경된 컬럼만 업데이트하는 쿼리 사용

* refactor: sign up 시 닉네임 검증 로직 제거

- nickname 제약 조건의 이름 명시적으로 지정

* refactor: 도메인 로직 변경에 따른 테스트 코드 수정

- 게시글_좋아요_동시성_문제를_해결한다: 동일한 닉네임을 사용하지 않도록 변경
- 이메일이_같더라도_인증_유형이_다른_사용자는_정상_저장한다: 동일한 닉네임을 사용하지 않도록 변경
- 닉네임 무결성 테스트는 repository test로 분리
- 새로운_이미지로_성공적으로_업데이트한다: DB에서 사용자 조회 후 URL 비교

* refactor: 예외 처리를 컨트롤러가 아닌 서비스 계층에서 처리하도록 변경

* refactor: JPQL이 아닌 dirty check를 사용하도록 변경 외

- 중복 닉네임 검증보다 닉네임 수정 시간 검증이 선행되도록 변경
- 준영속 엔티티를 save()하는 과정에서 발생하는 N+1 문제 해결
- DB 레벨, 애플리케이션 레벨 검증 모두 사용하도록
- 위 변경사항에 따른 테스트 코드 수정

* refactor: 로그에만 예외 원문 포함하도록 변경 및 상태코드 수정

* refactor: 회원가입 시 닉네임 관련 애플리케이션 레벨 검증 추가

- CustomExceptionHandler에 DB 레벨에서 중복 닉네임 검증 추가에 따라 try-catch 문 삭제

* refactor: 미사용 코드 제거 (JPQL 관련)

* test: 중복된_닉네임으로_사용자를_저장하면_예외_응답을_반환한다 테스트 수정

- save -> saveAndFlush

* chore: 미사용 import문 제거

* chore: 함수명과 중괄호 사이 띄어쓰기 추가 (컨벤션 관련)

* chore: 호출 순서에 따라 메서드 선언 재배치

* chore: 마이그레이션 파일 버전 수정 V13 -> V14

Author: whqtker

src/main/java/com/example/solidconnection/common/exception/CustomExceptionHandler.java

@@ -4,6 +4,7 @@
 import com.fasterxml.jackson.databind.exc.InvalidFormatException;
 import io.jsonwebtoken.JwtException;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.MethodArgumentNotValidException;
@@ -13,6 +14,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import static com.example.solidconnection.common.exception.ErrorCode.DATA_INTEGRITY_VIOLATION;
 import static com.example.solidconnection.common.exception.ErrorCode.INVALID_INPUT;
 import static com.example.solidconnection.common.exception.ErrorCode.JSON_PARSING_FAILED;
 import static com.example.solidconnection.common.exception.ErrorCode.JWT_EXCEPTION;
@@ -56,6 +58,15 @@ public ResponseEntity<ErrorResponse> handleValidationExceptions(MethodArgumentNo
                 .body(errorResponse);
     }
 
+    @ExceptionHandler(DataIntegrityViolationException.class)
+    public ResponseEntity<Object> handleDataIntegrityViolationException(DataIntegrityViolationException ex) {
+        log.error("데이터 무결성 제약조건 위반 예외 발생 : {}", ex.getMessage());
+        ErrorResponse errorResponse = new ErrorResponse(DATA_INTEGRITY_VIOLATION, "데이터 무결성 제약조건 위반 예외 발생");
+        return ResponseEntity
+                .status(DATA_INTEGRITY_VIOLATION.getCode())
+                .body(errorResponse);
+    }
+
     @ExceptionHandler(JwtException.class)
     public ResponseEntity<Object> handleJwtException(JwtException ex) {
         String errorMessage = ex.getMessage();

src/main/java/com/example/solidconnection/common/exception/ErrorCode.java

@@ -96,6 +96,9 @@ public enum ErrorCode {
     USER_DO_NOT_HAVE_GPA(HttpStatus.BAD_REQUEST.value(), "해당 유저의 학점을 찾을 수 없음"),
     REJECTED_REASON_REQUIRED(HttpStatus.BAD_REQUEST.value(), "거절 사유가 필요합니다."),
 
+    // database
+    DATA_INTEGRITY_VIOLATION(HttpStatus.CONFLICT.value(), "데이터베이스 무결성 제약조건 위반이 발생했습니다."),
+
     // general
     JSON_PARSING_FAILED(HttpStatus.BAD_REQUEST.value(), "JSON 파싱을 할 수 없습니다."),
     JWT_EXCEPTION(HttpStatus.BAD_REQUEST.value(), "JWT 토큰을 처리할 수 없습니다."),

src/main/java/com/example/solidconnection/siteuser/controller/MyPageController.java

@@ -1,5 +1,6 @@
 package com.example.solidconnection.siteuser.controller;
 
+
 import com.example.solidconnection.common.resolver.AuthorizedUser;
 import com.example.solidconnection.siteuser.domain.SiteUser;
 import com.example.solidconnection.siteuser.dto.MyPageResponse;

src/main/java/com/example/solidconnection/siteuser/domain/SiteUser.java

@@ -35,6 +35,10 @@
         @UniqueConstraint(
                 name = "uk_site_user_email_auth_type",
                 columnNames = {"email", "auth_type"}
+        ),
+        @UniqueConstraint(
+                name = "uk_site_user_nickname",
+                columnNames = {"nickname"}
         )
 })
 public class SiteUser {

src/main/java/com/example/solidconnection/siteuser/repository/SiteUserRepository.java

@@ -1,5 +1,6 @@
 package com.example.solidconnection.siteuser.repository;
 
+
 import com.example.solidconnection.siteuser.domain.AuthType;
 import com.example.solidconnection.siteuser.domain.SiteUser;
 import org.springframework.data.jpa.repository.JpaRepository;

src/main/java/com/example/solidconnection/siteuser/service/MyPageService.java

@@ -21,6 +21,7 @@
 
 import static com.example.solidconnection.common.exception.ErrorCode.CAN_NOT_CHANGE_NICKNAME_YET;
 import static com.example.solidconnection.common.exception.ErrorCode.NICKNAME_ALREADY_EXISTED;
+import static com.example.solidconnection.common.exception.ErrorCode.USER_NOT_FOUND;
 
 @RequiredArgsConstructor
 @Service
@@ -47,27 +48,23 @@ public MyPageResponse getMyPageInfo(SiteUser siteUser) {
      * */
     @Transactional
     public void updateMyPageInfo(SiteUser siteUser, MultipartFile imageFile, String nickname) {
+        SiteUser user = siteUserRepository.findById(siteUser.getId())
+                .orElseThrow(() -> new CustomException(USER_NOT_FOUND));
+
         if (nickname != null) {
+            validateNicknameNotChangedRecently(user.getNicknameModifiedAt());
             validateNicknameUnique(nickname);
-            validateNicknameNotChangedRecently(siteUser.getNicknameModifiedAt());
-            siteUser.setNickname(nickname);
-            siteUser.setNicknameModifiedAt(LocalDateTime.now());
+            user.setNickname(nickname);
+            user.setNicknameModifiedAt(LocalDateTime.now());
         }
 
         if (imageFile != null && !imageFile.isEmpty()) {
             UploadedFileUrlResponse uploadedFile = s3Service.uploadFile(imageFile, ImgType.PROFILE);
-            if (!isDefaultProfileImage(siteUser.getProfileImageUrl())) {
-                s3Service.deleteExProfile(siteUser);
+            if (!isDefaultProfileImage(user.getProfileImageUrl())) {
+                s3Service.deleteExProfile(user);
             }
             String profileImageUrl = uploadedFile.fileUrl();
-            siteUser.setProfileImageUrl(profileImageUrl);
-        }
-        siteUserRepository.save(siteUser);
-    }
-
-    private void validateNicknameUnique(String nickname) {
-        if (siteUserRepository.existsByNickname(nickname)) {
-            throw new CustomException(NICKNAME_ALREADY_EXISTED);
+            user.setProfileImageUrl(profileImageUrl);
         }
     }
 
@@ -82,6 +79,12 @@ private void validateNicknameNotChangedRecently(LocalDateTime lastModifiedAt) {
         }
     }
 
+    private void validateNicknameUnique(String nickname) {
+        if (siteUserRepository.existsByNickname(nickname)) {
+            throw new CustomException(NICKNAME_ALREADY_EXISTED);
+        }
+    }
+
     private boolean isDefaultProfileImage(String profileImageUrl) {
         String prefix = "profile/";
         return profileImageUrl == null || !profileImageUrl.startsWith(prefix);

src/main/resources/db/migration/V14__set_unique_constraint_to_nickname.sql

@@ -0,0 +1,3 @@
+ALTER TABLE site_user
+ADD CONSTRAINT uk_site_user_nickname
+UNIQUE (nickname);

src/test/java/com/example/solidconnection/concurrency/PostLikeCountConcurrencyTest.java

@@ -21,7 +21,7 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 
-import static com.example.solidconnection.e2e.DynamicFixture.createSiteUserByEmail;
+import static com.example.solidconnection.e2e.DynamicFixture.createSiteUserByEmailAndNickname;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 @TestContainerSpringBootTest
@@ -92,7 +92,8 @@ private Post createPost(Board board, SiteUser siteUser) {
 
         for (int i = 0; i < THREAD_NUMS; i++) {
             String email = "email" + i;
-            SiteUser tmpSiteUser = siteUserRepository.save(createSiteUserByEmail(email));
+            String nickname = "nickname" + i;
+            SiteUser tmpSiteUser = siteUserRepository.save(createSiteUserByEmailAndNickname(email, nickname));
             executorService.submit(() -> {
                 try {
                     postLikeService.likePost(tmpSiteUser, post.getId());

src/test/java/com/example/solidconnection/e2e/DynamicFixture.java

@@ -6,10 +6,10 @@
 
 public class DynamicFixture { // todo: test fixture 개선 작업 이후, 이 클래스의 사용이 대체되면 삭제 필요
 
-    public static SiteUser createSiteUserByEmail(String email) {
+    public static SiteUser createSiteUserByEmailAndNickname(String email, String nickname) {
         return new SiteUser(
                 email,
-                "nickname",
+                nickname,
                 "profileImage",
                 PreparationStatus.CONSIDERING,
                 Role.MENTEE

src/test/java/com/example/solidconnection/siteuser/repository/SiteUserRepositoryTest.java

@@ -24,8 +24,8 @@ class 이메일과_인증_유형이_동일한_사용자는_저장할_수_없다
         @Test
         void 이메일과_인증_유형이_동일한_사용자를_저장하면_예외_응답을_반환한다() {
             // given
-            SiteUser user1 = createSiteUser("email", AuthType.KAKAO);
-            SiteUser user2 = createSiteUser("email", AuthType.KAKAO);
+            SiteUser user1 = createSiteUser("email", "nickname1", AuthType.KAKAO);
+            SiteUser user2 = createSiteUser("email", "nickname2", AuthType.KAKAO);
             siteUserRepository.save(user1);
 
             // when, then
@@ -36,8 +36,8 @@ class 이메일과_인증_유형이_동일한_사용자는_저장할_수_없다
         @Test
         void 이메일이_같더라도_인증_유형이_다른_사용자는_정상_저장한다() {
             // given
-            SiteUser user1 = createSiteUser("email", AuthType.KAKAO);
-            SiteUser user2 = createSiteUser("email", AuthType.APPLE);
+            SiteUser user1 = createSiteUser("email", "nickname1", AuthType.KAKAO);
+            SiteUser user2 = createSiteUser("email", "nickname2", AuthType.APPLE);
             siteUserRepository.save(user1);
 
             // when, then
@@ -46,10 +46,42 @@ class 이메일과_인증_유형이_동일한_사용자는_저장할_수_없다
         }
     }
 
-    private SiteUser createSiteUser(String email, AuthType authType) {
+    @Nested
+    class 닉네임은_중복될_수_없다 {
+
+        @Test
+        void 중복된_닉네임으로_사용자를_저장하면_예외_응답을_반환한다() {
+            // given
+            SiteUser user1 = createSiteUser("email1", "nickname", AuthType.KAKAO);
+            SiteUser user2 = createSiteUser("email2", "nickname", AuthType.KAKAO);
+            siteUserRepository.save(user1);
+
+            // when, then
+            assertThatCode(() -> siteUserRepository.saveAndFlush(user2))
+                    .isInstanceOf(DataIntegrityViolationException.class);
+        }
+
+        @Test
+        void 중복된_닉네임으로_변경하면_예외_응답을_반환한다() {
+            // given
+            SiteUser user1 = createSiteUser("email1", "nickname1", AuthType.KAKAO);
+            SiteUser user2 = createSiteUser("email2", "nickname2", AuthType.KAKAO);
+            siteUserRepository.save(user1);
+            siteUserRepository.save(user2);
+
+            // when
+            user2.setNickname("nickname1");
+
+            // then
+            assertThatCode(() -> siteUserRepository.saveAndFlush(user2))
+                    .isInstanceOf(DataIntegrityViolationException.class);
+        }
+    }
+
+    private SiteUser createSiteUser(String email, String nickname, AuthType authType) {
         return new SiteUser(
                 email,
-                "nickname",
+                nickname,
                 "profileImageUrl",
                 PreparationStatus.CONSIDERING,
                 Role.MENTEE,