[Spring, React] Elasticsearch 스프링 코드 작성하기!

Elasticsearch를 스프링에 사용하도록
기초 작업까지 완료했다.
이제 코드에 직접 작성해보자!

1. 동작 화면

GIF

이미지

2. 데이터 추가 과정

프로젝트 설명
고객 정보를 관리하는 페이지로 고객 정보를 추가할 때 이름, 등급, 연락처, 초대코드, 메모를 적을 수 있다.

(예시) 사용자가 보낸 JSON 데이터

{
  "name": "홍길동",
  "phone": "010-1234-5678",
  "code": "VIP777"
}

CustomerSearchEntity

// MySQL은 데이터를 저장할 때 어떤 테이블에 넣을지 결정한다.
// Elasticsearch에서는 데이터를 인덱스 단위로 관리한다.
@Document(indexName = "customers")
@Getter
@Setter
public class CustomerSearchEntity {
    @Id
    private Long id;

    // FieldType.Text는 문장이나 긴 텍스트를 저장할 때 쓴다.
    // analyzer = "nori"는 공식 한글 형태소 분석기이다.
    // 홍길동 이름을 저장하면 [홍,길,동] 혹은 [홍길동] 이런식으로 저장되도록 한다.
    @Field(type = FieldType.Text, analyzer = "nori")
    private String name;

    // FieldType.Keywords는 정확히 일치해야하는 데이터를 저장한다.
    // 전화번호나 고객 코드처럼 숫자로 이뤄진 경우 Keyword를 쓴다.
    // 영어도 keyword를 사용한다.
    @Field(type = FieldType.Keyword)
    private String grade;

    @Field(type = FieldType.Keyword)
    private String phone;

    @Field(type = FieldType.Keyword)
    private String code;

    @Field(type = FieldType.Text, analyzer = "nori")
    private String note;

    @Field(type = FieldType.Text)
    private String nameChosung;
}

프로젝트에 CustomerEntity와 CustomerSearchEntity를 만들었다. CustomerSearchEntity는 Elasticsearch 검색 엔진 전용 저장소에 데이터를 넣을 때 사용하는 엔티티이다. 두가지 엔티티를 만든 이유는 CustomerEntity은 진짜 원본인 MySQL용 엔티티로 원본은 안전하게 보관하는 역할을 한다.

CustomerSearchRepository

// Spring Data가 제공하는 특수 인터페이스인 ElasticsearchRepository
// 이걸 상속하면 save, delete, findById 같은 기능을 바로 쓸 수 있다.
// CustomerSearchEntity는 검색 대상이 되는 데이터 타입이고 그 데이터의 ID(Long)을 지정했다.
public interface CustomerSearchRepository extends ElasticsearchRepository<CustomerSearchEntity, Long> {
   
   // @Query는 Elasticsearch에 보내는 질문지이다.
    // 조건을 조합하기 위해 bool은 사용했다. shold는 or 연산자와 비슷하다.
    // 나열된 조건들 중 하나라도 만족하면 결과에 포함해달라는 말이다.
    
    // 검색 방법은 match와 wildcard가 있다.
    // match는 텍스트 검색(이름, 메모)에 더 적합하다. 형태소 분석기로 홍길동이 있으면 그걸 찾아낸다.
    // wildcard는 부분 일치 검색을 한다. 그래서 등급 전화번호 코드 초성에 더 적합하다.
    
    // *?0*은 앞뒤에 어떤 글자가 와도 상관없으니 키워드가 포함되어 있으면 찾으라는 것이다.
    // 그러니까 숫자의 일부분, 전화번호이면 뒷자리만 검색해도 결과가 나타난다.
    
    // should는 간혹 검색 결과를 넓게 한다. 
    // 그걸 방지하기 위해 최소한의 정확도를 확보하기 위해서 minimum_should_match:1을 적었다.
    // 나열된 조건들 중에서 적어도 1개 이상 만족해야한다는 의미이다.
    @Query("""
    {
      "bool": {
        "should": [
          { "match": { "name": { "query": "?0" } } },
          { "match": { "note": { "query": "?0" } } },

          { "wildcard": { "grade": { "value": "*?0*" } } },
          { "wildcard": { "phone": { "value": "*?0*" } } },
          { "wildcard": { "code":  { "value": "*?0*" } } },
          { "wildcard": { "nameChosung": { "value": "*?0*" } } }
        ],
        "minimum_should_match": 1
      }
    }
    """)
    // String keyword는 사용자가 검색창에 입력한 단어이다.
    List<CustomerSearchEntity> searchAll(String keyword);

    // 이 코드에 대해서 짧게 다시 정리하자면
    // 사용자가 공주를 검색했으면 '공주'기 포함된 모든 리스트를 다 들고오도록 하는 것이다.
}

CustomerController

    @PostMapping
    @PreAuthorize("hasAnyAuthority('ROLE_SUPER_ADMIN', 'CUSTOMER_ADD')")
    public Customer saveCustomer(@RequestBody Customer customer) {
        return customerService.save(customer);
    }

@PostMapping 메서드가 실행되며 사용자가 보낸 JSON 데이터를 Customer 객체로 받습니다. 이 부분 코드가 (@RequestBody Customer customer)이다. 그러면 컨트롤러에서 customerService에 적어둔 save 메서드로 customer 객체를 보낸다. 참고로 @PreAuthorize는 관리자의 역할에 따라 권한을 부여한 코드로 elasticsearch와 무관하다.

CustomerService

    // MySQL 저장에는 성공했는데 Elasticsearch 저장에서 에러가 나면
    // MySQL 저장도 없던 일로 되돌린다. (Rollback)
    // 양쪽 데이터가 불일치하는 상황을 방지하고자 어노테이션을 추가했다.
    @Transactional
    public Customer save(Customer customer) {

        // customer 객체에 포함되어있는 code를 꺼내서 code에 넣는다.
        String code = customer.getCode();

        // 그리고 코드가 중복되었는지 체크한다.
        if (code != null && customerRepository.existsByCode(code)) {
            throw new DuplicateCodeException("초대코드가 중복되었습니다.");
        }

        // customerRepository에도 저장된다.
        // customerRepository에.save()가 실행되면 DB에 저장된 실제 데이터가 반환되는데
        // 그걸 saved라는 이름표를 붙여서 보관한다.
        Customer saved = customerRepository.save(customer);

        // elasticsearch 검색을 위해서 검색 엔진에도 따로 저장한다.
        CustomerSearchEntity ela = new CustomerSearchEntity();
        // 변수 saved에서 저장된 데이터를 꺼내서 ela에 넣는다.
        ela.setId(saved.getId());
        ela.setName(saved.getName());
        ela.setGrade(saved.getGrade());
        ela.setPhone(saved.getPhone());
        ela.setCode(saved.getCode());
        ela.setNote(saved.getNote());
        // 초성도 저장한다. 
        // 그건 바로 밑에 코드에서 설명!
        ela.setNameChosung(getChosung(saved.getName()));

        customerSearchRepository.save(ela);

        // 모든 작업이 끝나면 최종적으로 saved를 컨트롤러에게 돌려준다.
        return saved;
    }

    // elasticsearch로 초성 검색으로도 찾게 하기 위해서
    // 한글의 유니코드 규칙을 이용해서 자음을 분리했다.
    private String getChosung(String text) {
        if (text == null) return "";

        String[] CHO = {
                "ㄱ","ㄲ","ㄴ","ㄷ","ㄸ","ㄹ","ㅁ","ㅂ","ㅃ","ㅅ",
                "ㅆ","ㅇ","ㅈ","ㅉ","ㅊ","ㅋ","ㅌ","ㅍ","ㅎ"
        };

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < text.length(); i++) {
            char c = text.charAt(i);

            if (c >= '가' && c <= '힣') {
                int uniVal = c - 0xAC00;
                int choIdx = uniVal / 588;
                sb.append(CHO[choIdx]);
            } else if (c != ' ') {
                sb.append(c);
            }
        }
        return sb.toString();
    }

Q. getChosung과 nori의 차이점은?

A. getChosung은 말 그대로 초성을 저장한다. 홍길동이란 데이터가 들어오면 ㅎㄱㄷ를 저장하는 것이다. name 필드에선 분석기 nori를 사용했다. nori는 홍길동을 쪼갠다. 홍,길,동 혹은 홍길,길동, 이런식으로 말이다. 사용자가 검색하면 초성 혹은 일부분만 검색해도 결과가 나타나도록 했다.

3. 데이터 검색 과정

(예시) 사용자가 보낸 검색 요청

GET /api/customers/search?keyword=ㅎㄱㄷ

CustomerController

    @GetMapping("/search")
    // 권한 검사
    @PreAuthorize("hasAnyAuthority('ROLE_SUPER_ADMIN', 'CUSTOMER_SEARCH')")
    // 여러 검색 결과가 반환될 수 있으니 List로 반환한다.
    // @RequestParam String keyword는 요청에 붙은 keyword=ㅎㄱㄷ 부분이다.
    // Spring이 자동으로 keyword="ㅎㄱㄷ" 이라고 넣는다.
    public List<CustomerSearchEntity> searchCustomer(@RequestParam String keyword) {
    
        // keyword를 들고가서 실제 검색이 실행된다.
        return customerSearchRepository.searchAll(keyword);
    }

CustomerSearchRepository

{
  "bool": {
    "should": [
      { "match": { "name": { "query": "?0" } } },
      { "match": { "note": { "query": "?0" } } },

      { "wildcard": { "grade": { "value": "*?0*" } } },
      { "wildcard": { "phone": { "value": "*?0*" } } },
      { "wildcard": { "code":  { "value": "*?0*" } } },
      { "wildcard": { "nameChosung": { "value": "*?0*" } } }
    ],
    "minimum_should_match": 1
  }
}

?0에 ㅎㄱㄷ이 들어간다. 쉽게 설명하기 위해 아래 코드처럼 작성했다.

{
  "bool": {
    "should": [
      { "match": { "name": { "query": "ㅎㄱㄷ" } } },
      { "match": { "note": { "query": "ㅎㄱㄷ" } } },

      { "wildcard": { "grade": { "value": "*ㅎㄱㄷ*" } } },
      { "wildcard": { "phone": { "value": "*ㅎㄱㄷ*" } } },
      { "wildcard": { "code":  { "value": "*ㅎㄱㄷ*" } } },
      { "wildcard": { "nameChosung": { "value": "*ㅎㄱㄷ*" } } }
    ],
    "minimum_should_match": 1
  }
}

CustomerService

ela.setNameChosung(getChosung(saved.getName()));

CustomerService에 위의 코드를 작성했다. 그래서 홍길동을 저장했을 때 아래와 같이 저장됐을거다.

{
  "id": 1,
  "name": "홍길동",
  "grade": "VIP",
  "phone": "010-1234-5678",
  "code": "1234",
  "note": "중요 고객",
  "nameChosung": "ㅎㄱㄷ"
}

이렇게 초성을 미리 저장해둬서 검색을 하면 찾을 수 있는 것이다.

4. MySQL을 기준으로 Elasticsearch 검색 데이터를 다시 맞추기

CustomerService

    // MySQL에 저장된 모든 고객 리스트를 긁어와서 하나씩 Elasticsearch에 넣는다.
    // elasticsearch를 사용하기 전에 DB에 저장되어 있는걸 가져오느라 적었던 코드인데,
    // 동기화 오류 등으로 DB와 검색엔진이 안맞는 걸 대비해서 해당 코드를 놔뒀다.
    @Transactional
    public void syncAllToElasticsearch() {
        //customerRepository에 있는 모든 데이터를 들어와서 list에 넣는다.
        List<Customer> list = customerRepository.findAll();

        // list에 있는 항목을 돌면서 customerSearchRepository에 저장한다.
        // 여기서 customerSearchRepository는 elasticsearch를 위해 만든 검색엔진이다.
        for (Customer c : list) {
            CustomerSearchEntity e = new CustomerSearchEntity();
            e.setId(c.getId());
            e.setName(c.getName());
            e.setGrade(c.getGrade());
            e.setPhone(c.getPhone());
            e.setCode(c.getCode());
            e.setNote(c.getNote());
            e.setNameChosung(getChosung(c.getName()));

            customerSearchRepository.save(e);
        }
    }

5. 전체 코드

CustomerSearchEntity

@Document(indexName = "customers")
@Getter
@Setter
public class CustomerSearchEntity {
    @Id
    private Long id;

    @Field(type = FieldType.Text, analyzer = "nori")
    private String name;

    @Field(type = FieldType.Keyword)
    private String grade;

    @Field(type = FieldType.Keyword)
    private String phone;

    @Field(type = FieldType.Keyword)
    private String code;

    @Field(type = FieldType.Text, analyzer = "nori")
    private String note;

    @Field(type = FieldType.Text)
    private String nameChosung;
}

CustomerSearchRepository

public interface CustomerSearchRepository extends ElasticsearchRepository<CustomerSearchEntity, Long> {
    @Query("""
    {
      "bool": {
        "should": [
          { "match": { "name": { "query": "?0" } } },
          { "match": { "note": { "query": "?0" } } },

          { "wildcard": { "grade": { "value": "*?0*" } } },
          { "wildcard": { "phone": { "value": "*?0*" } } },
          { "wildcard": { "code":  { "value": "*?0*" } } },
          { "wildcard": { "nameChosung": { "value": "*?0*" } } }
        ],
        "minimum_should_match": 1
      }
    }
    """)

    List<CustomerSearchEntity> searchAll(String keyword);
}

CustomerController

@RestController
@RequestMapping("/api/customers")
@RequiredArgsConstructor
public class CustomerController {

    private final CustomerService customerService;
    private final CustomerSearchRepository customerSearchRepository;

    @GetMapping
    @PreAuthorize("hasAnyAuthority('ROLE_SUPER_ADMIN', 'CUSTOMER_READ')")
    public List<Customer> effectCustomers() {
        return customerService.findAllCustomers();
    }

    @PostMapping
    @PreAuthorize("hasAnyAuthority('ROLE_SUPER_ADMIN', 'CUSTOMER_ADD')")
    public Customer saveCustomer(@RequestBody Customer customer) {
        return customerService.save(customer);
    }

    @PutMapping("/{id}")
    @PreAuthorize("hasAnyAuthority('ROLE_SUPER_ADMIN', 'CUSTOMER_EDIT')")
    public ResponseEntity<Customer> updateCustomer(@PathVariable Long id, @RequestBody Customer data) {
        if (!customerService.exists(id)) {
            return ResponseEntity.notFound().build();
        }
        Customer updated = customerService.update(id, data);
        return ResponseEntity.ok(updated);
    }

    @DeleteMapping("/{id}")
    @PreAuthorize("hasAnyAuthority('ROLE_SUPER_ADMIN', 'CUSTOMER_DELETE')")
    public ResponseEntity<Void> deleteCustomer(@PathVariable Long id) {
        if (!customerService.exists(id)) {
            return ResponseEntity.notFound().build();
        }
        customerService.delete(id);
        return ResponseEntity.ok().build();
    }

    @GetMapping("/search")
    @PreAuthorize("hasAnyAuthority('ROLE_SUPER_ADMIN', 'CUSTOMER_SEARCH')")
    public List<CustomerSearchEntity> searchCustomer(@RequestParam String keyword) {
        return customerSearchRepository.searchAll(keyword);
    }

    @PostMapping("/sync")
    @PreAuthorize("hasRole('SUPER_ADMIN')")
    public ResponseEntity<String> sync() {
        customerService.syncAllToElasticsearch();
        return ResponseEntity.ok("sync ok");
    }
}

CustomerService

@Service
public class CustomerService {

    private CustomerRepository customerRepository;
    private final CustomerSearchRepository customerSearchRepository;

    @Autowired
    public CustomerService(CustomerRepository customerRepository,  CustomerSearchRepository customerSearchRepository) {
        this.customerRepository = customerRepository;
        this.customerSearchRepository = customerSearchRepository;
    }

    public List<Customer> findAllCustomers() {
        return customerRepository.findAll();
    }

    public boolean exists(Long id) {
        return customerRepository.existsById(id);
    }

    public boolean isCodeDuplicatedForCreate(String code) {
        if (code == null || code.isBlank())
            return false;
        return customerRepository.existsByCode(code);
    }


    @Transactional
    public Customer save(Customer customer) {

        String code = customer.getCode();

        if (code != null && customerRepository.existsByCode(code)) {
            throw new DuplicateCodeException("초대코드가 중복되었습니다.");
        }

        Customer saved = customerRepository.save(customer);

        CustomerSearchEntity ela = new CustomerSearchEntity();
        ela.setId(saved.getId());
        ela.setName(saved.getName());
        ela.setGrade(saved.getGrade());
        ela.setPhone(saved.getPhone());
        ela.setCode(saved.getCode());
        ela.setNote(saved.getNote());
        ela.setNameChosung(getChosung(saved.getName()));

        customerSearchRepository.save(ela);

        return saved;
    }


    @Transactional
    public Customer update(Long id, Customer updateData) {
        Customer customer = customerRepository.findById(id)
                .orElseThrow(() -> new IllegalArgumentException("고객을 찾을 수 없습니다."));

        String newCode = updateData.getCode();

        if (newCode != null) {
            customerRepository.findByCode(newCode).ifPresent(found -> {
                if (!found.getId().equals(id)) {
                    throw new DuplicateCodeException("초대코드가 중복되었습니다.");
                }
            });
        }

        customer.setName(updateData.getName());
        customer.setGrade(updateData.getGrade());
        customer.setPhone(updateData.getPhone());
        customer.setCode(updateData.getCode());
        customer.setNote(updateData.getNote());

        CustomerSearchEntity ela = new CustomerSearchEntity();
        ela.setId(customer.getId());
        ela.setName(customer.getName());
        ela.setGrade(customer.getGrade());
        ela.setPhone(customer.getPhone());
        ela.setCode(customer.getCode());
        ela.setNote(customer.getNote());
        ela.setNameChosung(getChosung(customer.getName()));

        customerSearchRepository.save(ela);

        return customer;
    }

    @Transactional
    public void delete(Long id) {
        customerRepository.deleteById(id);
        customerSearchRepository.deleteById(id);
    }

    @Transactional
    public void syncAllToElasticsearch() {
        List<Customer> list = customerRepository.findAll();

        for (Customer c : list) {
            CustomerSearchEntity e = new CustomerSearchEntity();
            e.setId(c.getId());
            e.setName(c.getName());
            e.setGrade(c.getGrade());
            e.setPhone(c.getPhone());
            e.setCode(c.getCode());
            e.setNote(c.getNote());
            e.setNameChosung(getChosung(c.getName()));

            customerSearchRepository.save(e);
        }
    }

    private String getChosung(String text) {
        if (text == null) return "";

        String[] CHO = {
                "ㄱ","ㄲ","ㄴ","ㄷ","ㄸ","ㄹ","ㅁ","ㅂ","ㅃ","ㅅ",
                "ㅆ","ㅇ","ㅈ","ㅉ","ㅊ","ㅋ","ㅌ","ㅍ","ㅎ"
        };

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < text.length(); i++) {
            char c = text.charAt(i);

            if (c >= '가' && c <= '힣') {
                int uniVal = c - 0xAC00;
                int choIdx = uniVal / 588;
                sb.append(CHO[choIdx]);
            } else if (c != ' ') {
                sb.append(c);
            }
        }
        return sb.toString();
    }

}

'💻 프로젝트 > 👑 VIP 초대장 💌' 카테고리의 다른 글

[Spring, React] react-query 추가 후 기능 먹통 오류 발생,,, 해결해보자! (0)	2026.05.26
[Spring, React] 코드를 입력하면 고객 등급에 맞는 페이지를 결과로 보내기 (0)	2026.05.15
[Spring, React] Docker로 Elasticsearch를 실행해보자. (0)	2026.05.01
[Spring, React] Keycloak을 본격적으로 사용하기 전, 무엇을 할 지 구조 설계하기. (0)	2026.03.24
[Spring, React] jsx와 css 파일 연결, 연결된 css가 아니어도 jsx 페이지에 영향을 주는 경우 (0)	2026.03.17

hyeong-ing 🚀

[Spring, React] Elasticsearch 스프링 코드 작성하기!

'💻 프로젝트 > 👑 VIP 초대장 💌' 카테고리의 다른 글

티스토리툴바

[Spring, React] Elasticsearch 스프링 코드 작성하기!

'💻 프로젝트 > 👑 VIP 초대장 💌' 카테고리의 다른 글

관련글

티스토리툴바