MongoDB Atlas search 사용하도록 변경

build.gradle

@@ -85,6 +85,9 @@ dependencies {
     implementation("org.opensearch.client:opensearch-rest-client:2.11.0")
     implementation("org.opensearch.client:opensearch-java:2.7.0")
     implementation("jakarta.json:jakarta.json-api")
+
+    // MongoDB AtlasSearch
+    implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
 }
 
 swaggerSources {

src/main/java/com/projectlyrics/server/domain/artist/entity/ArtistMongo.java

@@ -0,0 +1,32 @@
+package com.projectlyrics.server.domain.artist.entity;
+
+import jakarta.persistence.Id;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.springframework.data.mongodb.core.mapping.Document;
+import org.springframework.data.mongodb.core.mapping.Field;
+
+@Document(collection = "artists")
+public class ArtistMongo {
+    @Id
+    private final Long id;
+
+    @Field("search_names")
+    private final String searchNames;
+
+    private ArtistMongo(Long id, String searchNames) {
+        this.id = id;
+        this.searchNames = searchNames;
+    }
+
+    public static ArtistMongo of(Artist artist) {
+        String searchNames = Stream.of(
+                        artist.getName(),
+                        artist.getSecondName(),
+                        artist.getThirdName())
+                .filter(s -> s != null && !s.isBlank())
+                .collect(Collectors.joining(" "));
+        return new ArtistMongo(artist.getId(), searchNames);
+    }
+}
+

src/main/java/com/projectlyrics/server/domain/artist/repository/ArtistMongoCommandRepository.java

@@ -0,0 +1,15 @@
+package com.projectlyrics.server.domain.artist.repository;
+
+import com.projectlyrics.server.domain.artist.entity.ArtistMongo;
+import java.util.List;
+
+public interface ArtistMongoCommandRepository {
+    ArtistMongo save(ArtistMongo artist);
+
+    List<ArtistMongo> saveAll(List<ArtistMongo> artists);
+
+    void delete(ArtistMongo artist);
+
+    void deleteAll();
+}
+

src/main/java/com/projectlyrics/server/domain/artist/repository/ArtistMongoQueryRepository.java

@@ -0,0 +1,7 @@
+package com.projectlyrics.server.domain.artist.repository;
+
+import com.projectlyrics.server.domain.common.dto.util.IdsWithHasNext;
+
+public interface ArtistMongoQueryRepository {
+    IdsWithHasNext searchArtistIdsByName(String query, int offset, int limit);
+}

src/main/java/com/projectlyrics/server/domain/artist/repository/ArtistQueryRepository.java

@@ -19,4 +19,6 @@ public interface ArtistQueryRepository {
     List<Artist> findAll();
 
     List<Artist> findAllByIds(List<Long> artistIds);
+
+    List<Artist> findAllByIdsInListOrder(List<Long> artistIds);
 }

src/main/java/com/projectlyrics/server/domain/artist/repository/impl/AritstMongoDelegateRepository.java

@@ -0,0 +1,9 @@
+package com.projectlyrics.server.domain.artist.repository.impl;
+
+import com.projectlyrics.server.domain.artist.entity.ArtistMongo;
+import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface AritstMongoDelegateRepository extends MongoRepository<ArtistMongo, Long> {
+}

src/main/java/com/projectlyrics/server/domain/artist/repository/impl/ArtistMongoCommandRepositoryImpl.java

@@ -0,0 +1,36 @@
+package com.projectlyrics.server.domain.artist.repository.impl;
+
+import com.projectlyrics.server.domain.artist.entity.ArtistMongo;
+import com.projectlyrics.server.domain.artist.repository.ArtistMongoCommandRepository;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Repository;
+
+@Repository
+@Profile({"dev", "prod"})
+@RequiredArgsConstructor
+public class ArtistMongoCommandRepositoryImpl implements ArtistMongoCommandRepository {
+
+    private final AritstMongoDelegateRepository delegate;
+
+    @Override
+    public ArtistMongo save(ArtistMongo artist) {
+        return delegate.save(artist);
+    }
+
+    @Override
+    public List<ArtistMongo> saveAll(List<ArtistMongo> artists) {
+        return delegate.saveAll(artists);
+    }
+
+    @Override
+    public void delete(ArtistMongo artist) {
+        delegate.delete(artist);
+    }
+
+    @Override
+    public void deleteAll() {
+        delegate.deleteAll();
+    }
+}

src/main/java/com/projectlyrics/server/domain/artist/repository/impl/ArtistMongoQueryRepositoryImpl.java

@@ -0,0 +1,57 @@
+package com.projectlyrics.server.domain.artist.repository.impl;
+
+import com.projectlyrics.server.domain.artist.repository.ArtistMongoQueryRepository;
+import com.projectlyrics.server.domain.common.dto.util.IdsWithHasNext;
+import java.util.List;
+import org.bson.Document;
+import org.springframework.context.annotation.Profile;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.aggregation.AggregationOperation;
+import org.springframework.data.mongodb.core.aggregation.AggregationResults;
+import org.springframework.stereotype.Repository;
+
+@Repository
+@Profile({"dev", "prod"})
+public class ArtistMongoQueryRepositoryImpl implements ArtistMongoQueryRepository {
+
+    private final MongoTemplate mongoTemplate;
+
+    public ArtistMongoQueryRepositoryImpl(MongoTemplate mongoTemplate) {
+        this.mongoTemplate = mongoTemplate;
+    }
+
+    public IdsWithHasNext searchArtistIdsByName(String query, int offset, int limit) {
+        // edgeGram autocomplete
+        AggregationOperation searchStage = context -> new Document("$search",
+                new Document("index", "artists_search_index")
+                        .append("autocomplete", new Document()
+                                .append("query", query)
+                                .append("path", "search_names")
+                                .append("tokenOrder", "any")
+                        )
+        );
+
+        AggregationOperation projectStage = Aggregation.project("_id");
+        AggregationOperation skipStage = Aggregation.skip(offset);
+        AggregationOperation limitStage = Aggregation.limit(limit + 1);
+
+        Aggregation aggregation = Aggregation.newAggregation(searchStage, projectStage, skipStage, limitStage);
+
+        AggregationResults<Document> results =
+                mongoTemplate.aggregate(aggregation, "artists", Document.class);
+
+        List<Long> ids = results.getMappedResults().stream()
+                .map(doc -> doc.get("_id", Long.class))
+                .toList();
+
+        boolean hasNext = ids.size() > limit;
+
+        if (hasNext) {
+            ids = ids.subList(0, limit);
+        }
+
+        return new IdsWithHasNext(ids, hasNext);
+    }
+}
+

src/main/java/com/projectlyrics/server/domain/artist/repository/impl/QueryDslArtistQueryRepository.java

@@ -1,18 +1,18 @@
 package com.projectlyrics.server.domain.artist.repository.impl;
 
-import static com.projectlyrics.server.domain.artist.entity.QArtist.*;
+import static com.projectlyrics.server.domain.artist.entity.QArtist.artist;
 import static com.querydsl.core.types.dsl.Expressions.anyOf;
 
 import com.projectlyrics.server.domain.artist.entity.Artist;
 import com.projectlyrics.server.domain.artist.repository.ArtistQueryRepository;
 import com.projectlyrics.server.domain.common.util.QueryDslUtils;
 import com.querydsl.core.types.OrderSpecifier;
 import com.querydsl.core.types.dsl.CaseBuilder;
+import com.querydsl.core.types.dsl.Expressions;
+import com.querydsl.core.types.dsl.NumberExpression;
 import com.querydsl.jpa.impl.JPAQueryFactory;
-
 import java.util.List;
 import java.util.Optional;
-
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Slice;
@@ -96,4 +96,18 @@ public Slice<Artist> findAllByQuery(String query, Pageable pageable) {
 
         return new SliceImpl<>(content, pageable, QueryDslUtils.checkIfHasNext(pageable, content));
     }
+
+    @Override
+    public List<Artist> findAllByIdsInListOrder(List<Long> artistIds) {
+
+        NumberExpression<Integer> orderExpression =
+                Expressions.numberTemplate(Integer.class, "FIELD({0}, {1})", artist.id,
+                        artistIds.stream().map(String::valueOf).toArray());
+
+        return jpaQueryFactory
+                .selectFrom(artist)
+                .where(artist.id.in(artistIds))
+                .orderBy(orderExpression.asc())
+                .fetch();
+    }
 }

src/main/java/com/projectlyrics/server/domain/artist/repository/noop/NoOpArtistMongoCommandRepository.java

@@ -0,0 +1,31 @@
+package com.projectlyrics.server.domain.artist.repository.noop;
+
+import com.projectlyrics.server.domain.artist.entity.ArtistMongo;
+import com.projectlyrics.server.domain.artist.repository.ArtistMongoCommandRepository;
+import java.util.List;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Repository;
+
+@Repository
+@Profile({"!dev", "!prod"})
+public class NoOpArtistMongoCommandRepository implements ArtistMongoCommandRepository {
+
+    @Override
+    public ArtistMongo save(ArtistMongo artist) {
+        return artist;
+    }
+
+    @Override
+    public List<ArtistMongo> saveAll(List<ArtistMongo> artists) {
+        return List.of();
+    }
+
+    @Override
+    public void delete(ArtistMongo artist) {
+    }
+
+    @Override
+    public void deleteAll() {
+    }
+}
+

src/main/java/com/projectlyrics/server/domain/artist/repository/noop/NoOpArtistMongoQueryRepository.java

@@ -0,0 +1,16 @@
+package com.projectlyrics.server.domain.artist.repository.noop;
+
+import com.projectlyrics.server.domain.artist.repository.ArtistMongoQueryRepository;
+import com.projectlyrics.server.domain.common.dto.util.IdsWithHasNext;
+import java.util.List;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Repository;
+
+@Repository
+@Profile({"!dev", "!prod"})
+public class NoOpArtistMongoQueryRepository implements ArtistMongoQueryRepository {
+    @Override
+    public IdsWithHasNext searchArtistIdsByName(String query, int offset, int limit) {
+        return new IdsWithHasNext(List.of(), false);
+    }
+}

src/main/java/com/projectlyrics/server/domain/artist/service/ArtistCommandService.java

@@ -4,41 +4,63 @@
 import com.projectlyrics.server.domain.artist.dto.request.ArtistUpdateRequest;
 import com.projectlyrics.server.domain.artist.entity.Artist;
 import com.projectlyrics.server.domain.artist.entity.ArtistCreate;
+import com.projectlyrics.server.domain.artist.entity.ArtistMongo;
 import com.projectlyrics.server.domain.artist.entity.ArtistUpdate;
 import com.projectlyrics.server.domain.artist.exception.ArtistNotFoundException;
 import com.projectlyrics.server.domain.artist.repository.ArtistCommandRepository;
+import com.projectlyrics.server.domain.artist.repository.ArtistMongoCommandRepository;
 import com.projectlyrics.server.domain.artist.repository.ArtistQueryRepository;
-
 import java.time.Clock;
 import java.time.LocalDateTime;
-
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+@Slf4j
 @RequiredArgsConstructor
 @Transactional
 @Service
 public class ArtistCommandService {
 
     private final ArtistCommandRepository artistCommandRepository;
     private final ArtistQueryRepository artistQueryRepository;
+    private final ArtistMongoCommandRepository artistMongoCommandRepository;
 
     public Artist create(ArtistCreateRequest request) {
-        return artistCommandRepository.save(Artist.create(ArtistCreate.from(request)));
+        Artist artist = artistCommandRepository.save(Artist.create(ArtistCreate.from(request)));
+
+        try {
+            artistMongoCommandRepository.save(ArtistMongo.of(artist));
+        } catch (Exception e) {
+            log.warn("MongoDB create failed for artist id {}: {}", artist.getId(), e.getMessage());
+        }
+        return artist;
     }
 
     public Artist update(Long artistId, ArtistUpdateRequest request) {
         Artist artist = artistQueryRepository.findById(artistId)
                 .orElseThrow(ArtistNotFoundException::new);
 
-        return artist.update(ArtistUpdate.from(request));
+        Artist updatedArtist = artist.update(ArtistUpdate.from(request));
+
+        try {
+            artistMongoCommandRepository.save(ArtistMongo.of(updatedArtist));
+        } catch (Exception e) {
+            log.warn("MongoDB update failed for artist id {}: {}", artistId, e.getMessage());
+        }
+        return updatedArtist;
     }
 
     public void delete(Long artistId, Long deletedBy) {
         Artist artist = artistQueryRepository.findById(artistId)
                 .orElseThrow(ArtistNotFoundException::new);
 
         artist.delete(deletedBy, LocalDateTime.now(Clock.systemDefaultZone()));
+        try {
+            artistMongoCommandRepository.delete(ArtistMongo.of(artist));
+        } catch (Exception e) {
+            log.warn("MongoDB delete failed for artist id {}: {}", artist.getId(), e.getMessage());
+        }
     }
 }

src/main/java/com/projectlyrics/server/domain/artist/service/ArtistQueryService.java

@@ -3,8 +3,11 @@
 import com.projectlyrics.server.domain.artist.dto.response.ArtistGetResponse;
 import com.projectlyrics.server.domain.artist.entity.Artist;
 import com.projectlyrics.server.domain.artist.exception.ArtistNotFoundException;
+import com.projectlyrics.server.domain.artist.repository.ArtistMongoQueryRepository;
 import com.projectlyrics.server.domain.artist.repository.ArtistQueryRepository;
+import com.projectlyrics.server.domain.common.dto.util.IdsWithHasNext;
 import com.projectlyrics.server.domain.common.dto.util.OffsetBasePaginatedResponse;
+import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Slice;
@@ -17,6 +20,7 @@
 public class ArtistQueryService {
 
     private final ArtistQueryRepository artistQueryRepository;
+    private final ArtistMongoQueryRepository artistMongoQueryRepository;
 
     public Artist getArtistById(long artistId) {
         return artistQueryRepository.findById(artistId)
@@ -31,9 +35,32 @@ public OffsetBasePaginatedResponse<ArtistGetResponse> getArtistList(Pageable pag
     }
 
     public OffsetBasePaginatedResponse<ArtistGetResponse> searchArtists(String query, Pageable pageable) {
+        IdsWithHasNext idsWithHasNext = artistMongoQueryRepository.searchArtistIdsByName(
+                query,
+                (int) pageable.getOffset(),
+                pageable.getPageSize()
+        );
+
+        List<Long> artistIds = idsWithHasNext.ids();
+
+        if (artistIds.size() == 0 && pageable.getOffset() == 0) {
+            return searchArtistsWithLike(query, pageable);
+        }
+
+        List<ArtistGetResponse> artists = artistQueryRepository.findAllByIdsInListOrder(artistIds).stream()
+                .map(ArtistGetResponse::of)
+                .toList();
+
+        return OffsetBasePaginatedResponse.of(
+                pageable.getPageNumber(),
+                idsWithHasNext.hasNext(),
+                artists
+        );
+    }
+
+    public OffsetBasePaginatedResponse<ArtistGetResponse> searchArtistsWithLike(String query, Pageable pageable) {
         Slice<ArtistGetResponse> searchedArtists = artistQueryRepository.findAllByQuery(query, pageable)
                 .map(ArtistGetResponse::of);
-
         return OffsetBasePaginatedResponse.of(searchedArtists);
     }
 }