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