spring-boot
Spring Boot + Spring Data Elasticsearch

Wprowadzenie

Integracja Spring Boot i Spring Data Elasticsearch

W tym przykładzie zamierzamy wdrożyć projekt sprężyn danych i elasticsearch do przechowywania POJO w elasticsearch. Zobaczymy przykładowy projekt maven, który wykonuje następujące czynności:

• Wstaw element Greeting(id, username, message) do elasticsearch.
• Zdobądź wszystkie elementy powitania, które zostały wstawione.
• Zaktualizuj element powitania.
• Usuń element powitania.
• Zdobądź Pozdrowienie id.
• Zdobądź wszystkie elementy powitania według nazwy użytkownika.

Spring boot i integracja elastycznego wyszukiwania danych wiosennych

W tym przykładzie zobaczymy aplikację wiosennego rozruchu opartą na maven, która integruje sprężyste wyszukiwanie danych elastycznych. Tutaj wykonamy następujące czynności i zobaczymy odpowiednie segmenty kodu.

• Wstaw element Greeting(id, username, message) do elasticsearch.
• Zbierz wszystkie przedmioty z elasticsearch
• Zaktualizuj konkretny element.
• Usuń konkretny element.
• Zdobądź konkretny przedmiot według identyfikatora.
• Uzyskaj konkretny element według nazwy użytkownika.

Plik konfiguracyjny projektu (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>

Użyjemy Spring Boot wersji 1.5.6.RELEASE i Spring Data Elasticsearch tej odpowiedniej wersji. W tym projekcie musimy uruchomić elasticsearch-2.4.5, aby przetestować nasze API.

Plik właściwości

Plik właściwości projektu (o nazwie applications.properties ) umieścimy w folderze resources który zawiera:

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

Użyjemy domyślnej nazwy klastra, hosta i portu. Domyślnie port 9300 jest używany jako port transportowy, a port 9200 jest znany jako port http. Aby zobaczyć domyślną nazwę klastra, naciśnij http: // localhost: 9200 / .

Główna klasa (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 to połączenie @Configuration , @EnableAutoConfiguration , @EnableWebMvc i @ComponentScan . Metoda main() używa metody SpringApplication.run() Spring Boot do uruchomienia aplikacji. Tam nie potrzebujemy żadnej konfiguracji XML, ta aplikacja jest czystą aplikacją java spring.

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

Klasa ElasticsearchConfig konfiguruje elasticsearch dla tego projektu i tworzy połączenie z elasticsearch. Tutaj @PropertySource służy do odczytu pliku application.properties , w którym przechowujemy nazwę klastra, hosta i portu @PropertySource . @EnableElasticsearchRepositories służy do włączania repozytoriów Elasticsearch, które domyślnie skanują pakiety klasy konfiguracji z adnotacjami w poszukiwaniu repozytoriów Spring Data. @Value służy tutaj do odczytu właściwości z pliku application.properties .

Metoda Client() tworzy połączenie transportowe z elasticsearch. Powyższa konfiguracja konfiguruje wbudowany serwer Elasticsearch, który jest używany przez ElasticsearchTemplate . Fasola ElasticsearchTemplate używa Elasticsearch Client i zapewnia niestandardową warstwę do manipulowania danymi w Elasticsearch.

Klasa modelu (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;
    }
}

Tutaj mamy odnotowany nasze Greeting obiektów danych z @Document adnotacją, że możemy również wykorzystać do określenia ustawień indeksów takich jak nazwy, liczby odłamków lub liczby replik. Jednym z atrybutów klasy musi być id , albo poprzez dodanie adnotacji @Id albo użycie jednego z automatycznie znalezionych nazw id lub documentId . Tutaj wartość pola id zostanie wygenerowana automatycznie, jeśli nie ustawimy żadnej wartości pola id .

Klasa repozytorium 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);
}

Tutaj rozszerzyliśmy ElasticsearchRepository które zapewniają nam wiele apis, których nie musimy definiować zewnętrznie. Jest to podstawowa klasa repozytorium dla klas domen opartych na elasticsearch . Ponieważ rozszerza klasy repozytoriów opartych na Spring , uzyskujemy korzyść polegającą na unikaniu kodu typu „plateplate” wymaganego do implementacji warstw dostępu do danych dla różnych magazynów trwałości.

W tym miejscu zadeklarowaliśmy metodę findByUsername(String username) która skonwertuje na pasujące zapytanie, które pasuje do nazwy użytkownika z polem username obiektów Greeting i zwraca listę wyników.

Usługi (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);
    }
}

W powyższych klasach @Autowired the GreetingRepository . Możemy po prostu wywołać metody CRUDRepository i metodę zadeklarowaną w klasie repozytorium za pomocą obiektu GreetingRepository .

W getAll() możesz znaleźć wiersz Lists.newArrayList(repository.findAll()) . Zrobiliśmy to, aby przekonwertować repository.findAll() na element List<> ponieważ zwraca Listę Iterable .

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

Budować

Aby zbudować tę aplikację maven uruchom

mvn clean install

Powyższe polecenie najpierw usuń wszystkie pliki z folderu target i skompiluj projekt. Po zbudowaniu projektu otrzymamy plik wykonywalny .jar o nazwie springdataes-1.0-SNAPSHOT.jar . Możemy uruchomić klasę główną ( Application.java ), aby rozpocząć proces lub po prostu wykonać powyższy jar, wpisując:

java -jar springdataes-1.0-SNAPSHOT.jar

Sprawdzanie interfejsów API

Aby wstawić element powitania w wyszukiwaniu elastycznym, wykonaj poniższe polecenie

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

Powinieneś otrzymać poniższy wynik jak

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

Możesz także sprawdzić get api, wykonując:

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

Powinieneś wziąć

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

Możesz sprawdzić inne api, wykonując powyższe procesy.

Oficjalne dokumenty:

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