[Spring] Elasticsearch + Spring Boot로 검색 기능 구현

Elasticsearch란?

Elasticsearch는 대용량 데이터에서 빠르고 효율적인 검색을 수행할 수 있도록 설계된 오픈 소스 분산 검색 엔진입니다. JSON 문서 기반으로 데이터를 저장하고 검색하며, 역색인(Inverted Index) 방식을 사용해 빠른 검색을 지원합니다.

 

Elasticsearch의 주요 특징

• 전문 검색(Full Text Search)
  • 형태소 분석을 통해 텍스트 검색을 최적화하고 동의어 및 유의어 검색을 지원합니다.
• 실시간 검색
  • 대량의 데이터를 빠르게 처리 및 검색할 수 있습니다.
• 분산 시스템
  • 여러 개의 노드로 클러스터를 구성하여 확장성을 제공합니다.
• RESTful API 지원
  • GET, POST, DELETE 등의 REST API를 활용하여 데이터를 손쉽게 CRUD(생성, 조회, 수정, 삭제)할 수 있습니다.
• 역색인 구조(Inverted Index)
  • 색인된 데이터를 활용하여 특정 단어와 관련된 문서를 빠르게 검색할 수 있습니다.
• 스키마리스(Schema-less)
  • 미리 정의된 스키마 없이도 데이터를 자동으로 분석하여 필드를 생성하고 저장할 수 있습니다.
• 강력한 데이터 분석 기능
  • 집계(Aggregation), 동의어 처리, 자동 완성 등의 기능을 지원하여 정교한 데이터 분석이 가능합니다.

 

Elasticsearch의 활용 사례

• 검색 엔진 (웹사이트, 전자상거래, 블로그 등)
• 로그 및 모니터링 시스템 (ELK Stack: Elasticsearch + Logstash + Kibana)
• 데이터 분석 및 시각화
• 추천 시스템

 

RDBMS와의 차이점

기존 RDBMS 기반 애플리케이션에서는 텍스트 검색이 어렵습니다. 일반적으로 LIKE 검색에 의존해야 하지만, LIKE 검색은 동의어나 유의어를 지원하지 않아 한계가 있습니다. 이러한 문제를 해결하기 위해 Elasticsearch(ES) 를 활용하면 보다 강력한 텍스트 검색 기능을 제공할 수 있습니다.

Elasticsearch는 역색인(Inverted Index) 구조 를 활용하여 빠른 검색을 지원하며, 형태소 분석 을 통해 검색 성능을 극대화할 수 있습니다. 이를 통해 보다 정확하고 유연한 검색 기능 을 제공합니다.

또한, Elasticsearch는 단순한 텍스트 데이터를 Tokenizer, Filter, Analyzer 등을 활용하여 저장하며, 형태소 분석 방식은 _analyze API를 통해 확인할 수 있습니다. 이 과정에서 문장은 원본 그대로 저장됨과 동시에, 텍스트 타입은 역색인(Inverted Index)이라는 특별한 자료구조에 저장됩니다.

 

역색인(Inverted Index) 예시

Elasticsearch는 검색을 빠르게 수행하기 위해 역색인 방식을 사용합니다. 역색인은 특정한 토큰(단어)이 어떤 문서와 연관되어 있는지를 저장하는 자료구조입니다. 예를 들어, 아래와 같은 형태로 저장됩니다.

Term	Id
potato	1,2
wedge	1
better	2

이러한 구조 덕분에 검색 시 빠르게 결과를 조회하고, 집계하여 반환할 수 있습니다.

 

---

 

ElasticSearch + SpringBoot 세팅

 

gradle 의존성 추가

    implementation 'org.springframework.boot:spring-boot-starter-data-search'

 

 

ElasticSearchConfig

package com.iruyeon.v1.config.common;

import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.client.ClientConfiguration;
import org.springframework.data.elasticsearch.client.elc.ElasticsearchConfiguration;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;

@Configuration
@EnableElasticsearchRepositories(basePackages = "org.springframework.data.elasticsearch.repository")
public class ElasticSearchConfig extends ElasticsearchConfiguration {

    @Override
    public ClientConfiguration clientConfiguration() {
        return ClientConfiguration.builder()
                .connectedTo("localhost:9200")
                .build();
    }
}

 

ClientDocumentRepository

package com.iruyeon.v1.domain.search.repository;

import com.iruyeon.v1.domain.search.entity.ClientDocument;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

public interface ClientDocumentRepository extends ElasticsearchRepository<ClientDocument, String> {
}

 

 

ClientDocument

package com.iruyeon.v1.domain.search.entity;

import com.iruyeon.v1.domain.client.entity.Client;
import com.iruyeon.v1.domain.client.entity.Family;
import com.iruyeon.v1.domain.client.enums.MaritalStatus;
import com.iruyeon.v1.domain.common.enums.Status;
import com.iruyeon.v1.domain.member.enums.Gender;
import jakarta.persistence.Id;
import lombok.AccessLevel;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

import java.util.List;
import java.util.Set;

@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Document(indexName = "client")
public class ClientDocument {

    @Id
    private String id;

    private String name;
    private String phoneNumber;
    private String address;
    private int birthYear;
    private MaritalStatus maritalStatus;
    private String highSchool;
    private String university;
    private String eduDegree;
    private String major;
    private String property;
    private String religion;
    private String currentJob;
    private String previousJob;
    private String jobDetail;
    private String info;
    private String homeTown;
    private Gender gender;
    private Status status;
    private int ageGapLower;
    private int ageGapUpper;
    private String interest;
    private String idealType;
    private String personality;

    @Field(name = "has_child", type=FieldType.Boolean)
    private Boolean hasChild;

    @Field(type = FieldType.Keyword)
    private List<String> images;

    @Field(type = FieldType.Nested)
    private Set<Family> family;

    @Builder
    public ClientDocument(String id, String name, String phoneNumber, String address, int birthYear, String highSchool,
                  String university, String major, String property, String religion, String currentJob,
                  String previousJob, String jobDetail, String info, String homeTown, Gender gender, Status status,
                  int ageGapLower, int ageGapUpper, String interest, Set<Family> family, MaritalStatus maritalStatus,
                  String idealType, String personality, boolean hasChild, List<String> images, String eduDegree) {
        this.id = id;
        this.name = name;
        this.phoneNumber = phoneNumber;
        this.address = address;
        this.birthYear = birthYear;
        this.maritalStatus = maritalStatus;
        this.highSchool = highSchool;
        this.university = university;
        this.major = major;
        this.property = property;
        this.religion = religion;
        this.currentJob = currentJob;
        this.previousJob = previousJob;
        this.jobDetail = jobDetail;
        this.info = info;
        this.homeTown = homeTown;
        this.gender = gender;
        this.status = status;
        this.ageGapLower = ageGapLower;
        this.ageGapUpper = ageGapUpper;
        this.interest = interest;
        this.idealType = idealType;
        this.personality = personality;
        this.hasChild = hasChild;
        this.images = images;
        this.family = family;
        this.eduDegree = eduDegree;
    }

    public static ClientDocument entityToDocument(Client client) {
        return ClientDocument.builder()
                .name(client.getName())
                .phoneNumber(client.getPhoneNumber())
                .address(client.getAddress())
                .birthYear(client.getBirthYear())
                .highSchool(client.getHighSchool())
                .university(client.getUniversity())
                .major(client.getMajor())
                .property(client.getProperty())
                .currentJob(client.getCurrentJob())
                .previousJob(client.getPreviousJob())
                .maritalStatus(client.getMaritalStatus())
                .jobDetail(client.getJobDetail())
                .info(client.getInfo())
                .homeTown(client.getHomeTown())
                .gender(client.getGender())
                .status(client.getStatus())
                .ageGapLower(client.getAgeGapLower())
                .ageGapUpper(client.getAgeGapHigher())
                .interest(client.getInterest())
                .idealType(client.getIdealType())
                .personality(client.getPersonality())
                .hasChild(client.getHasChild())
                .images(client.getImages())
                .build();
    }
}

 

ClientSearchService

package com.iruyeon.v1.domain.search.service;

import com.iruyeon.v1.domain.client.dto.ClientRequestDTO;
import com.iruyeon.v1.domain.search.entity.ClientDocument;
import com.iruyeon.v1.domain.search.repository.ClientDocumentRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.Criteria;
import org.springframework.data.elasticsearch.core.query.CriteriaQuery;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class ClientSearchService {

    private final ElasticsearchOperations operations;
    private final ClientDocumentRepository clientDocumentRepository;

    public ClientDocument saveClient(ClientDocument document) {
        return clientDocumentRepository.save(document);
    }

    public List<ClientDocument> searchClient(ClientRequestDTO dto, int page) {
        // 페이지 설정
        Pageable pageable = PageRequest.of(page, 10);

        // 검색 조건 설정
        Criteria criteria = createConditionCriteria(dto);
        Query query = new CriteriaQuery(criteria).setPageable(pageable);

        // Elasticsearch 검색 실행
        SearchHits<ClientDocument> searchHits = operations.search(query, ClientDocument.class);

        // 검색 결과 변환 후 반환
        return searchHits.getSearchHits()
                .stream()
                .map(SearchHit::getContent)
                .collect(Collectors.toList());
    }

    private Criteria createConditionCriteria(ClientRequestDTO dto) {
        Criteria criteria = new Criteria();

        if (dto == null) {
            return criteria;
        }

        if (dto.getCurrentJob() != null) {
            criteria = criteria.and(Criteria.where("currentJob").is(dto.getCurrentJob()));
        }

        if (dto.getAgeGapHigher() > 0) {
            criteria = criteria.and(Criteria.where("maxAge").greaterThanEqual(dto.getAgeGapHigher())); // ✅ 수정
        }

        if (dto.getAgeGapLower() > 0) {
            criteria = criteria.and(Criteria.where("minAge").lessThanEqual(dto.getAgeGapLower())); // ✅ 수정
        }

        if (dto.getHasChild() != null) {
            criteria = criteria.and(Criteria.where("hasChild").is(dto.getHasChild()));
        }

        if (dto.getMaritalStatus() != null) {
            criteria = criteria.and(Criteria.where("maritalStatus").is(dto.getMaritalStatus()));
        }

        if (dto.getReligion() != null) {
            criteria = criteria.and(Criteria.where("religion").is(dto.getReligion()));
        }

        if (dto.getUniversity() != null) {
            criteria = criteria.and(Criteria.where("university").is(dto.getUniversity()));
        }

        return criteria;
    }
}

 

• operations.search(query, ClientDocument.class) 동작 방식
  • query는 CriteriaQuery 기반의 검색 조건이 설정된 쿼리 객체
  • ClientDocument.class는 검색 대상 엔티티 타입을 지정합니다.
  • Elasticsearch에 HTTP 요청을 보내고, 검색 결과를 JSON 형태로 응답하지만, Spring Data Elasticsearch는 이를 SearchHits<T> 객체로 변환합니다.

• • SearchHits<ClientDocument>는 다음 정보를 포함하고 있습니다:
    • 총 검색 결과 개수 (getTotalHits())
    • 각 검색 결과의 점수 (Elasticsearch Relevance Score)
    • 검색된 ClientDocument 데이터 (getContent())

 

index에 해당하는 전체 데이터 조회

http://localhost:9200/client/_search?pretty=true

 

조건에 맞는 데이터 조회

Elasticsearch에서 조건에 맞는 문서를 조회하고, 해당 결과를 쉽게 페이징 처리한 결과값을 확인할수 있습니다.

 

 

 

 

 

 

[참고]

 

https://esbook.kimjmin.net/07-settings-and-mappings

7. 인덱스 설정과 매핑 - Settings & Mappings | Elastic 가이드북

 

https://ksb-dev.tistory.com/324

스프링부트로 엘라스틱서치 쿼리 날리기

https://velog.io/@yukina1418/검색엔진-Elasticsearch에-대하여

검색엔진 Elasticsearch에 대하여

https://sihyung92.oopy.io/database/elasticsearch/1

검색엔진에 쓰이는 엘라스틱서치 Elasticsearch에 대해 알아보자!