Elasticsearch java

Elasticsearch java DEFAULT

Elasticsearch Java Client

Elastic logo

The official Java client for Elasticsearch.

Note: this project is still in beta. This client is meant to replace the existing Java High Level Client and remove all dependencies to the Elasticsearch server code base.

The Java client for Elasticsearch provides strongly typed requests and responses for all Elasticsearch APIs. It delegates protocol handling to an http client such as the Elasticsearch Low Level REST client that takes care of all transport-level concerns (http connection establishment and pooling, retries, etc).

The folder contains records of the major decisions in the design of the API. Most notably:

  • Object construction is based on the fluent builder pattern.
  • Nested objects can be constructed with builder lambdas, allowing for clean and expressive DSL-like code.
  • Optional values are represented as with annotations instead of the newer , the Java ecosystem being still very null-based.

Getting started

Installing the library

This library requires at least Java 8.

Along with this library, you also need a JSON/object mapping library. has built-in support for Jackson and JSON-B implementations such as Eclipse Yasson.

Releases are hosted on Maven Central. If you are looking for a SNAPSHOT version, the Elastic Maven Snapshot repository is available at https://snapshots.elastic.co/maven/.

Gradle project (Groovy flavor) setup using Jackson:

dependencies { implementation 'co.elastic.clients:elasticsearch-java:7.15.0' implementation 'com.fasterxml.jackson.core:jackson-databind:2.12.3' }

In the for your project add the following repository definition and dependencies:

<project> <dependencies> <dependency> <groupId>co.elastic.clients</groupId> <artifactId>elasticsearch-java</artifactId> <version>7.15.0</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.12.3</version> </dependency> </dependencies> </project>

Your first request

// Create the low-level clientRestClient restClient =RestClient.builder(newHttpHost("localhost", 9200)).build(); // Create the transport that provides JSON and http services to API clientsTransport transport =newRestClientTransport(restClient, newJacksonJsonpMapper()); // And create our API clientElasticsearchClient client =newElasticsearchClient(transport); // Search all items in an index that contains documents of type AppDataSearchResponse search = client.search(s -> s .index("test-index"), AppData.class ); if (search.hits().hits().isEmpty()) { System.out.println("No match"); } else { for (Hit<AppData> hit : search.hits().hits()) { processAppData(hit._source()); } }


The branch targets the next major release (8.0) and the branch targets the next minor release. Support is still incomplete as the API code is generated from the Elasticsearch Specification that is also still a work in progress.

The Elasticsearch Java client is forward compatible; meaning that the client supports communicating with greater minor versions of Elasticsearch. Elastic language clients are also backwards compatible with lesser supported minor Elasticsearch versions.

Current status

Beta state means we don't expect large architectural changes and the library is already fairly usable. This library also essentially deals with request & response serialization & deserialization and delegates all http request processing to the battle-tested Low Level Rest Client.

What's missing falls in two main categories, related to the Elasticsearch specification:

  • incomplete support for some data types used in specification (e.g. unions). Until they have been implemented in the code generator, they are represented as raw objects.
  • incomplete APIs: as the API specification is still incomplete, so are their implementations in this library since their code is entirely generated from the spec.




This software is licensed under the Apache License 2.0.

Sours: https://github.com/elastic/elasticsearch-java

Elasticsearch Tutorial

Elasticsearch Tutorial

Elasticsearch is a real-time distributed and open source full-text search and analytics engine. It is used in Single Page Application (SPA) projects. Elasticsearch is an open source developed in Java and used by many big organizations around the world. It is licensed under the Apache license version 2.0.

In this tutorial, you will learn in detail the basics of Elasticsearch and its important features.

This tutorial is designed for software professionals who want to learn the basics of Elasticsearch and its programming concepts in simple and easy steps. It describes the components of Elasticsearch with suitable examples.

This tutorial is designed to configure the HR module of SAP in an easy and systematic way. Packed with plenty of screenshots, it will be useful for consultants as well as end-users.

Before you begin with this tutorial, you should have a basic understanding of Java, JSON, search engines, and web technologies. The interaction with Elasticsearch is through RESTful API; therefore, it is always recommended to have knowledge of RESTful API.

If you are new to any of these concepts, we suggest you to take the help of tutorials based on these topics before you start with Elasticsearch.

Sours: https://www.tutorialspoint.com/elasticsearch/index.htm
  1. Flipgrid feedback
  2. Insane craft mod
  3. Healer memes wow
  4. Yamaha drum hardware parts

We plan on deprecating the in Elasticsearch 7.0 and removing it completely in 8.0. Instead, you should be using the Java High Level REST Client, which executes HTTP requests rather than serialized Java requests. The migration guide describes all the steps needed to migrate.

The Java High Level REST Client currently has support for the more commonly used APIs, but there are a lot more that still need to be added. You can help us prioritise by telling us which missing APIs you need for your application by adding a comment to this issue: Java high-level REST client completeness.

Any missing APIs can always be implemented today by using the low level Java REST Client with JSON request and response bodies.

X-Pack provides a Java client called that adds native Java support for the Watcher.

To obtain a instance, make sure you first set up the .

Installing XPackClientedit

You first need to make sure the JAR file is in the classpath. You can extract this jar from the downloaded X-Pack bundle.

If you use Maven to manage dependencies, add the following to the :

<project ...> <repositories> <!-- add the elasticsearch repo --> <repository> <id>elasticsearch-releases</id> <url>https://artifacts.elastic.co/maven</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>false</enabled> </snapshots> </repository> ... </repositories> ... <dependencies> <!-- add the x-pack jar as a dependency --> <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>x-pack-transport</artifactId> <version>6.8.20</version> </dependency> ... </dependencies> ... </project>

If you use Gradle, add the dependencies to :

repositories { /* ... Any other repositories ... */ // Add the Elasticsearch Maven Repository maven { name "elastic" url "https://artifacts.elastic.co/maven" } } dependencies { // Provide the x-pack jar on the classpath for compilation and at runtime compile "org.elasticsearch.client:x-pack-transport:6.8.20" /* ... */ }

You can also download the X-Pack Transport JAR manually, directly from our Maven repository.

Obtaining the edit

To obtain an instance of the you first need to create the . The is a wrapper around the standard Java Elasticsearch :

import org.elasticsearch.client.transport.TransportClient; import org.elasticsearch.xpack.client.PreBuiltXPackTransportClient; import org.elasticsearch.xpack.core.XPackClient; import org.elasticsearch.xpack.core.XPackPlugin; import org.elasticsearch.core.watcher.client.WatcherClient; ... TransportClient client = new PreBuiltXPackTransportClient(Settings.builder() .put("cluster.name", "myClusterName") ... .build()) .addTransportAddress(new TransportAddress(InetAddress.getByName("localhost"), 9300)); XPackClient xpackClient = new XPackClient(client); WatcherClient watcherClient = xpackClient.watcher();

Put watch APIedit

The put watch API either registers a new watch in Watcher or update an existing one. Once registered, a new document will be added to the index, representing the watch, and the watch trigger will immediately be registered with the relevant trigger engine (typically the scheduler, for the trigger).

Putting a watch must be done via this API only. Do not put a watch directly to the index using Elasticsearch’s Index API. When the Elasticsearch security features are enabled, make sure no privileges are granted to anyone over the index.

The following example adds a watch with the id that has the following characteristics:

  • The watch schedule triggers every minute.
  • The watch search input looks for any 404 HTTP responses that occurred in the last five minutes.
  • The watch condition checks if any hits where found.
  • When hits are found, the watch action sends an email to the administrator.
WatchSourceBuilder watchSourceBuilder = WatchSourceBuilders.watchBuilder(); // Set the trigger watchSourceBuilder.trigger(TriggerBuilders.schedule(Schedules.cron("0 0/1 * * * ?"))); // Create the search request to use for the input SearchRequest request = Requests.searchRequest("idx").source(searchSource() .query(boolQuery() .must(matchQuery("response", 404)) .filter(rangeQuery("date").gt("{{ctx.trigger.scheduled_time}}")) .filter(rangeQuery("date").lt("{{ctx.execution_time}}")) )); // Create the search input SearchInput input = new SearchInput(new WatcherSearchTemplateRequest(new String[]{"idx"}, null, SearchType.DEFAULT, WatcherSearchTemplateRequest.DEFAULT_INDICES_OPTIONS, new BytesArray(request.source().toString())), null, null, null); // Set the input watchSourceBuilder.input(input); // Set the condition watchSourceBuilder.condition(new ScriptCondition(new Script("ctx.payload.hits.total > 1"))); // Create the email template to use for the action EmailTemplate.Builder emailBuilder = EmailTemplate.builder(); emailBuilder.to("[email protected]"); emailBuilder.subject("404 recently encountered"); EmailAction.Builder emailActionBuilder = EmailAction.builder(emailBuilder.build()); // Add the action watchSourceBuilder.addAction("email_someone", emailActionBuilder); PutWatchResponse putWatchResponse = watcherClient.preparePutWatch("my-watch") .setSource(watchSourceBuilder) .get();

While the above snippet flashes out all the concrete classes that make our watch, using the available builder classes along with static imports can significantly simplify and compact your code:

PutWatchResponse putWatchResponse2 = watcherClient.preparePutWatch("my-watch") .setSource(watchBuilder() .trigger(schedule(cron("0 0/1 * * * ?"))) .input(searchInput(new WatcherSearchTemplateRequest(new String[]{"idx"}, null, SearchType.DEFAULT, WatcherSearchTemplateRequest.DEFAULT_INDICES_OPTIONS, searchSource() .query(boolQuery() .must(matchQuery("response", 404)) .filter(rangeQuery("date").gt("{{ctx.trigger.scheduled_time}}")) .filter(rangeQuery("date").lt("{{ctx.execution_time}}")) ).buildAsBytes()))) .condition(compareCondition("ctx.payload.hits.total", CompareCondition.Op.GT, 1L)) .addAction("email_someone", emailAction(EmailTemplate.builder() .to("[email protected]") .subject("404 recently encountered")))) .get();
  • Use and classes to define the trigger
  • Use class to define the input
  • Use class to define the condition
  • Use to define the actions

Get watch APIedit

This API retrieves a watch by its id.

The following example gets a watch with id:

GetWatchResponse getWatchResponse = watcherClient.prepareGetWatch("my-watch").get();

You can access the watch definition by accessing the source of the response:

XContentSource source = getWatchResponse.getSource();

The provides you methods to explore the source:

Map<String, Object> map = source.getAsMap();

Or get a specific value associated with a known key:

String host = source.getValue("input.http.request.host");

Delete watch APIedit

The delete watch API removes a watch (identified by its ) from Watcher. Once removed, the document representing the watch in the index is gone and it will never be executed again.

Please note that deleting a watch does not delete any watch execution records related to this watch from the watch history.

Deleting a watch must be done via this API only. Do not delete the watch directly from the index using Elasticsearch’s DELETE Document API. If the Elasticsearch security features are enabled, make sure no privileges are granted to anyone over the index.

The following example deletes a watch with the id:

DeleteWatchResponse deleteWatchResponse = watcherClient.prepareDeleteWatch("my-watch").get();

Execute watch APIedit

This API enables on-demand execution of a watch stored in the index. It can be used to test a watch without executing all its actions or by ignoring its condition. The response contains a that represents the record that would be written to the index.

The following example executes a watch with the name

ExecuteWatchResponse executeWatchResponse = watcherClient.prepareExecuteWatch("my-watch") // execute the actions, ignoring the watch condition .setIgnoreCondition(true) // A map containing alternative input to use instead of the output of // the watch's input .setAlternativeInput(new HashMap<String, Object>()) // Trigger data to use (Note that "scheduled_time" is not provided to the // ctx.trigger by this execution method so you may want to include it here) .setTriggerData(new HashMap<String, Object>()) // Simulating the "email_admin" action while ignoring its throttle state. Use // "_all" to set the action execution mode to all actions .setActionMode("_all", ActionExecutionMode.FORCE_SIMULATE) // If the execution of this watch should be written to the `.watcher-history` // index and reflected in the persisted Watch .setRecordExecution(false) // Indicates whether the watch should execute in debug mode. In debug mode the // returned watch record will hold the execution vars .setDebug(true) .get();

Once the response is returned, you can explore it by getting execution record source:

The class provides convenient methods to explore the source

XContentSource source = executeWatchResponse.getRecordSource(); String actionId = source.getValue("result.actions.0.id");

Ack watch APIedit

Acknowledging a watch enables you to manually throttle execution of the watch actions. The action’s acknowledgement state is stored in the structure.

The current status of the watch and the state of its actions are returned as part of the get watch API response:

GetWatchResponse getWatchResponse = watcherClient.prepareGetWatch("my-watch").get(); State state = getWatchResponse.getStatus().actionStatus("my-action").ackStatus().state();

The action state of a newly created watch is . When the watch runs and its condition is met, the state changes to . Acknowledging the action sets the state to .

When an action state is set to , further executions of that action are throttled until its state is reset to . This happens when the watch condition is no longer met (the condition evaluates to ).

The following snippet shows how to acknowledge an action. You specify the IDs of the watch and the action you want to acknowledge—​in this example and :

AckWatchResponse ackResponse = watcherClient.prepareAckWatch("my-watch").setActionIds("my-action").get();

As a response to this request, the status of the watch and the state of the action are returned and can be obtained from object:

WatchStatus status = ackResponse.getStatus(); ActionStatus actionStatus = status.actionStatus("my-action"); ActionStatus.AckStatus ackStatus = actionStatus.ackStatus(); ActionStatus.AckStatus.State ackState = ackStatus.state();

You can acknowledge multiple actions:

AckWatchResponse ackResponse = watcherClient.prepareAckWatch("my-watch") .setActionIds("action1", "action2") .get();

To acknowledge all actions of a watch, specify only the watch ID:

AckWatchResponse ackResponse = watcherClient.prepareAckWatch("my-watch").get();

Activate watch APIedit

A watch can be either active or inactive. This API enables you to activate a currently inactive watch.

The status of an inactive watch is returned with the watch definition when you call the get watch API:

GetWatchResponse getWatchResponse = watcherClient.prepareGetWatch("my-watch").get(); boolean active = getWatchResponse.getStatus().state().isActive();

The following snippet shows how you can activate a watch:

ActivateWatchResponse activateResponse = watcherClient.prepareActivateWatch("my-watch", true).get(); boolean active = activateResponse.getStatus().state().isActive();

The new state of the watch is returned as part of its overall status.

Deactivate watch APIedit

A watch can be either active or inactive. This API enables you to deactivate a currently active watch.

The status of an active watch is returned with the watch definition when you call the get watch API:

GetWatchResponse getWatchResponse = watcherClient.prepareGetWatch("my-watch").get(); boolean active = getWatchResponse.getStatus().state().isActive();

The following snippet shows how you can deactivate a watch:

ActivateWatchResponse activateResponse = watcherClient.prepareActivateWatch("my-watch", false).get(); boolean active = activateResponse.getStatus().state().isActive();

The new state of the watch is returned as part of its overall status.

Stats APIedit

The API returns the current Watcher metrics. You can control what metrics this API returns using the parameter.

The following example queries the API :

WatcherStatsResponse watcherStatsResponse = watcherClient.prepareWatcherStats().get();

A successful call returns a response structure that can be accessed as shown:

WatcherBuild build = watcherStatsResponse.getBuild(); // The current size of the watcher execution queue long executionQueueSize = watcherStatsResponse.getThreadPoolQueueSize(); // The maximum size the watch execution queue has grown to long executionQueueMaxSize = watcherStatsResponse.getThreadPoolQueueSize(); // The total number of watches registered in the system long totalNumberOfWatches = watcherStatsResponse.getWatchesCount(); // {watcher} state (STARTING,STOPPED or STARTED) WatcherState watcherState = watcherStatsResponse.getWatcherState();

Service APIedit

The Watcher API allows the control the lifecycle of the Watcher service. The following example starts the watcher service:

WatcherServiceResponse watcherServiceResponse = watcherClient.prepareWatchService().start().get();

The following example stops the watcher service:

WatcherServiceResponse watcherServiceResponse = watcherClient.prepareWatchService().stop().get();

The following example restarts the watcher service:

WatcherServiceResponse watcherServiceResponse = watcherClient.prepareWatchService().restart().get();
Sours: https://www.elastic.co/guide/en/elasticsearch/reference/6.8/api-java.html
How to connect to Elasticsearch from Spring Boot Application - Spring Data Elasticsearch - Part 1


Java elasticsearch


SpringBoot ElasticSearch using Spring Data - Java Techie


You will also be interested:


877 878 879 880 881