[Shoot-Pointer] 게시물 검색 성능 개선 - ElasticSearch 도입기(2) (검색용 쿼리 + nDCG/MRR/MAP 성능 지표 비교 55.89%🔺 정확성 향상)

GET post/_search
{
  "query": {
    "function_score": {
      "query": {
        "bool": {
          "should": [
            {
              "match": {
                "title": {
                  "query": "검색 키워드",
                  "boost": 30
                }
              }
            },
            {
              "match": {
                "content": {
                  "query": "검색 키워드",
                  "boost": 10
                }
              }
            }
          ]
        }
      }
    }
  },
  "sort": [
    { "_score":  { "order": "desc" } },
    { "likeCnt": { "order": "desc" } },
    { "postId":  { "order": "desc" } }
  ],
  "size": 10,
  "search_after": [마지막 게시물 score, 마지막 게시물 like_cnt, 마지막 게시물 post_id]
}

Criteria criteria=Criteria.where("title").matches(search).boost(TITLE_WEIGHT)
    .or(Criteria.where("content").matches(search).boost(CONTENT_WEIGHT));
CriteriaQuery booleanQuery=new CriteriaQuery(criteria);

NativeQueryBuilder builder = NativeQuery.builder()
    .withQuery(booleanQuery)
    .withSort(SortOptions.of(s -> s.score(sc -> sc.order(SortOrder.Desc))))
    .withSort(SortOptions.of(s -> s.field(f -> f.field("likeCnt").order(SortOrder.Desc))))
    .withSort(SortOptions.of(s -> s.field(f -> f.field("postId").order(SortOrder.Desc))))
    .withMaxResults(size);

if (sort != null) {
	builder.withSearchAfter(sortToList(sort)); 
} 
NativeQuery query = builder.build(); 
return operations.search(query, PostDocument.class);

public record PostSort(
        @NotNull float _score,
        @NotNull Long likeCnt,
        @NotNull Long lastPostId
) {
}

@Repository
@Profile("!dev")
@RequiredArgsConstructor
public class PostCustomElasticSearchImpl implements PostCustomElasticSearch {
    private final ElasticsearchOperations operations;
    //제목 가중치
    private final float TITLE_WEIGHT = 30f;
    //내용 가중치
    private final float CONTENT_WEIGHT = 10f;

    @Override
    public SearchHits<PostDocument> search(String search, int size, PostSort sort) {
        /**
         * 조건
         * 1. 제목 search 포함 : 가중치 +30
         * 2. 내용 search 포함 : 가중치 +10
         * 3. Elastic Search score 내림차순
         * 4. 점수 동일 시, like_cnt 내림차순
         * 5. score, like_cnt 동일 시 post_id 내림차순
         */

        //Criteria 생성하여 title 필드, content 필드에서 부분 일치 조건 + 가중치 지정
        Criteria criteria=Criteria.where("title").matches(search).boost(TITLE_WEIGHT)
                .or(Criteria.where("content").matches(search).boost(CONTENT_WEIGHT));
        CriteriaQuery booleanQuery=new CriteriaQuery(criteria);

        NativeQueryBuilder builder = NativeQuery.builder()
                .withQuery(booleanQuery)
                // sort: _score desc, likeCnt desc, postId desc
                .withSort(SortOptions.of(s -> s.score(sc -> sc.order(SortOrder.Desc))))
                .withSort(SortOptions.of(s -> s.field(f -> f.field("likeCnt").order(SortOrder.Desc))))
                .withSort(SortOptions.of(s -> s.field(f -> f.field("postId").order(SortOrder.Desc))))
                .withMaxResults(size);

        // search_after
        if (sort != null) {
            builder.withSearchAfter(sortToList(sort));
        }

        NativeQuery query = builder.build();
        return operations.search(query, PostDocument.class);
    }

    /**
     * search_after용 리스트 반환
     */
    private List<Object> sortToList(PostSort sort) {
        return List.of(sort._score(), sort.likeCnt(), sort.lastPostId());
    }
}

@Transactional(readOnly = true)
@Override
public List<PostSearchHit> getPostByTitleOrContentByElasticSearch(String search, int size, PostSort sort) {
    SearchHits<PostDocument> documentList=postElasticSearchRepository.search(search,size,sort);

   /**
   * 조회된 Document가 없는 경우 빈 리스트 반환
   */
   if(documentList==null) return Collections.emptyList();

   List<PostSearchHit> responses=new ArrayList<>();
   for (SearchHit<PostDocument> hit:documentList){
       PostDocument doc=hit.getContent();
       float _score=hit.getScore();
       //PostResponse 값 , _score 값 저장
       responses.add(new PostSearchHit(doc,_score));
   }
   return responses;
}

public record PostSearchHit(
        PostDocument doc,
        float _score
) {
}

@Builder
public static PostListResponse withSort(Long lastPostId,List<PostResponse> postList,PostSort sort){
  return new PostListResponse(lastPostId,postList,sort);
}

@Transactional(readOnly = true)
public PostListResponse getPostByPostTitleOrPostContentByElasticSearch(String search, int size, PostSort sort) {
    // 0. ElasticSearch가 사용 가능한 경우에만 실행
    if (postElasticSearchHelper == null) {
        // 일반 검색
        return getPostEntitiesByPostTitleOrPostContent(search, sort.lastPostId(), size);
    }

    // 1. 게시물 정렬 조건 + 검색어 게시물 검색 , _score 조회
    List<PostSearchHit> responses = postElasticSearchHelper.getPostByTitleOrContentByElasticSearch(search, size, sort);

    // 2. PostListResponse 형태로 반환 - 마지막 게시물의 정렬 값 보내기
    if (responses.isEmpty()) {
        // 결과값이 없는 경우 - 이전에 보낸 정렬값(기본값) 그대로 전송
        return PostListResponse.withSort(sort.lastPostId(), Collections.emptyList(), sort);
    }

    // 결과값이 존재하는 경우 - 마지막 게시물의 정렬 기준 전송
    int last = responses.size() - 1;
    PostDocument lastResponse = responses.get(last).doc();

    PostSort newSort = new PostSort(
        responses.get(last)._score(),
        lastResponse.getLikeCnt(),
        lastResponse.getPostId()
    );

    // 3. List<PostDocument> -> List<PostResponse> 형태로 변환
    List<PostResponse> postResponses = responses.stream()
        .map(hit -> postMapper.documentToEResponse(hit.doc()))
        .toList();

    return PostListResponse.withSort(lastResponse.getPostId(), postResponses, newSort);
}

@GetMapping("/list-elastic")
public ResponseEntity<ApiResponse<PostListResponse>> searchElastic(@RequestParam(required = false) String search,
                                                                       @RequestParam(required = false,defaultValue = "922337203685477580") Long postId,
                                                                       @RequestParam(required = false,defaultValue = "10")int size,
                                                                       @RequestParam(required = false,defaultValue = "922337203685477580")float _score,
                                                                       @RequestParam(required = false,defaultValue = "922337203685477580")Long likeCnt){
   /**
   * 검색어가 없는 경우 -> 최신 게시물 리스트 조회
   */
   if(search.isBlank()){
      return ResponseEntity.ok(ApiResponse.ok(postQueryService.multiRead(postId,size,"latest")));
   }
   PostSort sort=new PostSort(_score,likeCnt,postId);
   return ResponseEntity.ok(ApiResponse.ok(postQueryService.searchByElastic(search,size,sort)));
}

  {
    "id": 84,
    "title": "하나투어, 국내여행",
    "content": "NEW #해시태그 검색이 가능해졌어요! 인기검색어 마이메뉴는 회원 전용 메뉴 입니다. 최근 본 상품이 없습니다.",
    "keyword": "국내 여행",
    "url": "https://www.hanatour.com/package/domestic",
    "likeCnt": 889
  }

{
  "날씨": {
    "1": 7.016,
    "2": 7.585,
    "3": 2.166,
    "4": 6.254,
    "5": 6.125,
    "6": 6.245,
    "7": 6.076,
    "8": 2.286,
    "9": 6.044,
    "10": 2.058
  },
  ...
 }