ElasticSearch Example

application-dev.properties

#
# Home directory of the embedded Elasticsearch instance. Default to the
# current working directory.
#
spring.data.elasticsearch.properties.path.home=target/elastic-embedded
spring.data.elasticsearch.properties.transport.tcp.connect_timeout=60s

ElasticSearchConfig.java

package com.station.config.interfaces;

public interface ElasticSearchConfig {
}

ElasticSearchDevConfig.java

package com.station.config;

import com.station.config.interfaces.ElasticSearchConfig;
import com.station.elasticModel.FleteroContrato;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import static org.elasticsearch.node.NodeBuilder.nodeBuilder;

@Configuration
@Profile("dev")
@EnableElasticsearchRepositories(basePackages = "com.station.elasticRepositories")
public class ElasticSearchDevConfig implements ElasticSearchConfig {

    //Embedded Elasticsearch Server
    @Bean
    public ElasticsearchOperations elasticsearchTemplate() {
        return new ElasticsearchTemplate(nodeBuilder().local(true).node().client());
    }
}

ElasticTest.java

package com.station.fletz;

import com.station.elasticModel.FleteroContrato;
import com.station.services.interfaces.FleteroContratoService;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Description;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.query.*;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

import static org.elasticsearch.index.query.QueryBuilders.matchPhraseQuery;
import static org.hamcrest.core.Is.is;
import static org.hamcrest.core.IsNull.notNullValue;
import static org.junit.Assert.*;

@RunWith(SpringRunner.class)
@SpringBootTest
@ActiveProfiles("dev")
public class ElasticTest {

    @Autowired
    private FleteroContratoService fleteroContratoService;

    @Autowired
    private ElasticsearchOperations elasticsearchTemplate;

    private FleteroContrato fleteroContrato;

    @Before
    public void init() {
        this.fleteroContrato = FleteroContrato.builder()
                .idFletero("123")
                .largaDistancia(true)
                .precioKilometro(235.4)
                .build();
        //Delete all documents for consistent test
        dropIndex(FleteroContrato.class);
    }

    @Test
    public void insertTest() {
        FleteroContrato result = fleteroContratoService.save(this.fleteroContrato);
        assertNotNull(result);
    }

    @Test
    @Description("Siempre que se limpie el indice 'contrato' en el método init() no deben existir documentos en ese indice")
    public void findZeroByDefaultIndexUsingIdFleteroTest() {
        String idFletero = "123";
        Page<FleteroContrato> result = fleteroContratoService.findByIdFletero(idFletero, new PageRequest(0,1));
        assertNotNull(result);
        assertEquals(0,result.getTotalElements());
    }

    @Test
    public void listAllTest() {
        FleteroContrato result = fleteroContratoService.save(
                FleteroContrato.builder().idFletero("456")
                .precioKilometro(126.7)
                .largaDistancia(false)
                .build()
        );
        assertNotNull(result);
        assertEquals(1L, fleteroContratoService.findAll().size());
    }

    @Test
    public void shouldExecuteGivenCriteriaQueryAndGetOneFleteroContrato() {
        // given
        FleteroContrato fc = fleteroContratoService.save(
                FleteroContrato.builder().idFletero("456")
                        .precioKilometro(126.7)
                        .largaDistancia(false)
                        .clausulas("El cliente debe proveer del ayudante. Solo se provee el transporte")
                        .build()
        );

        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("clausulas").contains("ayudante"));

        // when
        FleteroContrato result = elasticsearchTemplate.queryForObject(criteriaQuery, FleteroContrato.class);
        // then
        assertThat(result, is(notNullValue()));
    }

    @Test
    public void shouldExecuteGivenCriteriaQueryAndGetListFleteroContrato() {
        // given
        //a contract
        fleteroContratoService.save(
                FleteroContrato.builder().idFletero("456")
                        .precioKilometro(126.7)
                        .largaDistancia(false)
                        .clausulas("El cliente debe proveer del ayudante. Solo se provee el transporte")
                        .build()
        );
        //and another
        fleteroContratoService.save(
                FleteroContrato.builder().idFletero("225")
                        .precioKilometro(145.1)
                        .largaDistancia(true)
                        .clausulas("El ayudante solo trabaja por la mañana. El transportista hace de ayudante")
                        .build()
        );

        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("clausulas").contains("ayudante"));

        // when
        List<FleteroContrato> result = elasticsearchTemplate.queryForList(criteriaQuery, FleteroContrato.class);
        // then
        assertThat(result, is(notNullValue()));
        assertThat(result.size(), is(2));
    }
    
    @Test
    public void deleteOneEntityTest() {
        //given fleteroContrato loaded at init()

        //when
        //save at Elastic Search Server
        FleteroContrato result = this.fleteroContratoService.save(fleteroContrato);
        assertNotNull(result);

        //then
        this.fleteroContratoService.delete(result);
        assertThat(null, is(this.fleteroContratoService.findOne(result.getId())));

    }

    //for init the index, used by @Before
    private void dropIndex(Class<?> index) {
        elasticsearchTemplate.deleteIndex(index);
        elasticsearchTemplate.createIndex(index);
        elasticsearchTemplate.putMapping(index);
        elasticsearchTemplate.refresh(index);
    }
}

FleteroContrato.java

package com.station.elasticModel;

import lombok.Builder;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;

import java.io.Serializable;

@Data
@Builder
@Document(indexName = "contrato", type = "fletero_contrato")
public class FleteroContrato implements Serializable {

    @Id
    private String id;
    private String idFletero;
    private Double precioKilometro;
    private Boolean largaDistancia;
    private String clausulas;
}

FleteroContratoRepository.java

package com.station.elasticRepositories;

import com.station.elasticModel.FleteroContrato;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

public interface FleteroContratoRepository extends ElasticsearchRepository<FleteroContrato, String> {

    Page<FleteroContrato> findByIdFletero(String idFletero, Pageable page);
}

FleteroContratoService.java

package com.station.services.interfaces;

import com.station.elasticModel.FleteroContrato;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;

import java.util.Collection;

public interface FleteroContratoService {

    FleteroContrato save(FleteroContrato contrato);

    void delete(FleteroContrato contrato);

    FleteroContrato findOne(String id);

    Collection<FleteroContrato> findAll();

    Page<FleteroContrato> findByIdFletero(String idFletero, PageRequest pageRequest);

}

FleteroContratoServiceImpl.java

package com.station.services.implementations;

import com.google.common.collect.Lists;
import com.station.elasticModel.FleteroContrato;
import com.station.elasticRepositories.FleteroContratoRepository;
import com.station.services.interfaces.FleteroContratoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;

import java.util.Collection;

@Service
public class FleteroContratoServiceImp implements FleteroContratoService {

    @Autowired
    private FleteroContratoRepository fleteroContratoRepository;

    @Override
    public FleteroContrato save(FleteroContrato contrato) {
        return fleteroContratoRepository.save(contrato);
    }

    @Override
    public void delete(FleteroContrato contrato) {
        fleteroContratoRepository.delete(contrato);
    }

    @Override
    public FleteroContrato findOne(String id) {
        return fleteroContratoRepository.findOne(id);
    }

    @Override
    public Collection<FleteroContrato> findAll() {
        return Lists.newArrayList(fleteroContratoRepository.findAll());
    }

    @Override
    public Page<FleteroContrato> findByIdFletero(String idFletero, PageRequest pageRequest) {
        return fleteroContratoRepository.findByIdFletero(idFletero, pageRequest);
    }
}

pom.xml

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