feat: 멘토 조회 기능 구현

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())
+        ));
+    }
+}

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

@@ -1,13 +1,17 @@
 package com.example.solidconnection.mentor.repository;
 
 import com.example.solidconnection.mentor.domain.Mentor;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
 import org.springframework.data.jpa.repository.JpaRepository;
 
 import java.util.Optional;
 
 public interface MentorRepository extends JpaRepository<Mentor, Long> {
 
+    boolean existsBySiteUserId(long siteUserId);
+
     Optional<Mentor> findBySiteUserId(long siteUserId);
 
-    boolean existsBySiteUserId(long siteUserId);
+    Slice<Mentor> findAllBy(Pageable pageable);
 }

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

@@ -2,12 +2,22 @@
 
 import com.example.solidconnection.mentor.domain.Mentoring;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 
 import java.util.List;
 
 public interface MentoringRepository extends JpaRepository<Mentoring, Long> {
 
+    int countByMentorIdAndCheckedAtIsNull(long mentorId);
+
+    boolean existsByMentorIdAndMenteeId(long mentorId, long menteeId);
+
     List<Mentoring> findAllByMentorId(long mentorId);
 
-    int countByMentorIdAndCheckedAtIsNull(long mentorId);
+    @Query("""
+            SELECT m FROM Mentoring m
+            WHERE m.mentorId IN :mentorIds AND m.menteeId = :menteeId
+            """)
+    List<Mentoring> findAllByMentorIdInAndMenteeId(@Param("mentorIds") List<Long> mentorIds, @Param("menteeId") long menteeId);
 }

src/main/java/com/example/solidconnection/mentor/service/MentorQueryService.java

@@ -0,0 +1,67 @@
+package com.example.solidconnection.mentor.service;
+
+import com.example.solidconnection.common.dto.SliceResponse;
+import com.example.solidconnection.common.exception.CustomException;
+import com.example.solidconnection.mentor.domain.Mentor;
+import com.example.solidconnection.mentor.dto.MentorDetailResponse;
+import com.example.solidconnection.mentor.dto.MentorPreviewResponse;
+import com.example.solidconnection.mentor.repository.MentorBatchQueryRepository;
+import com.example.solidconnection.mentor.repository.MentorRepository;
+import com.example.solidconnection.mentor.repository.MentoringRepository;
+import com.example.solidconnection.siteuser.domain.SiteUser;
+import com.example.solidconnection.siteuser.repository.SiteUserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import static com.example.solidconnection.common.exception.ErrorCode.MENTOR_NOT_FOUND;
+
+@RequiredArgsConstructor
+@Service
+public class MentorQueryService {
+
+    private final MentorRepository mentorRepository;
+    private final MentoringRepository mentoringRepository;
+    private final SiteUserRepository siteUserRepository;
+    private final MentorBatchQueryRepository mentorBatchQueryRepository;
+
+    @Transactional(readOnly = true)
+    public MentorDetailResponse getMentorDetails(long mentorId, SiteUser currentUser) {
+        Mentor mentor = mentorRepository.findById(mentorId)
+                .orElseThrow(() -> new CustomException(MENTOR_NOT_FOUND));
+        SiteUser mentorUser = siteUserRepository.findById(mentor.getSiteUserId())
+                .orElseThrow(() -> new CustomException(MENTOR_NOT_FOUND));
+        boolean isApplied = mentoringRepository.existsByMentorIdAndMenteeId(mentorId, currentUser.getId());
+
+        return MentorDetailResponse.of(mentor, mentorUser, isApplied);
+    }
+
+    @Transactional(readOnly = true)
+    public SliceResponse<MentorPreviewResponse> getMentorPreviews(String region, SiteUser siteUser, Pageable pageable) { // todo: 멘토의 '인증' 작업 후 region 필터링 추가
+        Slice<Mentor> mentorSlice = mentorRepository.findAllBy(pageable);
+        List<Mentor> mentors = mentorSlice.toList();
+        List<MentorPreviewResponse> content = getMentorPreviewResponses(mentors, siteUser);
+
+        return SliceResponse.of(content, mentorSlice);
+    }
+
+    private List<MentorPreviewResponse> getMentorPreviewResponses(List<Mentor> mentors, SiteUser siteUser) {
+        Map<Long, SiteUser> mentorIdToSiteUser = mentorBatchQueryRepository.getMentorIdToSiteUserMap(mentors);
+        Map<Long, Boolean> mentorIdToIsApplied = mentorBatchQueryRepository.getMentorIdToIsApplied(mentors, siteUser.getId());
+
+        List<MentorPreviewResponse> mentorPreviews = new ArrayList<>();
+        for (Mentor mentor : mentors) {
+            SiteUser mentorUser = mentorIdToSiteUser.get(mentor.getId());
+            boolean isApplied = mentorIdToIsApplied.get(mentor.getId());
+            MentorPreviewResponse response = MentorPreviewResponse.of(mentor, mentorUser, isApplied);
+            mentorPreviews.add(response);
+        }
+        return mentorPreviews;
+    }
+}