Reactive Elasticsearch Repositories

Reactive Elasticsearch repository support builds on the core repository support explained in Repositories utilizing operations provided via Reactive Elasticsearch Operations executed by a Reactive REST Client.

Spring Data Elasticsearch reactive repository support uses Project Reactor as its reactive composition library of choice.

There are 3 main interfaces to be used:

ReactiveRepository
ReactiveCrudRepository
ReactiveSortingRepository

Usage

To access domain objects stored in a Elasticsearch using a Repository, just create an interface for it. Before you can actually go on and do that you will need an entity.

Example 1. Sample Person entity

public class Person {

  @Id
  private String id;
  private String firstname;
  private String lastname;
  private Address address;

  // … getters and setters omitted
}

Please note that the id property needs to be of type String.

Example 2. Basic repository interface to persist Person entities

interface ReactivePersonRepository extends ReactiveSortingRepository<Person, String> {

  Flux<Person> findByFirstname(String firstname);                                   (1)

  Flux<Person> findByFirstname(Publisher<String> firstname);                        (2)

  Flux<Person> findByFirstnameOrderByLastname(String firstname);                    (3)

  Flux<Person> findByFirstname(String firstname, Sort sort);                        (4)

  Flux<Person> findByFirstname(String firstname, Pageable page);                    (5)

  Mono<Person> findByFirstnameAndLastname(String firstname, String lastname);       (6)

  Mono<Person> findFirstByLastname(String lastname);                                (7)

  @Query("{ \"bool\" : { \"must\" : { \"term\" : { \"lastname\" : \"?0\" } } } }")
  Flux<Person> findByLastname(String lastname);                                     (8)

  Mono<Long> countByFirstname(String firstname)                                     (9)

  Mono<Boolean> existsByFirstname(String firstname)                                 (10)

  Mono<Long> deleteByFirstname(String firstname)                                    (11)
}

1	The method shows a query for all people with the given `lastname`.
2	Finder method awaiting input from `Publisher` to bind parameter value for `firstname`.
3	Finder method ordering matching documents by `lastname`.
4	Finder method ordering matching documents by the expression defined via the `Sort` parameter.
5	Use `Pageable` to pass offset and sorting parameters to the database.
6	Finder method concating criteria using `And` / `Or` keywords.
7	Find the first matching entity.
8	The method shows a query for all people with the given `lastname` looked up by running the annotated `@Query` with given parameters.
9	Count all entities with matching `firstname`.
10	Check if at least one entity with matching `firstname` exists.
11	Delete all entities with matching `firstname`.

Configuration

For Java configuration, use the @EnableReactiveElasticsearchRepositories annotation. If no base package is configured, the infrastructure scans the package of the annotated configuration class.

The following listing shows how to use Java configuration for a repository:

Example 3. Java configuration for repositories

@Configuration
@EnableReactiveElasticsearchRepositories
public class Config extends AbstractReactiveElasticsearchConfiguration {

  @Override
  public ReactiveElasticsearchClient reactiveElasticsearchClient() {
    return ReactiveRestClients.create(ClientConfiguration.localhost());
  }
}

Because the repository from the previous example extends ReactiveSortingRepository, all CRUD operations are available as well as methods for sorted access to the entities. Working with the repository instance is a matter of dependency injecting it into a client, as the following example shows:

Example 4. Sorted access to Person entities

public class PersonRepositoryTests {

  @Autowired ReactivePersonRepository repository;

  @Test
  public void sortsElementsCorrectly() {

    Flux<Person> persons = repository.findAll(Sort.by(new Order(ASC, "lastname")));

    // ...
  }
}