Inleiding tot Spring Data Elasticsearch

1. Overzicht

In deze tutorial we zullen de basisprincipes van Spring Data Elasticsearch verkennen op een codegerichte en praktische manier.

We laten zien hoe Elasticsearch in een Spring-applicatie kan worden geïndexeerd, gezocht en opgevraagd met Spring Data Elasticsearch. Spring Data Elasticseach is een Spring-module die Spring Data implementeert en zo een manier biedt om te communiceren met de populaire open-source, op Lucene gebaseerde zoekmachine.

Hoewel Elasticsearch zonder nauwelijks gedefinieerd schema kan werken, is het gebruikelijk om er een te ontwerpen en toewijzingen te maken die het type gegevens specificeren dat in bepaalde velden mag worden verwacht.. Wanneer een document wordt geïndexeerd, worden de velden verwerkt volgens hun typen. Een tekstveld wordt bijvoorbeeld getokeniseerd en gefilterd volgens toewijzingsregels. We zouden ook zelf filters en tokenizers kunnen maken.

Eenvoudigheidshalve gebruiken we echter een docker-afbeelding voor onze Elasticsearch-instantie elke Elasticsearch-instantie die luistert op poort 9200 is voldoende.

We beginnen met het opstarten van onze Elasticsearch-instantie:

docker run -d --name es762 -p 9200: 9200 -e "discovery.type = single-node" elasticsearch: 7.6.2

2. Veergegevens

Spring Data helpt standaardcode te vermijden. Als we bijvoorbeeld een repository-interface definiëren die het ElasticsearchRepository interface geleverd door Spring Data Elasticsearch, CRUD-bewerkingen voor de corresponderende documentklasse worden standaard beschikbaar gemaakt.

Bovendien worden, simpelweg door methoden met namen in een voorgedefinieerd formaat te declareren, methode-implementaties voor ons gegenereerd - het is niet nodig om een ​​implementatie van de repository-interface te schrijven.

De Baeldung-gidsen over Spring Data bieden de essentie om met het onderwerp aan de slag te gaan.

2.1. Afhankelijkheid van Maven

Spring Data Elasticsearch biedt een Java API voor de zoekmachine. Om het te kunnen gebruiken, moeten we een nieuwe afhankelijkheid toevoegen aan het pom.xml:

 org.springframework.data spring-data-elasticsearch 4.0.0.RELEASE 

2.2. Repository-interfaces definiëren

Om nieuwe repositories te definiëren, breiden we een van de meegeleverde repository-interfaces uit, waarbij we de generieke typen vervangen door onze huidige document- en primaire sleuteltypen.

Het is belangrijk om dat op te merken ElasticsearchRepository strekt zich uit van PagingAndSortingRepository. Hierdoor is ingebouwde ondersteuning voor paginering en sortering mogelijk.

In ons voorbeeld gebruiken we de paginafunctie in onze aangepaste zoekmethoden:

openbare interface ArticleRepository breidt ElasticsearchRepository uit {Page findByAuthorsName (String naam, Pageable pageable); @Query ("{\" bool \ ": {\" must \ ": [{\" match \ ": {\" auteurs.naam \ ": \"? 0 \ "}}]}}") Pagina findByAuthorsNameUsingCustomQuery (String naam, Pageable pageable); }

Met de findByAuthorsName methode, zal de repository-proxy een implementatie creëren op basis van de naam van de methode. Het resolutie-algoritme zal bepalen dat het toegang moet hebben tot het auteurs eigenschap en zoek vervolgens het naam eigenschap van elk item.

De tweede methode, findByAuthorsNameUsingCustomQuery, gebruikt een aangepaste Elasticsearch booleaanse query, gedefinieerd met de @Query annotatie, waarvoor een strikte overeenkomst tussen de naam van de auteur en het opgegeven naam argument.

2.3. Java-configuratie

Bij het configureren van Elasticsearch in onze Java-applicatie, moeten we definiëren hoe we verbinding maken met de Elasticsearch-instantie. Daarvoor gebruiken we een RestHighLevelClient dat wordt aangeboden door de Elasticsearch-afhankelijkheid:

@Configuration @EnableElasticsearchRepositories (basePackages = "com.baeldung.spring.data.es.repository") @ComponentScan (basePackages = {"com.baeldung.spring.data.es.service"}) public class Config {@Bean public RestHighLevelClient client () {ClientConfiguration clientConfiguration = ClientConfiguration.builder () .connectedTo ("localhost: 9200") .build (); retourneer RestClients.create (clientConfiguration) .rest (); } @Bean openbare ElasticsearchOperations elasticsearchTemplate () {retourneer nieuwe ElasticsearchRestTemplate (client ()); }}

We gebruiken een standaard annotatiestijl met Spring-functie. @EnableElasticsearchRepositories zorgt ervoor dat Spring Data Elasticsearch het meegeleverde pakket voor Spring Data-opslagplaatsen scant.

Om te communiceren met onze Elasticsearch-server gebruiken we een eenvoudig RestHighLevelClient. Hoewel Elasticsearch meerdere soorten clients biedt, gebruikt u de RestHighLevelClient is een goede manier om de communicatie met de server toekomstbestendig te maken.

Ten slotte hebben we een ElasticsearchOperations bean om bewerkingen op onze server uit te voeren. In dit geval instantiëren we een ElasticsearchRestTemplate.

3. Toewijzingen

Mappings worden gebruikt om een ​​schema voor onze documenten te definiëren. Door een schema voor onze documenten te definiëren, beschermen we ze tegen ongewenste resultaten, zoals mapping naar een type dat we niet zouden willen.

Onze entiteit is een eenvoudig document met de naam Artikel waar de ID kaart is van het type Draad. We specificeren ook dat dergelijke documenten moeten worden opgeslagen in een index met de naam blog binnen de artikel type.

@Document (indexName = "blog", type = "article") openbare klasse Artikel {@Id privé String-id; private String-titel; @Field (type = FieldType.Nested, includeInParent = true) auteurs van privélijsten; // standaard getters en setters}

Indexen kunnen verschillende typen hebben. We kunnen die functie gebruiken om hiërarchieën te implementeren.

De auteurs veld is gemarkeerd als FieldType.Nested. Dit stelt ons in staat om de Schrijver class afzonderlijk, maar de individuele instanties van auteur hebben ingebed in een Artikel document wanneer het wordt geïndexeerd in Elasticsearch.

4. Indexeren van documenten

Spring Data Elasticsearch maakt over het algemeen automatisch indexen op basis van de entiteiten in het project. We kunnen echter ook programmatisch een index maken via de client-sjabloon:

ElasticsearchTemplate.indexOps (Article.class) .create ();

Vervolgens kunnen we documenten aan de index toevoegen:

Artikelartikel = nieuw artikel ("Spring Data Elasticsearch"); article.setAuthors (asList (nieuwe auteur ("John Smith"), nieuwe auteur ("John Doe"))); articleRepository.save (artikel);

5. Opvragen

5.1. Methode op naam gebaseerde zoekopdracht

Wanneer we de methode op naam gebaseerde query gebruiken, schrijven we methoden die de query definiëren die we willen uitvoeren. Tijdens de installatie analyseert Spring Data de handtekening van de methode en maakt de queries dienovereenkomstig aan:

String nameToFind = "John Smith"; Page articleByAuthorName = articleRepository.findByAuthorsName (nameToFind, PageRequest.of (0, 10));

Door te bellen findByAuthorsName met een PageRequest object, krijgen we de eerste pagina met resultaten (paginanummering is gebaseerd op nul), waarbij die pagina maximaal 10 artikelen bevat. Het pagina-object biedt ook het totale aantal treffers voor de zoekopdracht, samen met andere handige pagineringsinformatie.

5.2. Een aangepaste zoekopdracht

Er zijn een aantal manieren om aangepaste query's te definiëren voor Spring Data Elasticsearch-opslagplaatsen. Een manier is om de @Query annotatie, zoals aangetoond in paragraaf 2.2.

Een andere optie is om de querybuilder te gebruiken om onze aangepaste query te maken.

Zoeken naar artikelen met het woord 'gegevens”In de titel kunnen we gewoon een NativeSearchQueryBuilder met een filter op de titel:

Query searchQuery = nieuwe NativeSearchQueryBuilder () .withFilter (regexpQuery ("title", ". * Data. *")) .Build (); SearchHits-artikelen = elasticsearchTemplate.search (searchQuery, Article.class, IndexCoordinates.of ("blog");

6. Bijwerken en verwijderen

Om een ​​document bij te werken, moeten we het eerst ophalen:

String articleTitle = "Spring Data Elasticsearch"; Query searchQuery = nieuwe NativeSearchQueryBuilder () .withQuery (matchQuery ("title", articleTitle) .minimumShouldMatch ("75%")) .build (); SearchHits-artikelen = elasticsearchTemplate.search (searchQuery, Article.class, IndexCoordinates.of ("blog"); Article article = Articles.getSearchHit (0) .getContent ();

Vervolgens kunnen we wijzigingen aanbrengen in het document door de inhoud van het object te bewerken met behulp van de beoordelaars:

article.setTitle ("Aan de slag met zoekmachines"); articleRepository.save (artikel);

Wat het verwijderen betreft, zijn er verschillende opties. We kunnen het document ophalen en verwijderen met de verwijderen methode:

articleRepository.delete (artikel);

We kunnen het ook verwijderen door ID kaart wanneer het bekend is:

articleRepository.deleteById ("article_id");

Het is ook mogelijk om op maat te maken deleteBy vragen en maak gebruik van de bulkverwijderingsfunctie die wordt aangeboden door Elasticsearch:

articleRepository.deleteByTitle ("titel");

7. Conclusie

In deze tutorial hebben we onderzocht hoe je verbinding kunt maken en gebruik kunt maken van Spring Data Elasticsearch. We hebben besproken hoe we documenten kunnen opvragen, bijwerken en verwijderen. Bovendien hebben we ook besproken hoe u aangepaste query's kunt maken en deze passen niet bij wat wordt aangeboden door Spring Data Elasticsearch.

Zoals gewoonlijk is de broncode die in deze tutorial wordt gebruikt, te vinden op GitHub.