Microservice Distributed Search Engine Elastic Search RestClient Operation Documentation

Article directory

• ?introduction
• 1. Initialize Java RestClient
• 2. RestClient’s CRUD operation on documents
• • ?New document
  • ?Query documents
  • ? Modify the document
  • ?Delete documents
• 3. RestClient Batch Document Import
• ?summary

?Introduction

This article refers to the dark horse distributed Elastic search
Elasticsearch is a very powerful open source search engine with many powerful functions that can help us quickly find what we need from massive amounts of data

1. Initialize Java RestClient

Initialize RestHighLevelClient

In order to separate from the index library operation, we add a test class again, which does two things:

• Initialize RestHighLevelClient
• Our hotel data is in the database, we need to use IHotelService to query, so inject this interface

Document test class

import com.alibaba.fastjson.JSON;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.List;

/**
 * @author whc
 * @date 2023/2/28 15:01
 */
@SpringBootTest
public class HotelDocumentTest {<!-- -->

    private RestHighLevelClient restHighLevelClient;

    @Autowired
    private IHotelService hotelService;

    @BeforeEach
    void setUp() {<!-- -->
           this.restHighLevelClient = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("IP address: 9200")
        ));
    }

    @AfterEach
    void tearDown() throws IOException {<!-- -->
        this.restHighLevelClient.close();
    }
}

The test class initialization RestClient is completed.

2. RestClient CRUD operations on documents

Next, we use RestClient to add, delete, modify and check the document for a deeper understanding.

?Add document

Requirement: Query the hotel data from the database and write it into ElasticSearch through RestClient.

Conversion between entity class and index library entity class

The result returned by the database is a Hotel type object with the following properties:

@Data
@TableName("tb_hotel")
public class Hotel {<!-- -->
    @TableId(type = IdType. INPUT)
    private Long id;
    private String name;
    private String address;
    private Integer price;
    private Integer score;
    private String brand;
    private String city;
    private String starName;
    private String business;
    private String longitude;
    private String latitude;
    private String pic;
}

Then the question is, what should we do if the structure of our ElasticSearch index library is inconsistent with the entity class?

For example: longitude and latitude are realized by location in the index library, separated by , . In the entity class there are two separate properties.

Therefore, we need to define a new object and combine the properties to achieve the result we want

import lombok. Data;
import lombok. NoArgsConstructor;

@Data
@NoArgsConstructor
public class HotelDoc {<!-- -->
    private Long id;
    private String name;
    private String address;
    private Integer price;
    private Integer score;
    private String brand;
    private String city;
    private String starName;
    private String business;
    private String location;
    private String pic;

    public HotelDoc(Hotel hotel) {<!-- -->
        this.id = hotel.getId();
        this.name = hotel.getName();
        this.address = hotel.getAddress();
        this.price = hotel.getPrice();
        this.score = hotel.getScore();
        this.brand = hotel.getBrand();
        this.city = hotel.getCity();
        this.starName = hotel.getStarName();
        this. business = hotel. getBusiness();
        this.location = hotel.getLatitude() + ", " + hotel.getLongitude();
        this.pic = hotel.getPic();
    }
}

Grammar Description

The DSL statement of the newly added document is as follows:

POST /{<!-- -->Index library name}/_doc/1
{<!-- -->
    "name": "Jack",
    "age": 20
}

The Java code is as follows

You can see that it is similar to creating an index library, and it is also a three-step process:

• 1. Create a Request object
• 2. Prepare request parameters, that is, JSON in DSL document
• 3. Send request

The change is that the API of **client.xxx() is directly used here, and there is no need forclient.indices()**.

New documentation for full code testing

@Test
void testAddDocument() throws IOException {<!-- -->
    //Get hotel data
    Hotel hotel = hotelService. getById(36934L);
HotelDoc hotelDoc = new HotelDoc(hotel);
//1. Create a request object
    IndexRequest request = new IndexRequest("hotel").id(hotel.getId().toString());
    //2. Prepare parameters
    request.source(JSON.toJSONString(hotelDoc), XContentType.JSON);
    //3. Send request
    restHighLevelClient.index(request, RequestOptions.DEFAULT);
}

Just execute it.

?Query document

The query DSL statement is as follows:

GET /index library name/_doc/{<!-- -->id}

Roughly divided into 2 steps

• Prepare the Request object
• send request

However, the purpose of the query is to get the result, which is parsed into HotelDoc, so the difficulty is the parsing of the result. The complete code is as follows:

As you can see, the result is a JSON, in which the document is placed in a _source attribute, so the parsing is to get the _source, and deserialize it into a Java object can be.

@Test
void testGetDocument() throws IOException {<!-- -->
    //1. Create a request object
    GetRequest request = new GetRequest("hotel", "36934");
    //2. Send request
    GetResponse response = restHighLevelClient.get(request, RequestOptions.DEFAULT);
    String sourceAsString = response. getSourceAsString();
    System.out.println(sourceAsString);
}

@Test
void testUpdateDocument() throws IOException {<!-- -->
    //1. Create a request object
    UpdateRequest request = new UpdateRequest("hotel", "36934");
    //2. Prepare parameters
    request.doc(
        "price", "456",
        "starName", "Three Diamonds"
    );
    //3. Send request
    restHighLevelClient.update(request, RequestOptions.DEFAULT);
}

DELETE /hotel/_doc/{<!-- -->id}

@Test
void testDeleteDocument() throws IOException {<!-- -->
    //1. Create a request object
    DeleteRequest request = new DeleteRequest("hotel", "36934");
    //2. Send request
    restHighLevelClient.delete(request, RequestOptions.DEFAULT);
}

@Test
void testBulk() throws IOException {<!-- -->
    //Get hotel data
    List<Hotel> hotels = hotelService. list();

    //1. Create a bulk request
    BulkRequest request = new BulkRequest();
    //2. Add batch processing requests
    for (Hotel hotel : hotels) {<!-- -->
        HotelDoc hotelDoc = new HotelDoc(hotel);
        request. add(new IndexRequest("hotel").
                    id(hotel.getId().toString()).source(JSON.toJSONString(hotelDoc), XContentType.JSON));
    }

    //3. Send request
    restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
}