spring-boot
Spring Boot + Spring Data Elasticsearch

introduzione

Spring Boot e Spring Data Elasticsearch integrazione

In questo esempio implementeremo il progetto spring-data-elasticsearch per memorizzare POJO in elasticsearch. Vedremo un esempio di progetto Maven che esegue le seguenti operazioni:

• Inserisci un oggetto Greeting(id, username, message) su elasticsearch.
• Ricevi tutti gli articoli di auguri che sono stati inseriti.
• Aggiorna un elemento di saluto.
• Elimina un elemento di saluto.
• Ottieni un oggetto di auguri per id.
• Ottieni tutti gli articoli di auguri per nome utente.

Spring boot e primavera dati elasticsearch integrazione

In questo esempio vedremo un'applicazione di avvio a molla basata su Maven che integra spring-data-elasticsearch. Qui, faremo quanto segue e vedremo i rispettivi segmenti di codice.

• Inserisci un oggetto Greeting(id, username, message) su elasticsearch.
• Ottieni tutti gli oggetti da elasticsearch
• Aggiorna un articolo specifico.
• Elimina un elemento specifico.
• Ottieni un oggetto specifico per ID.
• Ottieni un oggetto specifico per nome utente.

File di configurazione del progetto (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>

Useremo Spring Boot della versione 1.5.6.RELEASE e Spring Data Elasticsearch di quella rispettiva versione. Per questo progetto, dobbiamo eseguire elasticsearch-2.4.5 per testare le nostre API.

File delle proprietà

Inseriremo il file delle proprietà del progetto (denominato applications.properties ) nella cartella delle resources che contiene:

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

Utilizzeremo il nome cluster, l'host e la porta predefiniti. Per impostazione predefinita, la porta 9300 viene utilizzata come porta di trasporto e la porta 9200 è nota come porta http. Per vedere il nome del cluster predefinito, premi http: // localhost: 9200 / .

Classe principale (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 è una combinazione di @Configuration , @EnableAutoConfiguration , @EnableWebMvc e @ComponentScan . Il metodo main() usa il metodo SpringApplication.run() Spring Boot per avviare un'applicazione. Non abbiamo bisogno di alcuna configurazione xml, questa applicazione è pura applicazione java spring.

Classe di configurazione Elasticsearch (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 classe ElasticsearchConfig configura elasticsearch per questo progetto e crea una connessione con elasticsearch. Qui, @PropertySource viene utilizzato per leggere il file application.properties cui archiviamo il nome del cluster, l'host elasticsearch e la porta. @EnableElasticsearchRepositories viene utilizzato per abilitare i repository Elasticsearch che @EnableElasticsearchRepositories la scansione dei pacchetti della classe di configurazione annotata per gli archivi Spring Data per impostazione predefinita. @Value è usato qui per leggere le proprietà dal file application.properties .

Il metodo Client() crea una connessione di trasporto con elasticsearch. La configurazione precedente imposta un server Elasticsearch incorporato utilizzato da ElasticsearchTemplate . Il bean ElasticsearchTemplate utilizza Elasticsearch Client e fornisce un livello personalizzato per la manipolazione dei dati in Elasticsearch.

Model Class (Greeting.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;
    }
}

Qui abbiamo annotato i nostri oggetti di dati di Greeting con un'annotazione @Document che possiamo anche usare per determinare le impostazioni dell'indice come nome, numero di frammenti o numero di repliche. Uno degli attributi della classe deve essere un id , annotandolo con @Id o usando uno dei nomi trovati automaticamente id o documentId . Qui, il valore del campo id verrà generato automaticamente, se non impostiamo alcun valore del campo id .

Classe di deposito Elasticsearch (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);
}

Qui, abbiamo esteso ElasticsearchRepository che fornisce molte delle API che non è necessario definire esternamente. Questa è la classe di repository di base per le classi di dominio basate su elasticsearch . Poiché estende le classi di repository basate su Spring , otteniamo il vantaggio di evitare il codice boilerplate richiesto per implementare i livelli di accesso ai dati per vari archivi di persistenza.

Qui abbiamo dichiarato un metodo findByUsername(String username) che convertirà in una query di corrispondenza che corrisponde al nome utente con il campo username di oggetti Greeting e restituisce l'elenco dei risultati.

Servizi (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);
    }
}

Nella suddetta classe, abbiamo @Autowired il @Autowired dei GreetingRepository . Possiamo semplicemente chiamare i metodi CRUDRepository e il metodo che abbiamo dichiarato nella classe repository con l'oggetto GreetingRepository .

Nel metodo getAll() , è possibile trovare una riga Lists.newArrayList(repository.findAll()) . Abbiamo fatto questo per convertire repository.findAll() in List<> item in quanto restituisce un Iterable List.

Controller Class (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);
    }
}

Costruire

Per costruire questa esecuzione di applicazioni Maven

mvn clean install

Prima di tutto, rimuovere tutti i file nella cartella di target e creare il progetto. Dopo aver springdataes-1.0-SNAPSHOT.jar il progetto, otterremo il file eseguibile .jar che è chiamato springdataes-1.0-SNAPSHOT.jar . Possiamo eseguire la classe principale ( Application.java ) per avviare il processo o semplicemente eseguire il jar sopra digitando:

java -jar springdataes-1.0-SNAPSHOT.jar

Controllo delle API

Per inserire un oggetto Saluto in elasticsearch, eseguire il comando seguente

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

Dovresti ottenere il seguente risultato come

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

Puoi anche controllare l'API get eseguendo:

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

Dovresti ricevere

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

È possibile controllare altre apis seguendo i processi di cui sopra.

Documentazione ufficiale:

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