How to build Elasticsearch client and call API using Java?

#Elasticsearch provides a rich set of Java calling interfaces to the outside world by constructing a client. Generally speaking, clients are divided into two types: cluster information clients and data (index) clients. These two categories can be divided into general operations and admin operations.

Inheritance relationship of client

(version 1.5, other versions may be different):

It can be clearly seen through this inheritance relationship diagram Understand the implementation and functions of client. There are three categories in total, namely client, indicesAdminClient and ClusterAdminClient. It has its own implementation class, but in the end it provides external services through the client interface. As the general external interface, client first combines admin-related operations through the admin() method. It also provides all common operations on data and clusters.

Method implementation

All interfaces implement asynchronous calls in two ways, one is to return an ActionFuture, and the other is to accept an ActionListener.

Take the index method as an example

As shown below

ActionFuture index(IndexRequest request) ;

void index(IndexRequest request , ActionListener listener);

The first method will return a future, and the second method needs to pass a Listener. These are also two basic ways of asynchronous implementation. The client uses the facade mode. All implementations are in the AbstractClient class. Taking the index method as an example, the code is as follows:

@Override
    public ActionFuture<IndexResponse> index(final IndexRequest request) {
        return execute(IndexAction.INSTANCE, request);
    }
    @Override
    public void index(final IndexRequest request, final ActionListener<IndexResponse> listener) {
        execute(IndexAction.INSTANCE, request, listener);
    }

The implementation is as shown above. The reason why it is called the facade mode is because all Methods are integrated into the client, but the execution process is executed in the corresponding action. In the execute method, the corresponding action instance is obtained, and the real logic is implemented in the corresponding transaction action.

execute method code

is as follows:

@SuppressWarnings("unchecked")
    @Override
    public <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder, Client>> ActionFuture<Response> execute(Action<Request, Response, RequestBuilder, Client> action, Request request) {
        headers.applyTo(request);
        TransportAction<Request, Response> transportAction = actions.get((ClientAction)action);
        return transportAction.execute(request);
    }
    @SuppressWarnings("unchecked")
    @Override
    public <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder, Client>> void execute(Action<Request, Response, RequestBuilder, Client> action, Request request, ActionListener<Response> listener) {
        headers.applyTo(request);
        TransportAction<Request, Response> transportAction = actions.get((ClientAction)action);
        transportAction.execute(request, listener);
    }

Each operation corresponds to a corresponding transportAction, and these transportActions are the final executors. Here we take index as an example for a brief explanation. We will see more results like this in the analysis of the index function later.

public class IndexAction extends ClientAction<IndexRequest, IndexResponse, IndexRequestBuilder> {
    public static final IndexAction INSTANCE = new IndexAction();
    public static final String NAME = "indices:data/write/index";
    private IndexAction() {
        super(NAME);
    }
    @Override
    public IndexResponse newResponse() {
        return new IndexResponse();
    }
    @Override
    public IndexRequestBuilder newRequestBuilder(Client client) {
        return new IndexRequestBuilder(client);
    }
}

In IndexAction, a NAME and several simple methods are simply defined. This name will be registered in the TransportService as the key to the transportHandler at startup. In the execute method, the transportAction will be taken out according to the action as shown in the previous code. The real execution logic is in InternalTransportClient. Its implementation will be skipped here and will be analyzed in detail later. The registration of all these actions is implemented in actionModule, and the registration process will be analyzed together with the action later.

The above is the detailed content of How to build Elasticsearch client and call API using Java?. For more information, please follow other related articles on the PHP Chinese website!