Anleitung zur Elasticsearch in Java

1. Überblick

In diesem Artikel werden wir uns mit einigen Schlüsselkonzepten im Zusammenhang mit Volltextsuchmaschinen befassen, wobei der Schwerpunkt auf Elasticsearch liegt.

Da es sich um einen Java-orientierten Artikel handelt, werden wir keine detaillierte Schritt-für-Schritt-Anleitung zum Einrichten von Elasticsearch geben und zeigen, wie es unter der Haube funktioniert. Stattdessen werden wir uns an den Java-Client wenden. und wie man die Hauptfunktionen wieindex,delete,get undsearch verwendet.

2. Konfiguration

Informationen zum Installieren von Elasticsearch auf Ihrem Computer finden Sie unterofficial setup guide.

Der Installationsvorgang ist ziemlich einfach. Laden Sie einfach das zip / tar-Paket herunter und führen Sie die Skriptdateielasticsearch aus (elasticsearch.bat für Windows-Benutzer).

Standardmäßig überwacht Elasticsearch den 9200-Port auf bevorstehende HTTP-Abfragen. Wir können überprüfen, ob es erfolgreich gestartet wurde, indem wir die URL vonhttp://localhost:9200/in Ihrem bevorzugten Browser öffnen:

{
  "name" : "GEpcsab",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "z3FfAe6gRMmSmeWBIOihJg",
  "version" : {
    "number" : "5.6.10",
    "build_hash" : "b727a60",
    "build_date" : "2018-06-06T15:48:34.860Z",
    "build_snapshot" : false,
    "lucene_version" : "6.6.1"
  },
  "tagline" : "You Know, for Search"
}

3. Maven-Konfiguration

Nachdem wir unseren grundlegenden Elasticsearch-Cluster eingerichtet haben, können wir direkt zum Java-Client springen. Zunächst müssen die folgendenMaven dependency in unsererpom.xml-Datei deklariert sein:


    org.elasticsearch
    elasticsearch
    5.6.0

Sie können die neuesten Versionen, die von Maven Central gehostet werden, jederzeit über den zuvor bereitgestellten Link überprüfen.

4. Java API

Bevor wir direkt mit der Verwendung der wichtigsten Java-API-Funktionen beginnen, müssen wir den Transportclient: initiieren

Client client = new PreBuiltTransportClient(
  Settings.builder().put("client.transport.sniff", true)
                    .put("cluster.name","elasticsearch").build())
  .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"), 9300));

4.1. Indizieren von Dokumenten

Mit der FunktionprepareIndex() kann ein beliebiges JSON-Dokument gespeichert und durchsuchbar gemacht werden:

@Test
public void givenJsonString_whenJavaObject_thenIndexDocument() {
    String jsonObject = "{\"age\":10,\"dateOfBirth\":1471466076564,"
      +"\"fullName\":\"John Doe\"}";
    IndexResponse response = client.prepareIndex("people", "Doe")
      .setSource(jsonObject, XContentType.JSON).get();

    String id = response.getId();
    String index = response.getIndex();
    String type = response.getType();
    long version = response.getVersion();

    assertEquals(Result.CREATED, response.getResult());
    assertEquals(0, version);
    assertEquals("people", index);
    assertEquals("Doe", type);
}

Stellen Sie beim Ausführen des Tests sicher, dass Sie die Variablepath.homedeklarieren. Andernfalls kann die folgende Ausnahme auftreten:

java.lang.IllegalStateException: path.home is not configured

Nach dem Ausführen des Maven-Befehls:mvn clean install -Des.path.home=C:\elastic wird das JSON-Dokument mitpeople als Index undDoe als Typ gespeichert.

Beachten Sie, dass Sieany JSON Java library verwenden können, um Ihre Dokumente zu erstellen und zu verarbeiten. If you are not familiar with any of these, you can use Elasticsearch helpers to generate your own JSON documents:

XContentBuilder builder = XContentFactory.jsonBuilder()
  .startObject()
  .field("fullName", "Test")
  .field("dateOfBirth", new Date())
  .field("age", "10")
  .endObject();
IndexResponse response = client.prepareIndex("people", "Doe")
  .setSource(builder).get();

assertEquals(Result.CREATED, response.getResult());

4.2. Indizierte Dokumente abfragen

Nachdem wir ein typisiertes durchsuchbares JSON-Dokument indiziert haben, können wir mit der MethodeprepareSearch()fortfahren und suchen:

SearchResponse response = client.prepareSearch().execute().actionGet();
List searchHits = Arrays.asList(response.getHits().getHits());
List results = new ArrayList();
searchHits.forEach(
  hit -> results.add(JSON.parseObject(hit.getSourceAsString(), Person.class)));

The results returned by the actionGet() method are called Hits, jedesHit bezieht sich auf ein JSON-Dokument, das einer Suchanforderung entspricht.

In diesem Fall enthält die Listeresultsalle im Cluster gespeicherten Daten. Beachten Sie, dass wir in diesem Beispiel die BibliothekFastJsonverwenden, um JSONStringsin Java-Objekte zu konvertieren.

Wir können die Anforderung erweitern, indem wir zusätzliche Parameter hinzufügen, um die Abfrage mithilfe der Methoden vonQueryBuildersanzupassen:

SearchResponse response = client.prepareSearch()
  .setTypes()
  .setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
  .setPostFilter(QueryBuilders.rangeQuery("age").from(5).to(15))
  .execute()
  .actionGet();

4.3. Dokumente abrufen und löschen

Mit den MethodenprepareGet() undprepareDelete() können Sie ein JSON-Dokument mithilfe seiner ID aus dem Cluster abrufen oder löschen:

GetResponse response = client.prepareGet("people","Doe","1").get();
String age = (String) response.getField("age").getValue();
// Process other fields
DeleteResponse response = client.prepareDelete("people", "Doe", "5")
  .get();

Die Syntax ist ziemlich einfach. Sie müssen lediglich den Index und den Typwert neben der Objekt-ID angeben.

**5. QueryBuilders Beispiele**

Die KlasseQueryBuilders bietet eine Vielzahl statischer Methoden, die als dynamische Matcher verwendet werden, um bestimmte Einträge im Cluster zu finden. Während Sie die MethodeprepareSearch() zum Suchen nach bestimmten JSON-Dokumenten im Cluster verwenden, können Sie die Suchergebnisse mithilfe von Abfrage-Generatoren anpassen.

Hier ist eine Liste der häufigsten Verwendungen derQueryBuilders-API.

Die MethodematchAllQuery() gibt einQueryBuilder-Objekt zurück, das mit allen Dokumenten im Cluster übereinstimmt:

QueryBuilder matchAllQuery = QueryBuilders.matchAllQuery();

DierangeQuery() stimmen mit Dokumenten überein, bei denen der Wert eines Felds innerhalb eines bestimmten Bereichs liegt:

QueryBuilder matchDocumentsWithinRange = QueryBuilders
  .rangeQuery("price").from(15).to(100)

Bereitstellen eines Feldnamens - z. fullName und der entsprechende Wert - z. John Doe, Die MethodematchQuery() stimmt alle Dokumente mit dem genauen Feldwert ab:

QueryBuilder matchSpecificFieldQuery= QueryBuilders
  .matchQuery("fullName", "John Doe");

Wir können auch diemultiMatchQuery()-Methode verwenden, um eine Version der Übereinstimmungsabfrage mit mehreren Feldern zu erstellen:

QueryBuilder matchSpecificFieldQuery= QueryBuilders.matchQuery(
  "Text I am looking for", "field_1", "field_2^3", "*_field_wildcard");

We can use the caret symbol (^) to boost specific fields.

In unserem Beispiel hatfield_2 einen Boost-Wert von drei, was ihn wichtiger macht als die anderen Felder. Beachten Sie, dass es möglich ist, Platzhalter- und Regex-Abfragen zu verwenden. Achten Sie jedoch beim Umgang mit Platzhaltern auf den Speicherverbrauch und die Verzögerung der Antwortzeit, da so etwas wie * _apples einen großen Einfluss auf die Leistung haben kann.

Der Wichtigkeitskoeffizient wird verwendet, um die Ergebnismenge der Treffer zu ordnen, die nach Ausführung derprepareSearch()-Methode zurückgegeben werden.

Wenn Sie mit der Lucene-Abfragesyntax besser vertraut sind, können SiesimpleQueryStringQuery() method to customize search queries: verwenden

QueryBuilder simpleStringQuery = QueryBuilders
  .simpleQueryStringQuery("+John -Doe OR Janette");

Wie Sie wahrscheinlich erraten können,we can use the Lucene’s Query Parser syntax to build simple, yet powerful queries. Hier sind einige grundlegende Operatoren, die zusammen mit den OperatorenAND/OR/NOTzum Erstellen von Suchanfragen verwendet werden können:

Der erforderliche Operator (+): Erfordert, dass irgendwo in den Feldern eines Dokuments ein bestimmter Text vorhanden ist.
Der Verbotsoperator (–): Schließt alle Dokumente aus, die ein Schlüsselwort enthalten, das nach dem Symbol (–) deklariert ist.

6. Fazit

In diesem kurzen Artikel haben wir gesehen, wie Sie die Java-API von ElasticSearch verwenden, um einige der allgemeinen Funktionen von Volltextsuchmaschinen auszuführen.

Sie können das in diesem Artikel bereitgestellte Beispiel inGitHub project überprüfen.

TOC

Anleitung zur Elasticsearch in Java