spring-boot
Spring Boot + Spring Data Elasticsearch

Einführung

Integration von Spring Boot und Spring Data Elasticsearch

In diesem Beispiel werden wir ein Feder-Daten-Elasticsearch-Projekt implementieren, um POJO in der Elasticsearch zu speichern. Wir werden ein Musterprojekt sehen, das folgende Aufgaben erfüllt:

• Fügen Sie ein Greeting(id, username, message) in elasticsearch ein.
• Alle Begrüßungselemente abrufen, die eingefügt wurden.
• Aktualisieren Sie ein Grußelement.
• Löschen Sie ein Begrüßungselement.
• Bekommen Sie einen Begrüßungsartikel nach ID.
• Holen Sie sich alle Begrüßungsartikel nach Benutzername.

Spring Boot und Spring Data Elasticsearch Integration

In diesem Beispiel sehen wir eine Maven-basierte Federstiefelanwendung, die die Federdaten-Elasticsuche integriert. Hier werden wir Folgendes tun und die entsprechenden Codesegmente sehen.

• Fügen Sie ein Greeting(id, username, message) in elasticsearch ein.
• Holen Sie sich alle Artikel von elasticsearch
• Aktualisieren Sie ein bestimmtes Element.
• Einen bestimmten Artikel löschen
• Holen Sie sich einen bestimmten Artikel nach ID.
• Holen Sie sich einen bestimmten Artikel nach Benutzername.

Projektkonfigurationsdatei (pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.springdataes</groupId>
    <artifactId>springdataes</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Wir werden Spring Boot der Version 1.5.6.RELEASE und Spring Data Elasticsearch der jeweiligen Version verwenden. Für dieses Projekt müssen wir elasticsearch-2.4.5 ausführen, um unsere Apis zu testen.

Eigenschaftendatei

Wir legen die Projekteigenschaftsdatei (namens applications.properties ) im resources Folgendes enthält:

elasticsearch.clustername = elasticsearch
elasticsearch.host = localhost
elasticsearch.port = 9300

Wir verwenden den Standard-Clusternamen, Host und Port. Standardmäßig wird der 9300 Port als Transportport verwendet und der 9200 Port wird als http-Port bezeichnet. Um den Standard-Clusternamen anzuzeigen, klicken Sie auf http: // localhost: 9200 / .

Hauptklasse (Application.java)

package org.springdataes;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String []args) {
        SpringApplication.run(Application.class, args);
    }
}

@SpringBootApplication ist eine Kombination aus @Configuration @EnableAutoConfiguration , @EnableWebMvc @Configuration , @EnableAutoConfiguration @EnableWebMvc und @ComponentScan Anmerkungen. Die main() -Methode verwendet die SpringApplication.run() -Methode von Spring Boot, um eine Anwendung zu starten. Da wir keine XML-Konfiguration benötigen, handelt es sich bei dieser Anwendung um eine reine Java-Frühling-Anwendung.

Elasticsearch-Konfigurationsklasse (ElasticsearchConfig.java)

package org.springdataes.config;

import org.elasticsearch.client.Client;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;

import java.net.InetAddress;

@Configuration
@PropertySource(value = "classpath:applications.properties")
@EnableElasticsearchRepositories(basePackages = "org.springdataes.dao")
public class ElasticsearchConfig {
    @Value("${elasticsearch.host}")
    private String EsHost;

    @Value("${elasticsearch.port}")
    private int EsPort;

    @Value("${elasticsearch.clustername}")
    private String EsClusterName;

    @Bean
    public Client client() throws Exception {
        Settings esSettings = Settings.settingsBuilder()
                .put("cluster.name", EsClusterName)
                .build();

        return TransportClient.builder()
                .settings(esSettings)
                .build()
                .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(EsHost), EsPort));
    }

    @Bean
    public ElasticsearchOperations elasticsearchTemplate() throws Exception {
        return new ElasticsearchTemplate(client());
    }
}

ElasticsearchConfig Klasse ElasticsearchConfig konfiguriert die ElasticsearchConfig für dieses Projekt und stellt eine Verbindung mit der ElasticsearchConfig . Hier wird @PropertySource zum Lesen der Datei application.properties verwendet, in der der Clustername, der Elasticsearch-Host und der Port gespeichert werden. @EnableElasticsearchRepositories wird verwendet, um Elasticsearch-Repositorys zu aktivieren, die die Pakete der annotierten Konfigurationsklasse standardmäßig nach Spring Data-Repositorys scannen. @Value wird hier zum Lesen der Eigenschaften aus der Datei application.properties verwendet.

Die Client() Methode erstellt eine Transportverbindung mit Elasticsearch. Die obige Konfiguration richtet einen Embedded Elasticsearch Server ein, der vom ElasticsearchTemplate . Die Bean " ElasticsearchTemplate verwendet den Elasticsearch Client und stellt eine benutzerdefinierte Ebene zum Bearbeiten von Daten in Elasticsearch bereit.

Modellklasse (Gruß.java)

package org.springdataes.model;

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import java.io.Serializable;

@Document(indexName = "index", type = "greetings")
public class Greeting implements Serializable{

    @Id
    private String id;

    private String username;

    private String message;

    public Greeting() {
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

Hier haben wir unsere Greeting mit einer @Document-Annotation versehen, mit der wir auch Indexeinstellungen wie Name, Anzahl der Shards oder Anzahl der Repliken ermitteln können. Eines der Attribute der Klasse muss eine id , entweder durch Annotation mit @Id oder durch Verwendung eines der automatisch gefundenen Namen id oder documentId . Hier wird der id -Feldwert automatisch generiert, wenn wir keinen Wert für das id Feld festlegen.

Elasticsearch-Repository-Klasse (GreetingRepository.class)

package org.springdataes.dao;

import org.springdataes.model.Greeting;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import java.util.List;

public interface GreetingRepository extends ElasticsearchRepository<Greeting, String> {
    List<Greeting> findByUsername(String username);
}

Hier haben wir das ElasticsearchRepository erweitert, das uns viele Apis bietet, die wir nicht extern definieren müssen. Dies ist die Basis-Repository-Klasse für elasticsearch basierte Domänenklassen. Da Spring basierte Repository-Klassen erweitert werden, haben wir den Vorteil, dass der für die Implementierung von Datenzugriffsschichten für verschiedene Persistenzspeicher erforderliche Boilerplate-Code vermieden wird.

Hier haben wir eine Methode findByUsername(String username) deklariert, die in eine Übereinstimmungsabfrage konvertiert wird, die mit dem Benutzernamen mit dem username der Greeting übereinstimmt und die Ergebnisliste zurückgibt.

Dienste (GreetingService.java)

package org.springdataes.service;

import org.springdataes.model.Greeting;
import java.util.List;

public interface GreetingService {
    List<Greeting> getAll();
    Greeting findOne(String id);
    Greeting create(Greeting greeting);
    Greeting update(Greeting greeting);
    List<Greeting> getGreetingByUsername(String username);
    void delete(String id);
}

Service Bean (GreetingServiceBean.java)

package org.springdataes.service;

import com.google.common.collect.Lists;
import org.springdataes.dao.GreetingRepository;
import org.springdataes.model.Greeting;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class GreetingServiceBean implements GreetingService {

    @Autowired
    private GreetingRepository repository;

    @Override
    public List<Greeting> getAll() {
        return Lists.newArrayList(repository.findAll());
    }

    @Override
    public Greeting findOne(String id) {
        return repository.findOne(id);
    }

    @Override
    public Greeting create(Greeting greeting) {
        return repository.save(greeting);
    }

    @Override
    public Greeting update(Greeting greeting) {
        Greeting persitedGreeting = repository.findOne(greeting.getId());
        if(persitedGreeting == null) {
            return null;
        }
        return repository.save(greeting);
    }

    @Override
    public List<Greeting> getGreetingByUsername(String username) {
        return repository.findByUsername(username);
    }

    @Override
    public void delete(String id) {
        repository.delete(id);
    }
}

In oben Klasse haben wir @Autowired die GreetingRepository . Wir können einfach die CRUDRepository Methoden und die von uns in der Repository-Klasse mit dem GreetingRepository Objekt deklarierte Methode aufrufen.

In der getAll() -Methode finden Sie möglicherweise eine Zeile Lists.newArrayList(repository.findAll()) . Wir haben dies getan, um repository.findAll() in List<> Iterable zu konvertieren, da es eine Iterable List Iterable .

Controller-Klasse (GreetingController.java)

package org.springdataes.controller;

import org.springdataes.model.Greeting;
import org.springdataes.service.GreetingService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api")
public class GreetingController {

    @Autowired
    private GreetingService greetingService;

    @ResponseBody
    @RequestMapping(value = "/greetings", method = RequestMethod.GET)
    public ResponseEntity<List<Greeting>> getAll() {
        return new ResponseEntity<List<Greeting>>(greetingService.getAll(), HttpStatus.OK);
    }

    @ResponseBody
    @RequestMapping(value = "/greetings", method = RequestMethod.POST)
    public ResponseEntity<Greeting> insertGreeting(@RequestBody Greeting greeting) {
        return new ResponseEntity<Greeting>(greetingService.create(greeting), HttpStatus.CREATED);
    }

    @ResponseBody
    @RequestMapping(value = "/greetings", method = RequestMethod.PUT)
    public ResponseEntity<Greeting> updateGreeting(@RequestBody Greeting greeting) {
        return new ResponseEntity<Greeting>(greetingService.update(greeting), HttpStatus.MOVED_PERMANENTLY);
    }

    @ResponseBody
    @RequestMapping(value = "/greetings/{id}", method = RequestMethod.DELETE)
    public ResponseEntity<Greeting> deleteGreeting(@PathVariable("id") String idd) {
        greetingService.delete(idd);
        return new ResponseEntity<Greeting>(HttpStatus.NO_CONTENT);
    }

    @ResponseBody
    @RequestMapping(value = "/greetings{id}", method = RequestMethod.POST)
    public ResponseEntity<Greeting> getOne(@PathVariable("id") String idd) {
        return new ResponseEntity<Greeting>(greetingService.findOne(idd), HttpStatus.OK);
    }

    @ResponseBody
    @RequestMapping(value = "/greetings/{name}", method = RequestMethod.GET)
    public ResponseEntity<List<Greeting>> getByUserName(@PathVariable("name") String name) {
        return new ResponseEntity<List<Greeting>>(greetingService.getGreetingByUsername(name), HttpStatus.OK);
    }
}

Bauen

So erstellen Sie diese Maven-Anwendung

mvn clean install

Obiger Befehl entfernen Sie zuerst alle Dateien im target und das Projekt. Nach dem springdataes-1.0-SNAPSHOT.jar des Projekts erhalten Sie die ausführbare .jar-Datei mit dem Namen springdataes-1.0-SNAPSHOT.jar . Wir können die Hauptklasse ( Application.java ) ausführen, um den Prozess zu starten, oder indem Sie einfach den obigen Jar ausführen, indem Sie Folgendes eingeben:

java -jar springdataes-1.0-SNAPSHOT.jar

Überprüfen der APIs

Führen Sie den folgenden Befehl aus, um ein Begrüßungselement in die Elasticsearch einzufügen

curl -H "Content-Type: application/json" -X POST -d '{"username":"sunkuet02","message": "this is a message"}' http://localhost:8080/api/greetings

Sie sollten das untenstehende Ergebnis gerne erhalten

{"id":"AV2ddRxBcuirs1TrVgHH","username":"sunkuet02","message":"this is a message"}

Sie können die Get-API auch überprüfen, indem Sie Folgendes ausführen:

curl -H "Content-Type: application/json" -X GET http://localhost:8080/api/greetings

Du solltest bekommen

[{"id":"AV2ddRxBcuirs1TrVgHH","username":"sunkuet02","message":"this is a message"}]

Sie können andere Apis überprüfen, indem Sie die obigen Schritte befolgen.

Offizielle Dokumentationen:

• https://projects.spring.io/spring-boot/
• https://projects.spring.io/spring-data-elasticsearch/