Feat/#498 Artist 엔티티 추가, 가수 검색 기능 구현

backend/src/main/java/shook/shook/globalexception/ErrorCode.java

@@ -53,6 +53,12 @@ public enum ErrorCode {
     CAN_NOT_READ_SONG_DATA_FILE(3011, "노래 데이터 파일을 읽을 수 없습니다."),
     SONG_ALREADY_EXIST(3012, "등록하려는 노래가 이미 존재합니다."),
     WRONG_GENRE_TYPE(3013, "잘못된 장르 타입입니다."),
+    EMPTY_ARTIST_PROFILE_URL(3014, "가수 프로필 이미지는 비어있을 수 없습니다."),
+    TOO_LONG_ARTIST_PROFILE_URL(3015, "가수 프로필 이미지URL은 65,356자를 넘길 수 없습니다."),
+    EMPTY_ARTIST_SYNONYM(3016, "가수 동의어는 비어있을 수 없습니다."),
+    TOO_LONG_ARTIST_SYNONYM(3017, "가수 동의어는 255자를 넘길 수 없습니다."),
+    ARTIST_NOT_EXIST(3018, "존재하지 않는 가수입니다."),
+
 
     // 4000: 투표
     VOTING_PART_START_LESS_THAN_ZERO(4001, "파트의 시작 초는 0보다 작을 수 없습니다."),

backend/src/main/java/shook/shook/globalexception/GlobalExceptionHandler.java

@@ -14,6 +14,7 @@
 import shook.shook.auth.exception.TokenException;
 import shook.shook.member.exception.MemberException;
 import shook.shook.part.exception.PartException;
+import shook.shook.song.exception.ArtistException;
 import shook.shook.song.exception.SongException;
 import shook.shook.song.exception.killingpart.KillingPartCommentException;
 import shook.shook.song.exception.killingpart.KillingPartException;
@@ -55,7 +56,8 @@ public ResponseEntity<ErrorResponse> handleTokenException(final CustomException
         MemberException.class,
         VotingSongException.class,
         VotingSongPartException.PartNotExistException.class,
-        PartException.class
+        PartException.class,
+        ArtistException.class
     })
     public ResponseEntity<ErrorResponse> handleGlobalBadRequestException(final CustomException e) {
         log.error(e.getErrorInfoLog());

backend/src/main/java/shook/shook/song/application/ArtistSearchService.java

@@ -0,0 +1,119 @@
+package shook.shook.song.application;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shook.shook.song.application.dto.ArtistResponse;
+import shook.shook.song.application.dto.ArtistWithSongSearchResponse;
+import shook.shook.song.domain.Artist;
+import shook.shook.song.domain.InMemoryArtistSynonyms;
+import shook.shook.song.domain.Song;
+import shook.shook.song.domain.repository.ArtistRepository;
+import shook.shook.song.domain.repository.SongRepository;
+import shook.shook.song.domain.repository.dto.SongTotalLikeCountDto;
+import shook.shook.song.exception.ArtistException;
+
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+@Service
+@Slf4j
+public class ArtistSearchService {
+
+    private static final int TOP_SONG_COUNT_OF_ARTIST = 3;
+
+    private final InMemoryArtistSynonyms inMemoryArtistSynonyms;
+    private final ArtistRepository artistRepository;
+    private final SongRepository songRepository;
+
+    public List<ArtistResponse> searchArtistsByKeyword(final String keyword) {
+        final List<Artist> artists = findArtistsStartsWithKeyword(keyword);
+
+        return artists.stream()
+            .map(ArtistResponse::from)
+            .toList();
+    }
+
+    private List<Artist> findArtistsStartsWithKeyword(final String keyword) {
+        final List<Artist> artistsFoundByName = inMemoryArtistSynonyms.findAllArtistsNameStartsWith(
+            keyword);
+        final List<Artist> artistsFoundBySynonym = inMemoryArtistSynonyms.findAllArtistsHavingSynonymStartsWith(
+            keyword);
+
+        return removeDuplicateArtistResultAndSortByName(artistsFoundByName, artistsFoundBySynonym);
+    }
+
+    private List<Artist> removeDuplicateArtistResultAndSortByName(final List<Artist> firstResult,
+                                                                  final List<Artist> secondResult) {
+        return Stream.concat(firstResult.stream(), secondResult.stream())
+            .distinct()
+            .sorted(Comparator.comparing(Artist::getArtistName))
+            .toList();
+    }
+
+    public List<ArtistWithSongSearchResponse> searchArtistsAndTopSongsByKeyword(
+        final String keyword) {
+        final List<Artist> artists = findArtistsStartsOrEndsWithKeyword(keyword);
+
+        return artists.stream()
+            .map(artist -> ArtistWithSongSearchResponse.of(
+                artist,
+                getSongsOfArtistSortedByLikeCount(artist).size(),
+                getTopSongsOfArtist(artist))
+            )
+            .toList();
+    }
+
+    private List<Artist> findArtistsStartsOrEndsWithKeyword(final String keyword) {
+        final List<Artist> artistsFoundByName = inMemoryArtistSynonyms.findAllArtistsNameStartsOrEndsWith(
+            keyword);
+        final List<Artist> artistsFoundBySynonym = inMemoryArtistSynonyms.findAllArtistsHavingSynonymStartsOrEndsWith(
+            keyword);
+
+        return removeDuplicateArtistResultAndSortByName(artistsFoundByName, artistsFoundBySynonym);
+    }
+
+    private List<Song> getTopSongsOfArtist(final Artist artist) {
+        final List<Song> songs = getSongsOfArtistSortedByLikeCount(artist);
+        if (songs.size() < TOP_SONG_COUNT_OF_ARTIST) {
+            return songs;
+        }
+
+        return songs.subList(0, TOP_SONG_COUNT_OF_ARTIST);
+    }
+
+    private List<Song> getSongsOfArtistSortedByLikeCount(final Artist artist) {
+        final List<Song> all = songRepository.findAll();
+        log.info("all song: {}", all);
+        final List<SongTotalLikeCountDto> songsWithTotalLikeCount = songRepository.findAllSongsWithTotalLikeCountByArtist(
+            artist);
+
+        log.info("found song of artist: {}", songsWithTotalLikeCount);
+        return songsWithTotalLikeCount.stream()
+            .sorted(Comparator.comparing(SongTotalLikeCountDto::getTotalLikeCount,
+                    Comparator.reverseOrder())
+                .thenComparing(songWithTotalLikeCount -> songWithTotalLikeCount.getSong().getId(),
+                    Comparator.reverseOrder())
+            )
+            .map(SongTotalLikeCountDto::getSong)
+            .toList();
+    }
+
+    public ArtistWithSongSearchResponse searchAllSongsByArtist(final long artistId) {
+        final Artist artist = findArtistById(artistId);
+        final List<Song> songs = getSongsOfArtistSortedByLikeCount(artist);
+
+        return ArtistWithSongSearchResponse.of(artist, songs.size(), songs);
+    }
+
+    private Artist findArtistById(final long artistId) {
+        return artistRepository.findById(artistId)
+            .orElseThrow(() -> new ArtistException.NotExistException(
+                Map.of("ArtistId", String.valueOf(artistId))
+            ));
+    }
+}

backend/src/main/java/shook/shook/song/application/SongDataExcelReader.java

@@ -16,8 +16,11 @@
 import org.springframework.stereotype.Component;
 import org.springframework.web.multipart.MultipartFile;
 import shook.shook.part.domain.PartLength;
+import shook.shook.song.domain.Artist;
+import shook.shook.song.domain.ArtistName;
 import shook.shook.song.domain.Genre;
 import shook.shook.song.domain.KillingParts;
+import shook.shook.song.domain.ProfileImageUrl;
 import shook.shook.song.domain.Song;
 import shook.shook.song.domain.killingpart.KillingPart;
 import shook.shook.song.exception.SongDataFileReadException;
@@ -91,7 +94,9 @@ private Optional<Song> parseToSong(final Row currentRow) {
         final Optional<KillingParts> killingParts = getKillingParts(cellIterator);
 
         return killingParts.map(
-            parts -> new Song(title, videoId, albumCoverUrl, singer, length, Genre.from(genre),
+            parts -> new Song(title, videoId, albumCoverUrl,
+                new Artist(new ProfileImageUrl("image"), new ArtistName("name")), length,
+                Genre.from(genre),
                 parts));
     }
 

backend/src/main/java/shook/shook/song/application/SongService.java

@@ -18,11 +18,10 @@
 import shook.shook.song.domain.Genre;
 import shook.shook.song.domain.InMemorySongs;
 import shook.shook.song.domain.Song;
-import shook.shook.song.domain.SongTitle;
 import shook.shook.song.domain.killingpart.repository.KillingPartLikeRepository;
 import shook.shook.song.domain.killingpart.repository.KillingPartRepository;
+import shook.shook.song.domain.repository.ArtistRepository;
 import shook.shook.song.domain.repository.SongRepository;
-import shook.shook.song.exception.SongException;
 
 @RequiredArgsConstructor
 @Transactional(readOnly = true)
@@ -38,6 +37,7 @@ public class SongService {
     private final KillingPartLikeRepository killingPartLikeRepository;
     private final MemberRepository memberRepository;
     private final InMemorySongs inMemorySongs;
+    private final ArtistRepository artistRepository;
     private final SongDataExcelReader songDataExcelReader;
 
     @Transactional
@@ -48,9 +48,7 @@ public Long register(final SongWithKillingPartsRegisterRequest request) {
     }
 
     private Song saveSong(final Song song) {
-        if (songRepository.existsSongByTitle(new SongTitle(song.getTitle()))) {
-            throw new SongException.SongAlreadyExistException(Map.of("Song-Name", song.getTitle()));
-        }
+        artistRepository.save(song.getArtist());
         final Song savedSong = songRepository.save(song);
         killingPartRepository.saveAll(song.getKillingParts());
         return savedSong;
@@ -68,8 +66,10 @@ public SongSwipeResponse findSongByIdForFirstSwipe(
     ) {
         final Song currentSong = inMemorySongs.getSongById(songId);
 
-        final List<Song> beforeSongs = inMemorySongs.getPrevLikedSongs(currentSong, BEFORE_SONGS_COUNT);
-        final List<Song> afterSongs = inMemorySongs.getNextLikedSongs(currentSong, AFTER_SONGS_COUNT);
+        final List<Song> beforeSongs = inMemorySongs.getPrevLikedSongs(currentSong,
+            BEFORE_SONGS_COUNT);
+        final List<Song> afterSongs = inMemorySongs.getNextLikedSongs(currentSong,
+            AFTER_SONGS_COUNT);
 
         return convertToSongSwipeResponse(memberInfo, currentSong, beforeSongs, afterSongs);
     }
@@ -87,7 +87,8 @@ private SongSwipeResponse convertToSongSwipeResponse(
         }
 
         final Member member = findMemberById(memberInfo.getMemberId());
-        final List<Long> killingPartIds = killingPartLikeRepository.findLikedKillingPartIdsByMember(member);
+        final List<Long> killingPartIds = killingPartLikeRepository.findLikedKillingPartIdsByMember(
+            member);
         return SongSwipeResponse.of(currentSong, beforeSongs, afterSongs, killingPartIds);
     }
 
@@ -105,7 +106,8 @@ public List<SongResponse> findSongByIdForBeforeSwipe(
         final MemberInfo memberInfo
     ) {
         final Song currentSong = inMemorySongs.getSongById(songId);
-        final List<Song> beforeSongs = inMemorySongs.getPrevLikedSongs(currentSong, BEFORE_SONGS_COUNT);
+        final List<Song> beforeSongs = inMemorySongs.getPrevLikedSongs(currentSong,
+            BEFORE_SONGS_COUNT);
 
         return convertToSongResponses(memberInfo, beforeSongs);
     }
@@ -136,7 +138,8 @@ public List<SongResponse> findSongByIdForAfterSwipe(
         final MemberInfo memberInfo
     ) {
         final Song currentSong = inMemorySongs.getSongById(songId);
-        final List<Song> afterSongs = inMemorySongs.getNextLikedSongs(currentSong, AFTER_SONGS_COUNT);
+        final List<Song> afterSongs = inMemorySongs.getNextLikedSongs(currentSong,
+            AFTER_SONGS_COUNT);
 
         return convertToSongResponses(memberInfo, afterSongs);
     }
@@ -163,7 +166,8 @@ public SongSwipeResponse findSongsByGenreForSwipe(
         final Song currentSong = inMemorySongs.getSongById(songId);
         final List<Song> prevSongs = inMemorySongs.getPrevLikedSongByGenre(currentSong, genre,
             BEFORE_SONGS_COUNT);
-        final List<Song> nextSongs = inMemorySongs.getNextLikedSongByGenre(currentSong, genre, AFTER_SONGS_COUNT);
+        final List<Song> nextSongs = inMemorySongs.getNextLikedSongByGenre(currentSong, genre,
+            AFTER_SONGS_COUNT);
 
         final Authority authority = memberInfo.getAuthority();
 
@@ -197,7 +201,8 @@ public List<SongResponse> findNextSongsByGenre(
     ) {
         final Genre genre = Genre.findByName(genreName);
         final Song currentSong = inMemorySongs.getSongById(songId);
-        final List<Song> nextSongs = inMemorySongs.getNextLikedSongByGenre(currentSong, genre, AFTER_SONGS_COUNT);
+        final List<Song> nextSongs = inMemorySongs.getNextLikedSongByGenre(currentSong, genre,
+            AFTER_SONGS_COUNT);
 
         return convertToSongResponses(memberInfo, nextSongs);
     }

backend/src/main/java/shook/shook/song/application/dto/ArtistResponse.java

@@ -0,0 +1,30 @@
+package shook.shook.song.application.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import shook.shook.song.domain.Artist;
+
+@Schema(description = "아티스트를 통한 아티스트, 해당 아티스트의 노래 검색 결과")
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@Getter
+public class ArtistResponse {
+
+    @Schema(description = "아티스트 id", example = "1")
+    private final Long id;
+
+    @Schema(description = "가수 이름", example = "가수")
+    private final String singer;
+
+    @Schema(description = "가수 대표 이미지 url", example = "https://image.com/artist-profile.jpg")
+    private final String profileImageUrl;
+
+    public static ArtistResponse from(final Artist artist) {
+        return new ArtistResponse(
+            artist.getId(),
+            artist.getArtistName(),
+            artist.getProfileImageUrl()
+        );
+    }
+}

backend/src/main/java/shook/shook/song/application/dto/ArtistWithSongSearchResponse.java

@@ -0,0 +1,47 @@
+package shook.shook.song.application.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import java.util.List;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import shook.shook.song.domain.Artist;
+import shook.shook.song.domain.Song;
+
+@Schema(description = "아티스트를 통한 아티스트, 해당 아티스트의 노래 검색 결과")
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@Getter
+public class ArtistWithSongSearchResponse {
+
+    @Schema(description = "아티스트 id", example = "1")
+    private final Long id;
+
+    @Schema(description = "가수 이름", example = "가수")
+    private final String singer;
+
+    @Schema(description = "가수 대표 이미지 url", example = "https://image.com/artist-profile.jpg")
+    private final String profileImageUrl;
+
+    @Schema(description = "가수 노래 총 개수", example = "10")
+    private final int totalSongCount;
+
+    @Schema(description = "아티스트의 노래 목록")
+    private final List<SongSearchResponse> songs;
+
+    public static ArtistWithSongSearchResponse of(final Artist artist, final int totalSongCount,
+                                                  final List<Song> songs) {
+        return new ArtistWithSongSearchResponse(
+            artist.getId(),
+            artist.getArtistName(),
+            artist.getProfileImageUrl(),
+            totalSongCount,
+            convertToSongSearchResponse(songs)
+        );
+    }
+
+    private static List<SongSearchResponse> convertToSongSearchResponse(final List<Song> songs) {
+        return songs.stream()
+            .map(SongSearchResponse::from)
+            .toList();
+    }
+}

backend/src/main/java/shook/shook/song/application/dto/LikedKillingPartResponse.java

@@ -37,7 +37,7 @@ public static LikedKillingPartResponse of(final Song song, final KillingPart kil
         return new LikedKillingPartResponse(
             song.getId(),
             song.getTitle(),
-            song.getSinger(),
+            song.getArtistName(),
             song.getAlbumCoverUrl(),
             killingPart.getId(),
             killingPart.getStartSecond(),

backend/src/main/java/shook/shook/song/application/dto/SongResponse.java

@@ -43,7 +43,7 @@ public static SongResponse of(final Song song, final List<Long> likedKillingPart
         return new SongResponse(
             song.getId(),
             song.getTitle(),
-            song.getSinger(),
+            song.getArtistName(),
             song.getLength(),
             song.getVideoId(),
             song.getAlbumCoverUrl(),

backend/src/main/java/shook/shook/song/application/dto/SongSearchResponse.java

@@ -0,0 +1,30 @@
+package shook.shook.song.application.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import shook.shook.song.domain.Song;
+
+@Schema(description = "검색 결과 (가수, 가수의 노래) 응답")
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@Getter
+public class SongSearchResponse {
+
+    @Schema(description = "노래 id", example = "1")
+    private final Long id;
+
+    @Schema(description = "노래 제목", example = "제목")
+    private final String title;
+
+    @Schema(description = "노래 앨범 커버 이미지 url", example = "https://image.com/album-cover.jpg")
+    private final String albumCoverUrl;
+
+    @Schema(description = "노래 비디오 길이", example = "247")
+    private final int videoLength;
+
+    public static SongSearchResponse from(final Song song) {
+        return new SongSearchResponse(song.getId(), song.getTitle(), song.getAlbumCoverUrl(),
+            song.getLength());
+    }
+}