feat: 멘토 조회 기능 구현 (#370)

* feat: 멘토 단일 조회 응답 dto 생성

* feat: 멘토, 멘토링, 채널 레포지토리 생성

* feat: 멘토 단일 조회 서비스 함수 생성

* feat: 멘토 단일 조회 컨트롤러 생성

* test: 멘토 관련 픽스처 생성

* refactor: channel 연관관계 편의 메서드 추가

* test: channel 픽스쳐 생성

* test: 멘토 단일 조회 테스트 코드 작성

* feat: 멘토 미리보기 목록 조회 dto 생성

* feat: 멘토 미리보기 Batch 조회를 위한 레포지토리 생성

- Mentor와 SiteUser는 id 만 참조하는 관계이다.
- Mentor와 Mentoring도 id 만 참조하는 관계이다.
- "멘토 목록"에 대해서 매번 siteUser, mentoring과 join 하면 N+1 이 발생한다.
- 이를 해결하기 위해, 한번에 조회하고 매핑하여 1번의 쿼리로 해결한다.

* feat: 멘토 미리보기 목록 서비스 함수 생성

* feat: 멘토 미리보기 목록 컨트롤러 생성

* test: 멘토 미리보기 목록 조회 테스트 코드 작성

* test: 멘토 배치 조회 레포지토리 테스트 코드 작성

* style: 개행 삭제

* refactor: Page가 아니라 Slice를 반환받도록

- Page를 사용할 시, 추가로 발생하는 count 쿼리 방지

* refactor: Channel N+1 문제 해결

* refactor: SliceResponse로 대체

* refactor: 멘토 목록 조회 정렬 정책 구체화

- 기획팀께 답변 받은 내용 적용

* feat: 채널 응답을 sequence 오름차순으로 정렬하는 기능 구현

* refactor: SliceResponse 정적 팩터리 메서드 사용하도록

* refactor: 자연스럽게 읽히도록 파라미터 순서 변경

* refactor: 함수 이름이 의미를 드러내도록 이름 변경

* refactor: JPA 표준 따르도록 함수이름 변경

- findBy -> findAllBy

* refactor: 멘토 객체에서 채널의 순서를 정렬해 가지고 있도록

- test도 더 정확하게 수정

---------

Co-authored-by: seonghyeok <chosh2001@naver.com>

Author: nayonsoso

src/main/java/com/example/solidconnection/common/dto/SliceResponse.java

@@ -0,0 +1,21 @@
+package com.example.solidconnection.common.dto;
+
+import org.springframework.data.domain.Slice;
+
+import java.util.List;
+
+public record SliceResponse<T>(
+        List<T> content,
+        int nextPageNumber
+) {
+
+    private static final int NO_NEXT_PAGE = -1;
+    private static final int BASE_NUMBER = 1; // 1-based
+
+    public static <T, R> SliceResponse<R> of(List<R> content, Slice<T> slice) {
+        int nextPageNumber = slice.hasNext()
+                ? slice.getNumber() + BASE_NUMBER + 1
+                : NO_NEXT_PAGE;
+        return new SliceResponse<>(content, nextPageNumber);
+    }
+}

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

@@ -43,6 +43,7 @@ public enum ErrorCode {
     GPA_SCORE_NOT_FOUND(HttpStatus.NOT_FOUND.value(), "존재하지 않는 학점입니다."),
     LANGUAGE_TEST_SCORE_NOT_FOUND(HttpStatus.NOT_FOUND.value(), "존재하지 않는 어학성적입니다."),
     NEWS_NOT_FOUND(HttpStatus.NOT_FOUND.value(), "존재하지 않는 소식지입니다."),
+    MENTOR_NOT_FOUND(HttpStatus.NOT_FOUND.value(), "존재하지 않는 멘토입니다."),
 
     // auth
     USER_ALREADY_SIGN_OUT(HttpStatus.UNAUTHORIZED.value(), "로그아웃 되었습니다."),
@@ -106,7 +107,6 @@ public enum ErrorCode {
 
     // mentor
     ALREADY_MENTOR(HttpStatus.BAD_REQUEST.value(), "이미 멘토로 등록된 사용자입니다."),
-    MENTOR_NOT_FOUND(HttpStatus.NOT_FOUND.value(), "해당 사용자는 멘토로 등록되어 있지 않습니다."),
     MENTORING_NOT_FOUND(HttpStatus.NOT_FOUND.value(), "해당 멘토링 신청을 찾을 수 없습니다."),
     UNAUTHORIZED_MENTORING(HttpStatus.FORBIDDEN.value(), "멘토링 권한이 없습니다."),
     MENTORING_ALREADY_CONFIRMED(HttpStatus.BAD_REQUEST.value(), "이미 승인 또는 거절된 멘토링입니다."),

src/main/java/com/example/solidconnection/mentor/controller/MentorController.java

@@ -0,0 +1,55 @@
+package com.example.solidconnection.mentor.controller;
+
+import com.example.solidconnection.common.dto.SliceResponse;
+import com.example.solidconnection.common.resolver.AuthorizedUser;
+import com.example.solidconnection.mentor.dto.MentorDetailResponse;
+import com.example.solidconnection.mentor.dto.MentorPreviewResponse;
+import com.example.solidconnection.mentor.service.MentorQueryService;
+import com.example.solidconnection.siteuser.domain.SiteUser;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.web.PageableDefault;
+import org.springframework.data.web.SortDefault;
+import org.springframework.data.web.SortDefault.SortDefaults;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import static org.springframework.data.domain.Sort.Direction.DESC;
+
+@RequiredArgsConstructor
+@RequestMapping("/mentors")
+@RestController
+public class MentorController {
+
+    private final MentorQueryService mentorQueryService;
+
+    @GetMapping("/{mentor-id}")
+    public ResponseEntity<MentorDetailResponse> getMentorDetails(
+            @AuthorizedUser SiteUser siteUser,
+            @PathVariable("mentor-id") Long mentorId
+    ) {
+        MentorDetailResponse response = mentorQueryService.getMentorDetails(mentorId, siteUser);
+        return ResponseEntity.ok(response);
+    }
+
+    @GetMapping
+    public ResponseEntity<SliceResponse<MentorPreviewResponse>> getMentorPreviews(
+            @AuthorizedUser SiteUser siteUser,
+            @RequestParam("region") String region,
+
+            @PageableDefault(size = 3, sort = "menteeCount", direction = DESC)
+            @SortDefaults({
+                    @SortDefault(sort = "menteeCount", direction = Sort.Direction.DESC),
+                    @SortDefault(sort = "id", direction = Sort.Direction.ASC)
+            })
+            Pageable pageable
+    ) {
+        SliceResponse<MentorPreviewResponse> response = mentorQueryService.getMentorPreviews(region, siteUser, pageable);
+        return ResponseEntity.ok(response);
+    }
+}

src/main/java/com/example/solidconnection/mentor/domain/Channel.java

@@ -44,4 +44,8 @@ public class Channel {
 
     @ManyToOne(fetch = FetchType.LAZY)
     private Mentor mentor;
+
+    public void updateMentor(Mentor mentor) {
+        this.mentor = mentor;
+    }
 }

src/main/java/com/example/solidconnection/mentor/domain/Mentor.java

@@ -7,10 +7,12 @@
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
 import jakarta.persistence.OneToMany;
+import jakarta.persistence.OrderBy;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
+import org.hibernate.annotations.BatchSize;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -43,6 +45,8 @@ public class Mentor {
     @Column
     private long universityId;
 
+    @BatchSize(size = 10)
+    @OrderBy("sequence ASC")
     @OneToMany(mappedBy = "mentor", cascade = CascadeType.ALL, orphanRemoval = true)
     private List<Channel> channels = new ArrayList<>();
 

src/main/java/com/example/solidconnection/mentor/dto/ChannelResponse.java

@@ -0,0 +1,17 @@
+package com.example.solidconnection.mentor.dto;
+
+import com.example.solidconnection.mentor.domain.Channel;
+import com.example.solidconnection.mentor.domain.ChannelType;
+
+public record ChannelResponse(
+        ChannelType type,
+        String url
+) {
+
+    public static ChannelResponse from(Channel channel) {
+        return new ChannelResponse(
+                channel.getType(),
+                channel.getUrl()
+        );
+    }
+}

src/main/java/com/example/solidconnection/mentor/dto/MentorDetailResponse.java

@@ -0,0 +1,40 @@
+package com.example.solidconnection.mentor.dto;
+
+import com.example.solidconnection.mentor.domain.Mentor;
+import com.example.solidconnection.siteuser.domain.ExchangeStatus;
+import com.example.solidconnection.siteuser.domain.SiteUser;
+
+import java.util.List;
+
+public record MentorDetailResponse(
+        long id,
+        String nickname,
+        String profileImageUrl,
+        ExchangeStatus exchangeStatus,
+        String country,
+        String universityName,
+        int menteeCount,
+        boolean hasBadge,
+        String introduction,
+        List<ChannelResponse> channels,
+        String passTip,
+        boolean isApplied
+) {
+
+    public static MentorDetailResponse of(Mentor mentor, SiteUser mentorUser, boolean isApplied) {
+        return new MentorDetailResponse(
+                mentor.getId(),
+                mentorUser.getNickname(),
+                mentorUser.getProfileImageUrl(),
+                mentorUser.getExchangeStatus(),
+                "국가", // todo: 교환학생 기록이 인증되면 추가
+                "대학 이름",  // todo: 교환학생 기록이 인증되면 추가
+                mentor.getMenteeCount(),
+                mentor.isHasBadge(),
+                mentor.getIntroduction(),
+                mentor.getChannels().stream().map(ChannelResponse::from).toList(),
+                mentor.getPassTip(),
+                isApplied
+        );
+    }
+}

src/main/java/com/example/solidconnection/mentor/dto/MentorPreviewResponse.java

@@ -0,0 +1,38 @@
+package com.example.solidconnection.mentor.dto;
+
+import com.example.solidconnection.mentor.domain.Mentor;
+import com.example.solidconnection.siteuser.domain.ExchangeStatus;
+import com.example.solidconnection.siteuser.domain.SiteUser;
+
+import java.util.List;
+
+public record MentorPreviewResponse(
+        long id,
+        String nickname,
+        String profileImageUrl,
+        ExchangeStatus exchangeStatus,
+        String country,
+        String universityName,
+        int menteeCount,
+        boolean hasBadge,
+        String introduction,
+        List<ChannelResponse> channels,
+        boolean isApplied
+) {
+
+    public static MentorPreviewResponse of(Mentor mentor, SiteUser mentorUser, boolean isApplied) {
+        return new MentorPreviewResponse(
+                mentor.getId(),
+                mentorUser.getNickname(),
+                mentorUser.getProfileImageUrl(),
+                mentorUser.getExchangeStatus(),
+                "국가", // todo: 교환학생 기록이 인증되면 추가
+                "대학 이름",  // todo: 교환학생 기록이 인증되면 추가
+                mentor.getMenteeCount(),
+                mentor.isHasBadge(),
+                mentor.getIntroduction(),
+                mentor.getChannels().stream().map(ChannelResponse::from).toList(),
+                isApplied
+        );
+    }
+}

src/main/java/com/example/solidconnection/mentor/repository/ChannelRepository.java

@@ -0,0 +1,7 @@
+package com.example.solidconnection.mentor.repository;
+
+import com.example.solidconnection.mentor.domain.Channel;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ChannelRepository extends JpaRepository<Channel, Long> {
+}

src/main/java/com/example/solidconnection/mentor/repository/MentorBatchQueryRepository.java

@@ -0,0 +1,56 @@
+package com.example.solidconnection.mentor.repository;
+
+import com.example.solidconnection.common.exception.CustomException;
+import com.example.solidconnection.mentor.domain.Mentor;
+import com.example.solidconnection.mentor.domain.Mentoring;
+import com.example.solidconnection.siteuser.domain.SiteUser;
+import com.example.solidconnection.siteuser.repository.SiteUserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static com.example.solidconnection.common.exception.ErrorCode.DATA_INTEGRITY_VIOLATION;
+
+@Repository
+@RequiredArgsConstructor
+public class MentorBatchQueryRepository { // 연관관계가 설정되지 않은 엔티티들을 N+1 없이 하나의 쿼리로 조회
+
+    private final SiteUserRepository siteUserRepository;
+    private final MentoringRepository mentoringRepository;
+
+    public Map<Long, SiteUser> getMentorIdToSiteUserMap(List<Mentor> mentors) {
+        List<Long> mentorUserIds = mentors.stream().map(Mentor::getSiteUserId).toList();
+        List<SiteUser> mentorUsers = siteUserRepository.findAllById(mentorUserIds);
+        Map<Long, SiteUser> mentorUserIdToSiteUserMap = mentorUsers.stream()
+                .collect(Collectors.toMap(SiteUser::getId, Function.identity()));
+
+        return mentors.stream().collect(Collectors.toMap(
+                Mentor::getId,
+                mentor -> {
+                    SiteUser mentorUser = mentorUserIdToSiteUserMap.get(mentor.getSiteUserId());
+                    if (mentorUser == null) { // site_user.id == mentor.site_user_id 에 해당하는게 없으면 정합성 문제가 발생한 것
+                        throw new CustomException(DATA_INTEGRITY_VIOLATION, "mentor에 해당하는 siteUser 존재하지 않음");
+                    }
+                    return mentorUser;
+                }
+        ));
+    }
+
+    public Map<Long, Boolean> getMentorIdToIsApplied(List<Mentor> mentors, long currentUserId) {
+        List<Long> mentorIds = mentors.stream().map(Mentor::getId).toList();
+        List<Mentoring> appliedMentorings = mentoringRepository.findAllByMentorIdInAndMenteeId(mentorIds, currentUserId);
+        Set<Long> appliedMentorIds = appliedMentorings.stream()
+                .map(Mentoring::getMentorId)
+                .collect(Collectors.toSet());
+
+        return mentors.stream().collect(Collectors.toMap(
+                Mentor::getId,
+                mentor -> appliedMentorIds.contains(mentor.getId())
+        ));
+    }
+}