Spring Data Elasticsearch

https://github.com/spring-projects/spring-data-elasticsearch
Admin
Spring Data Elasticsearch provides integration with Elasticsearch search engine, enabling...
Tokens:641,634
Snippets:3,689
Trust Score:9.7
License:Apache-2.0
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### ClientConfiguration builder with headers, SSL, proxy, timeouts, and callbacks

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/clients.adoc

Shows a comprehensive ClientConfiguration setup using the builder pattern. It sets default headers, connects to multiple hosts, enables SSL, sets a proxy, path prefix, timeouts, basic auth, a dynamic header supplier, and a client configurer callback. Note that the header supplier must not block in reactive setups.

```java
import static org.springframework.data.elasticsearch.client.elc.ElasticsearchClients.*;

HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.add("some-header", "on every request")                      <1>

ClientConfiguration clientConfiguration = ClientConfiguration.builder()
  .connectedTo("localhost:9200", "localhost:9291")                      <2>
  .usingSsl()                                                           <3>
  .withProxy("localhost:8888")                                          <4>
  .withPathPrefix("ela")                                                <5>
  .withConnectTimeout(Duration.ofSeconds(5))                            <6>
  .withSocketTimeout(Duration.ofSeconds(3))                             <7>
  .withDefaultHeaders(defaultHeaders)                                   <8>
  .withBasicAuth(username, password)                                    <9>
  .withHeaders(() -> {                                                  <10>
    HttpHeaders headers = new HttpHeaders();
    headers.add("currentTime", LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    return headers;
  })
  .withClientConfigurer(                                                <11>
    ElasticsearchHttpClientConfigurationCallback.from(clientBuilder -> {
  	  // ...
      return clientBuilder;
  	}))
  . // ... other options
  .build();
```

--------------------------------

### Type hints with @TypeAlias example

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/object-mapping.adoc

Shows how to use @TypeAlias to configure a custom type hint. The alias is used when writing the entity.

```java
@TypeAlias("human")                <1>
public class Person {

  @Id String id;
  // ...
}
```

```json
{
  "_class" : "human",              <1>
  "id" : ...
}
```

--------------------------------

### Repository Query Methods

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/elasticsearch-repository-queries.adoc

Examples of repository method declarations and the corresponding Elasticsearch queries generated for various keywords.

```APIDOC
## Repository Query Methods

### Description
Repository methods can be defined with specific keywords to generate Elasticsearch queries automatically. The following examples show the method signature and the resulting query body.

### Method
Repository method

### Endpoint
N/A (Repository method)

### Parameters
- **names** (Collection<String>) - Required - The collection of values for the `NotIn` query.
- **available** (boolean) - Required - The boolean value for `True`/`False` queries.
- **name** (String) - Required - The field name for `Exists`, `IsNull`, `IsNotNull`, `IsEmpty`, `IsNotEmpty` queries.

### Request Example
```java
findByNameNotIn(Collection<String> names)
findByAvailableTrue()
findByAvailableFalse()
findByAvailableTrueOrderByNameDesc()
findByNameExists()
findByNameIsNull()
findByNameIsNotNull()
findByNameIsEmpty()
findByNameIsNotEmpty()
```

### Response
#### Success Response (200)
- **query** (object) - The generated Elasticsearch query.

#### Response Example
```json
{
  "query": {
    "bool": {
      "must": [
        {
          "bool": {
            "must_not": [
              {
                "terms": {
                  "name": ["?", "?"]
                }
              }
            ]
          }
        }
      ]
    }
  }
}
```

```json
{
  "query": {
    "bool": {
      "must": [
        {
          "query_string": {
            "query": "NOT(\"?\" \"?\")",
            "fields": ["name"]
          }
        }
      ]
    }
  }
}
```

```json
{
  "query": {
    "bool": {
      "must": [
        {
          "query_string": {
            "query": "true",
            "fields": ["available"]
          }
        }
      ]
    }
  }
}
```

```json
{
  "query": {
    "bool": {
      "must": [
        {
          "query_string": {
            "query": "false",
            "fields": ["available"]
          }
        }
      ]
    }
  }
}
```

```json
{
  "query": {
    "bool": {
      "must": [
        {
          "query_string": {
            "query": "true",
            "fields": ["available"]
          }
        }
      ]
    }
  },
  "sort": [
    {
      "name": {
        "order": "desc"
      }
    }
  ]
}
```

```json
{
  "query": {
    "bool": {
      "must": [
        {
          "exists": {
            "field": "name"
          }
        }
      ]
    }
  }
}
```

```json
{
  "query": {
    "bool": {
      "must_not": [
        {
          "exists": {
            "field": "name"
          }
        }
      ]
    }
  }
}
```

```json
{
  "query": {
    "bool": {
      "must": [
        {
          "exists": {
            "field": "name"
          }
        }
      ]
    }
  }
}
```

```json
{
  "query": {
    "bool": {
      "must": [
        {
          "bool": {
            "must": [
              {
                "exists": {
                  "field": "name"
                }
              }
            ],
            "must_not": [
              {
                "wildcard": {
                  "name": {
                    "wildcard": "*"
                  }
                }
              }
            ]
          }
        }
      ]
    }
  }
}
```

```json
{
  "query": {
    "bool": {
      "must": [
        {
          "wildcard": {
            "name": {
              "wildcard": "*"
            }
          }
        }
      ]
    }
  }
}
```
```

--------------------------------

### Range type example with custom class

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/object-mapping.adoc

Shows how to map a range field using a custom class with @Field annotations for 'gte' and 'lte'.

```java
class SomePersonData {

    @Field(type = FieldType.Integer_Range)
    private ValidAge validAge;

    // getter and setter
}

class ValidAge {
    @Field(name="gte")
    private Integer from;

    @Field(name="lte")
    private Integer to;

    // getter and setter
}
```

--------------------------------

### Run integration tests with Maven wrapper

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/TESTING.adoc

Executes integration tests. Requires Docker to be running, as tests use Docker to start an Elasticsearch server.

```bash
./mvnw verify
```

--------------------------------

### Java repository and service example using Spring Data Repositories

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/README.adoc

Shows a PersonRepository extending CrudRepository with custom finder methods and a MyService that uses the repository to delete, save, and query Person entities. Demonstrates the basic usage of Spring Data Elasticsearch repositories.

```java
public interface PersonRepository extends CrudRepository<Person, Long> {

  List<Person> findByLastname(String lastname);

  List<Person> findByFirstnameLike(String firstname);
}

@Service
public class MyService {

  private final PersonRepository repository;

  public MyService(PersonRepository repository) {
    this.repository = repository;
  }

  public void doWork() {

    repository.deleteAll();

    Person person = new Person();
    person.setFirstname("Oliver");
    person.setLastname("Gierke");
    repository.save(person);

    List<Person> lastNameResults = repository.findByLastname("Gierke");
    List<Person> firstNameResults = repository.findByFirstnameLike("Oli");
 }
}
```

--------------------------------

### CriteriaQuery - Get books with a price range

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/template.adoc

Creates a CriteriaQuery to search for books with a price greater than 42.0 and less than 34.0 (note: this example is contradictory).

```APIDOC
## CriteriaQuery - Get books with a price range

### Description
Creates a CriteriaQuery to search for books with a price greater than 42.0 and less than 34.0 (note: this example is contradictory).

### Method
N/A (Java API)

### Endpoint
N/A (Java API)

### Parameters
- **price** (double) - Required - The price range to match.

### Request Example
java
Criteria criteria = new Criteria("price").greaterThan(42.0).lessThan(34.0);
Query query = new CriteriaQuery(criteria);


### Response
N/A (Java API)
```

--------------------------------

### Entity with price property for runtime field query

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/misc.adoc

Simple entity with a price property used in the runtime field query example.

```java
@Document(indexName = "some_index_name")
public class SomethingToBuy {

	private @Id @Nullable String id;
	@Nullable @Field(type = FieldType.Text) private String description;
	@Nullable @Field(type = FieldType.Double) private Double price;

	// getter and setter
}
```

--------------------------------

### Query creation from method names: findByNameAndPrice

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/elasticsearch-repository-queries.adoc

Example of a repository method that derives an Elasticsearch query from the method name. The method name is translated into a bool query with must clauses for each property.

```java
interface BookRepository extends Repository<Book, String> {
  List<Book> findByNameAndPrice(String name, Integer price);
}
```

--------------------------------

### CriteriaQuery - Get books with a given price

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/template.adoc

Creates a CriteriaQuery to search for books with a specific price using the is() method.

```APIDOC
## CriteriaQuery - Get books with a given price

### Description
Creates a CriteriaQuery to search for books with a specific price using the is() method.

### Method
N/A (Java API)

### Endpoint
N/A (Java API)

### Parameters
- **price** (double) - Required - The price to match.

### Request Example
java
Criteria criteria = new Criteria("price").is(42.0);
Query query = new CriteriaQuery(criteria);


### Response
N/A (Java API)
```

--------------------------------

### Access scroll ID and iterate scroll results with AbstractElasticsearchTemplate

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/misc.adoc

Use AbstractElasticsearchTemplate's searchScrollStart, searchScrollContinue, and searchScrollClear methods to manually manage scroll IDs. The example shows starting a scroll with a 1000ms keep-alive, iterating through hits, and clearing the scroll. Requires autowiring ElasticsearchOperations and casting to AbstractElasticsearchTemplate.

```java
@Autowired ElasticsearchOperations operations;

AbstractElasticsearchTemplate template = (AbstractElasticsearchTemplate)operations;

IndexCoordinates index = IndexCoordinates.of("sample-index");

Query query = NativeQuery.builder()
    .withQuery(q -> q
        .matchAll(ma -> ma))
    .withFields("message")
    .withPageable(PageRequest.of(0, 10))
    .build();

SearchScrollHits<SampleEntity> scroll = template.searchScrollStart(1000, query, SampleEntity.class, index);

String scrollId = scroll.getScrollId();
List<SampleEntity> sampleEntities = new ArrayList<>();
while (scroll.hasSearchHits()) {
  sampleEntities.addAll(scroll.getSearchHits());
  scrollId = scroll.getScrollId();
  scroll = template.searchScrollContinue(scrollId, 1000, SampleEntity.class);
}
template.searchScrollClear(scrollId);
```

--------------------------------

### Geospatial types example: Address class and JSON document

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/object-mapping.adoc

Shows how geospatial types like Point are converted to lat/lon pairs in the JSON document.

```java
public class Address {
  String city, street;
  Point location;
}
```

```json
{
  "city" : "Los Angeles",
  "street" : "2800 East Observatory Road",
  "location" : { "lat" : 34.118347, "lon" : -118.3026284 }
}
```

--------------------------------

### CriteriaQuery: Get books with a given price

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/template.adoc

Creates a CriteriaQuery that matches documents where the 'price' field equals 42.0. This is the simplest usage of CriteriaQuery.

```java
Criteria criteria = new Criteria("price").is(42.0);
Query query = new CriteriaQuery(criteria);
```

--------------------------------

### Range type example with Range<T> class

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/object-mapping.adoc

Shows the alternative using Spring Data Elasticsearch's Range<T> class for range fields.

```java
class SomePersonData {

    @Field(type = FieldType.Integer_Range)
    private Range<Integer> validAge;

    // getter and setter
}
```

--------------------------------

### Type hints example: Person class and JSON document

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/object-mapping.adoc

Shows the default type hint behavior: the _class attribute is written for each aggregate root, using the domain type's class name by default.

```java
public class Person {              <1>
  @Id String id;
  String firstname;
  String lastname;
}
```

```json
{
  "_class" : "com.example.Person", <1>
  "id" : "cb7bef",
  "firstname" : "Sarah",
  "lastname" : "Connor"
}
```

--------------------------------

### Define runtime fields mapping with @Mapping runtimeFieldsPath

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/misc.adoc

Example JSON content for a runtime fields definition that can be referenced via the runtimeFieldsPath property of the @Mapping annotation. This JSON is written to the index mappings.

```json
{
  "day_of_week": {
    "type": "keyword",
    "script": {
      "source": "emit(doc['@timestamp'].value.dayOfWeekEnum.getDisplayName(TextStyle.FULL, Locale.ROOT))"
    }
  }
}
```

--------------------------------

### Save, get, delete, and count operations with ReactiveElasticsearchOperations

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/reactive-template.adoc

Shows the reactive chain for saving a Person, retrieving it by id, deleting it, and counting documents in the index. The id is generated server-side and set into the returned instance. Remember to subscribe to trigger execution.

```java

ReactiveElasticsearchOperations operations;

// ...

operations.save(new Person("Bruce Banner", 42))                    
  .doOnNext(System.out::println)
  .flatMap(person -> operations.get(person.id, Person.class))      
  .doOnNext(System.out::println)
  .flatMap(person -> operations.delete(person))                    
  .doOnNext(System.out::println)
  .flatMap(id -> operations.count(Person.class))                   
  .doOnNext(System.out::println)
  .subscribe();                                                    
```

--------------------------------

### Use RoutingResolver.just for get and delete operations

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/routing.adoc

When retrieving or deleting by ID, provide the same routing value used at index time. RoutingResolver.just(routing) returns a resolver that always returns the given string.

```java
String id = "someId";
String routing = "theRoutingValue";

// get an entity
Statement s = operations
                .withRouting(RoutingResolver.just(routing))       <1>
                .get(id, Statement.class);

// delete an entity
operations.withRouting(RoutingResolver.just(routing)).delete(id);

```

--------------------------------

### Build Spring Data Elasticsearch Reference Documentation

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/README.adoc

Use this command to build the project and generate the reference documentation without running tests. The generated documentation is available from target/site/index.html.

```bash
 $ ./mvnw clean install -Pantora
```

--------------------------------

### Run unit tests with Maven wrapper

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/TESTING.adoc

Executes unit tests in the project. Use this command from the project root.

```bash
./mvnw test
```

--------------------------------

### Configure Rest5Client with callback

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/clients.adoc

Shows how to configure the low-level Elasticsearch Rest5Client using a callback that provides a RestClientBuilder. This is used when the standard ClientConfiguration options are insufficient.

```java
ClientConfiguration.builder()
    .connectedTo("localhost:9200", "localhost:9291")
    .withClientConfigurer(Rest5Clients.ElasticsearchRest5ClientConfigurationCallback.from(restClientBuilder -> {
        // configure the Elasticsearch Rest5Client
        return restClientBuilder;
    }))
    .build();
```

--------------------------------

### Configure HttpAsyncClient for Rest5Client

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/clients.adoc

Shows how to configure the HttpAsyncClient used by the low-level Rest5Client using a callback that provides an HttpAsyncClientBuilder.

```java
ClientConfiguration.builder()
    .connectedTo("localhost:9200", "localhost:9291")
    .withClientConfigurer(Rest5Clients.ElasticsearchHttpClientConfigurationCallback.from(httpAsyncClientBuilder -> {
        // configure the HttpAsyncClient
        return httpAsyncClientBuilder;
    }))
    .build();
```

--------------------------------

### Build Spring Data Elasticsearch with Maven Wrapper

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/README.adoc

Use this command to build the project from source using the Maven wrapper. Requires JDK 17 or above for the main branch, or JDK 8 for branches up to and including release 4.4.

```bash
 $ ./mvnw clean install
```

--------------------------------

### New client configuration (reactive)

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/migration-guides/migration-guide-4.4-5.0.adoc

Extend ReactiveElasticsearchConfiguration to configure the new reactive client. This creates RestClient, ReactiveElasticsearchClient, and ReactiveElasticsearchOperations beans.

```java
@Configuration
public class NewRestClientConfig extends ReactiveElasticsearchConfiguration {

	@Override
	public ClientConfiguration clientConfiguration() {
		return ClientConfiguration.builder() //
			.connectedTo("localhost:9200") //
			.build();
	}
}
```

--------------------------------

### Supported keywords: Like

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/elasticsearch-repository-queries.adoc

The Like keyword in a method name produces a query_string query with wildcard and analyze_wildcard true.

```json
{ "query" : {
"bool" : {
"must" : [
{ "query_string" : { "query" : "?*", "fields" : [ "name" ] }, "analyze_wildcard": true }
]
}
}}
```

--------------------------------

### CriteriaQuery - Get persons by lastname and firstname

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/template.adoc

Creates a CriteriaQuery to search for persons with lastname 'Miller' and firstname 'James' using chained Criteria.

```APIDOC
## CriteriaQuery - Get persons by lastname and firstname

### Description
Creates a CriteriaQuery to search for persons with lastname 'Miller' and firstname 'James' using chained Criteria.

### Method
N/A (Java API)

### Endpoint
N/A (Java API)

### Parameters
- **lastname** (string) - Required - The last name to match.
- **firstname** (string) - Required - The first name to match.

### Request Example
java
Criteria criteria = new Criteria("lastname").is("Miller")
  .and("firstname").is("James");
Query query = new CriteriaQuery(criteria);


### Response
N/A (Java API)
```

--------------------------------

### SearchTemplateQuery with parameters

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/misc.adoc

Shows how to build a SearchTemplateQuery with an ID and parameters, then execute the search using ElasticsearchOperations. The parameters are passed as a Map<String,Object> and the search is performed like other query types.

```java
@Override
public SearchPage<Person> findByFirstNameWithSearchTemplate(String firstName, Pageable pageable) {

  var query = SearchTemplateQuery.builder()                               <1>
    .withId("person-firstname")                                           <2>
    .withParams(
      Map.of(                                                             <3>
        "firstName", firstName,
        "from", pageable.getOffset(),
        "size", pageable.getPageSize()
        )
    )
    .build();

  SearchHits<Person> searchHits = operations.search(query, Person.class); <4>

  return SearchHitSupport.searchPageFor(searchHits, pageable);
}
```

--------------------------------

### Sort by geographical distance with GeoDistanceOrder

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/misc.adoc

Use GeoDistanceOrder to sort search results by distance from a given GeoPoint. The example sorts by the 'location' property of the entity.

```java
Sort.by(new GeoDistanceOrder("location", new GeoPoint(48.137154, 11.5761247)))
```

--------------------------------

### Java configuration for repositories

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/reactive-elasticsearch-repositories.adoc

Configures reactive Elasticsearch repositories using @EnableReactiveElasticsearchRepositories and provides a ReactiveElasticsearchClient.

```java
@Configuration
@EnableReactiveElasticsearchRepositories
public class Config extends AbstractReactiveElasticsearchConfiguration {

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

--------------------------------

### CriteriaQuery: AND chaining with and()

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/template.adoc

Chains two Criteria objects with and() to combine conditions with AND logic. The example searches for persons with last name 'Miller' and first name 'James'.

```java
Criteria criteria = new Criteria("lastname").is("Miller") <1>
  .and("firstname").is("James")                           <2>
Query query = new CriteriaQuery(criteria);
```

--------------------------------

### Supported keywords: And

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/elasticsearch-repository-queries.adoc

The And keyword in a method name produces a bool query with a must clause for each field.

```json
{ "query" : {
"bool" : {
"must" : [
{ "query_string" : { "query" : "?", "fields" : [ "name" ] } },
{ "query_string" : { "query" : "?", "fields" : [ "price" ] } }
]
}
}}
```

--------------------------------

### Geo-distance query with Criteria

Source: https://github.com/spring-projects/spring-data-elasticsearch/wiki/Geo-indexing-and-request

Builds a CriteriaQuery to find entities within a specified distance from a GeoPoint. The example searches for authors within 20km of Clermont-Ferrand and expects one result.

```java
CriteriaQuery geoLocationCriteriaQuery = new CriteriaQuery(
                new Criteria("location").within(new GeoPoint(45.7806d, 3.0875d), "20km"));
List<AuthorMarkerEntity> geoAuthorsForGeoCriteria = elasticsearchTemplate.queryForList(geoLocationCriteriaQuery, AuthorMarkerEntity.class);
```

--------------------------------

### Basic repository interface to persist Person entities

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/reactive-elasticsearch-repositories.adoc

Shows a reactive repository interface extending ReactiveSortingRepository with various finder methods, including query methods, sorting, pagination, and @Query annotation.

```java
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>
}
```

--------------------------------

### Geo-distance query combined with other criteria

Source: https://github.com/spring-projects/spring-data-elasticsearch/wiki/Geo-indexing-and-request

Combines a geo-distance filter with a name criterion. The example searches for authors within 20km of London and named 'Mohsin Husen', expecting one result.

```java
CriteriaQuery geoLocationCriteriaQuery2 = new CriteriaQuery(
                new Criteria("name").is("Mohsin Husen").and("location").within(new GeoPoint(51.5171d, 0.1062d), "20km"));
List<AuthorMarkerEntity> geoAuthorsForGeoCriteria2 = elasticsearchTemplate.queryForList(geoLocationCriteriaQuery2, AuthorMarkerEntity.class);
```

--------------------------------

### Supported keywords: In

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/elasticsearch-repository-queries.adoc

The In keyword in a method name produces a query_string query with quoted terms.

```json
{ "query": {"bool": {"must": [{"query_string":{"query": "\"?\" \"?\"", "fields": ["name"]}}]}}}
```

--------------------------------

### Reactive Rest5Client configuration class

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/clients.adoc

Configuration class extending ReactiveElasticsearchConfiguration to set up the reactive Elasticsearch client. Override clientConfiguration() to specify connection details.

```java
import org.springframework.data.elasticsearch.client.elc.ReactiveElasticsearchConfiguration;

@Configuration
public class MyClientConfig extends ReactiveElasticsearchConfiguration {

	@Override
	public ClientConfiguration clientConfiguration() {
		return ClientConfiguration.builder()           <.>
			.connectedTo("localhost:9200")
			.build();
	}
}
```

--------------------------------

### ElasticsearchOperations usage in Spring REST controller

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/template.adoc

Shows how to inject ElasticsearchOperations and use it to save and retrieve Person entities. The save method returns the generated id, and the get method retrieves by id.

```java
@RestController
@RequestMapping("/")
public class TestController {

  private  ElasticsearchOperations elasticsearchOperations;

  public TestController(ElasticsearchOperations elasticsearchOperations) {
    this.elasticsearchOperations = elasticsearchOperations;
  }

  @PostMapping("/person")
  public String save(@RequestBody Person person) {
    Person savedEntity = elasticsearchOperations.save(person);
    return savedEntity.getId();
  }

  @GetMapping("/person/{id}")
  public Person findById(@PathVariable("id")  Long id) {
    Person person = elasticsearchOperations.get(id.toString(), Person.class);
    return person;
  }
}
```

--------------------------------

### Sorted access to Person entities

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/reactive-elasticsearch-repositories.adoc

Shows how to use the repository to find all persons sorted by lastname in ascending order.

```java
public class PersonRepositoryTests {

  @Autowired ReactivePersonRepository repository;

  @Test
  public void sortsElementsCorrectly() {

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

    // ...
  }
}
```

--------------------------------

### Activating reactive auditing with @EnableReactiveElasticsearchAuditing

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/auditing.adoc

Configuration class that activates auditing for the reactive stack by adding @EnableReactiveElasticsearchAuditing alongside @EnableReactiveElasticsearchRepositories.

```java
@Configuration
@EnableReactiveElasticsearchRepositories
@EnableReactiveElasticsearchAuditing
class MyConfiguration {
   // configuration code
}
```

--------------------------------

### CriteriaQuery: Nested subqueries

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/template.adoc

Creates a nested query using subCriteria to combine a last name condition with an OR condition on first names. The example searches for persons with last name 'Miller' and first name either 'John' or 'Jack'.

```java
Criteria miller = new Criteria("lastName").is("Miller")  <.>
  .subCriteria(                                          <.>
    new Criteria().or("firstName").is("John")            <.>
      .or("firstName").is("Jack")                        <.>
  );
Query query = new CriteriaQuery(criteria);
```

--------------------------------

### Configure deprecated RestClient with callback

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/clients.adoc

Shows how to configure the deprecated low-level Elasticsearch RestClient using a callback that provides a RestClientBuilder. This is for the older RestClient API.

```java
ClientConfiguration.builder()
    .connectedTo("localhost:9200", "localhost:9291")
    .withClientConfigurer(RestClients.ElasticsearchRestClientConfigurationCallback.from(restClientBuilder -> {
        // configure the Elasticsearch RestClient
        return restClientBuilder;
    }))
    .build();
```

--------------------------------

### Person entity implementing Persistable with auditing fields

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/auditing.adoc

Example entity that implements Persistable and uses auditing annotations (@CreatedDate, @CreatedBy, @LastModifiedDate, @LastModifiedBy). The isNew() method returns true if id is null or creation fields are not set.

```java
@Document(indexName = "person")
public class Person implements Persistable<Long> {
    @Id private Long id;
    private String lastName;
    private String firstName;
    @CreatedDate
    @Field(type = FieldType.Date, format = DateFormat.basic_date_time)
    private Instant createdDate;
    @CreatedBy
    private String createdBy
    @Field(type = FieldType.Date, format = DateFormat.basic_date_time)
    @LastModifiedDate
    private Instant lastModifiedDate;
    @LastModifiedBy
    private String lastModifiedBy;

    public Long getId() {                                                 // <.>
        return id;
    }

    @Override
    public boolean isNew() {
        return id == null || (createdDate == null && createdBy == null);  // <.>
    }
}
```

--------------------------------

### New client configuration (imperative)

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/migration-guides/migration-guide-4.4-5.0.adoc

Extend ElasticsearchConfiguration to configure the new Elasticsearch client. This creates RestClient, ElasticsearchClient, and ElasticsearchOperations beans.

```java
@Configuration
public class NewRestClientConfig extends ElasticsearchConfiguration {

	@Override
	public ClientConfiguration clientConfiguration() {
		return ClientConfiguration.builder() //
			.connectedTo("localhost:9200") //
			.build();
	}
}
```

--------------------------------

### Implement PersonCustomRepositoryImpl

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/misc.adoc

Implements the custom repository fragment, injecting ElasticsearchOperations via constructor.

```java
public class PersonCustomRepositoryImpl implements PersonCustomRepository {

  private final ElasticsearchOperations operations;

  public PersonCustomRepositoryImpl(ElasticsearchOperations operations) {
    this.operations = operations;
  }
```

--------------------------------

### Indexing entities with geo-point

Source: https://github.com/spring-projects/spring-data-elasticsearch/wiki/Geo-indexing-and-request

Creates the index, mapping, and bulk indexes multiple entities with GeoPoint locations.

```java
elasticsearchTemplate.createIndex(AuthorMarkerEntity.class);
elasticsearchTemplate.refresh(AuthorMarkerEntity.class, true);
elasticsearchTemplate.putMapping(AuthorMarkerEntity.class);

List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
indexQueries.add(new AuthorMarkerEntityBuilder("1").name("Franck Marchand").location(45.7806d, 3.0875d).buildIndex());
indexQueries.add(new AuthorMarkerEntityBuilder("2").name("Mohsin Husen").location(51.5171d, 0.1062d).buildIndex());
indexQueries.add(new AuthorMarkerEntityBuilder("3").name("Rizwan Idrees").location(51.5171d, 0.1062d).buildIndex());
elasticsearchTemplate.bulkIndex(indexQueries);
```

--------------------------------

### Supported keywords: Or

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/elasticsearch-repository-queries.adoc

The Or keyword in a method name produces a bool query with a should clause for each field.

```json
{ "query" : {
"bool" : {
"should" : [
{ "query_string" : { "query" : "?", "fields" : [ "name" ] } },
{ "query_string" : { "query" : "?", "fields" : [ "price" ] } }
]
}
}}
```

--------------------------------

### PersonService class with ElasticsearchOperations

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/scripted-and-runtime-fields.adoc

Service class with a repository injected and an ElasticsearchOperations instance. Shows several ways of populating and using the age property. The code is split into different pieces for explanation.

```java
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.Criteria;
import org.springframework.data.elasticsearch.core.query.CriteriaQuery;
import org.springframework.data.elasticsearch.core.query.FetchSourceFilter;
import org.springframework.data.elasticsearch.core.query.RuntimeField;
import org.springframework.data.elasticsearch.core.query.ScriptData;
import org.springframework.data.elasticsearch.core.query.ScriptType;
import org.springframework.data.elasticsearch.core.query.ScriptedField;
import org.springframework.data.elasticsearch.core.query.StringQuery;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class PersonService {
    private final ElasticsearchOperations operations;
    private final PersonRepository repository;

    public PersonService(ElasticsearchOperations operations, SaRPersonRepository repository) {
        this.operations = operations;
        this.repository = repository;
    }

```

--------------------------------

### Activating auditing with @EnableElasticsearchAuditing

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/auditing.adoc

Configuration class that activates auditing for the imperative stack by adding @EnableElasticsearchAuditing alongside @EnableElasticsearchRepositories.

```java
@Configuration
@EnableElasticsearchRepositories
@EnableElasticsearchAuditing
class MyConfiguration {
   // configuration code
}
```

--------------------------------

### Use scroll API for big result sets

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/misc.adoc

Uses the scroll API via searchForStream to retrieve results in chunks. The query uses a matchAll query, selects the 'message' field, and sets a pageable of size 10. The stream is iterated to collect all SampleEntity instances.

```java
IndexCoordinates index = IndexCoordinates.of("sample-index");

Query searchQuery = NativeQuery.builder()
    .withQuery(q -> q
        .matchAll(ma -> ma))
    .withFields("message")
    .withPageable(PageRequest.of(0, 10))
    .build();

SearchHitsIterator<SampleEntity> stream = elasticsearchOperations.searchForStream(searchQuery, SampleEntity.class,
index);

List<SampleEntity> sampleEntities = new ArrayList<>();
while (stream.hasNext()) {
  sampleEntities.add(stream.next());
}
```

--------------------------------

### Repository method with @Highlight annotation

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/elasticsearch-repositories.adoc

Defines a repository method that searches for text in the 'name' or 'summary' fields and requests highlighting for those fields. The method returns SearchHits<Book>.

```java
interface BookRepository extends Repository<Book, String> {

    @Highlight(fields = {
        @HighlightField(name = "name"),
        @HighlightField(name = "summary")
    })
    SearchHits<Book> findByNameOrSummary(String text, String summary);
}
```

--------------------------------

### Configure ConnectionConfig for Rest5Client

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/clients.adoc

Use this callback to configure the ConnectionConfig used by the low level Elasticsearch Rest5Client. The callback provides a ConnectionConfigBuilder.

```java
ClientConfiguration.builder()
    .connectedTo("localhost:9200", "localhost:9291")
    .withClientConfigurer(Rest5Clients.ElasticsearchConnectionConfigurationCallback.from(connectionConfigBuilder -> {
        // configure the connection
        return connectionConfigBuilder;
    }))
    .build();
```

--------------------------------

### CDI producer and service for Elasticsearch repositories

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/cdi-integration.adoc

Shows a CDI producer that creates an ElasticsearchOperations bean and a service that uses CDI injection to obtain a ProductRepository. The producer must use the same calls as in the Elasticsearch Operations chapter. The repository is injected via a setter method annotated with @Inject.

```java
class ElasticsearchTemplateProducer {

  @Produces
  @ApplicationScoped
  public ElasticsearchOperations createElasticsearchTemplate() {
    // ...                               <1>
  }
}

class ProductService {

  private ProductRepository repository;  <2>
  public Page<Product> findAvailableBookByName(String name, Pageable pageable) {
    return repository.findByAvailableTrueAndNameStartingWith(name, pageable);
  }
  @Inject
  public void setRepository(ProductRepository repository) {
    this.repository = repository;
  }
}
```

--------------------------------

### Enable repositories with elasticsearch:repositories

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/elasticsearch-repositories.adoc

XML namespace configuration to enable Spring Data Elasticsearch repositories. Set the base-package attribute to the package containing your repository interfaces.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans-3.1.xsd
       http://www.springframework.org/schema/data/elasticsearch
       https://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch-1.0.xsd">

  <elasticsearch:repositories base-package="com.acme.repositories" />

</beans>
```

--------------------------------

### Full Spring XML configuration with repositories and custom result mapper

Source: https://github.com/spring-projects/spring-data-elasticsearch/wiki/Custom-ObjectMapper

Complete XML configuration that sets up Elasticsearch repositories, a transport client, and a custom result mapper that uses a DefaultEntityMapper. This shows how to inject the custom implementation into the template.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
       xsi:schemaLocation="http://www.springframework.org/schema/data/elasticsearch http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch-1.0.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">

    <elasticsearch:repositories base-package="com.xyz.acme"/>

    <elasticsearch:transport-client id="client" cluster-nodes="localhost:9300,someip:9300" />

    <bean name="elasticsearchTemplate"
          class="org.springframework.data.elasticsearch.core.ElasticsearchTemplate">
        <constructor-arg name="client" ref="client"/>
        <constructor-arg name="resultsMapper" ref="resultMapper"/>
    </bean>

    <bean name="entityMapper" class="org.springframework.data.elasticsearch.core.DefaultEntityMapper"/>

    <bean name="resultMapper" class="org.springframework.data.elasticsearch.core.CustomResultMapper">
        <constructor-arg ref="entityMapper"/>
    </bean>

</beans>
```

--------------------------------

### Configure Deprecated Imperative RestClient with ElasticsearchLegacyRestClientConfiguration

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/clients.adoc

Extends ElasticsearchLegacyRestClientConfiguration and overrides clientConfiguration() to connect to localhost:9200. Use this for the deprecated RestClient.

```java
import org.springframework.data.elasticsearch.client.elc.ElasticsearchLegacyRestClientConfiguration;

@Configuration
public class MyClientConfig extends ElasticsearchLegacyRestClientConfiguration {

	@Override
	public ClientConfiguration clientConfiguration() {
		return ClientConfiguration.builder()           <.>
			.connectedTo("localhost:9200")
			.build();
	}
}

```

--------------------------------

### NativeQuery: Search with aggregation

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/template.adoc

Builds a NativeQuery using the builder pattern, adding a terms aggregation on 'lastName' and a match query on 'firstName'. This is used for complex queries that cannot be expressed with Criteria.

```java
Query query = NativeQuery.builder()
	.withAggregation("lastNames", Aggregation.of(a -> a
		.terms(ta -> ta.field("lastName").size(10))))
	.withQuery(q -> q
		.match(m -> m
			.field("firstName")
			.query(firstName)
		)
	)
	.withPageable(pageable)
	.build();
```

--------------------------------

### Define PersonCustomRepository Fragment Interface

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/misc.adoc

Defines a custom repository fragment interface with a method that uses a search template query.

```java
interface PersonCustomRepository {
	SearchPage<Person> findByFirstNameWithSearchTemplate(String firstName, Pageable pageable);
}
```

--------------------------------

### Save sample person data to Elasticsearch

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/scripted-and-runtime-fields.adoc

Utility method to store a list of Person entities in Elasticsearch using the repository's saveAll method.

```java
    public void save() { <1>
        List<Person> persons = List.of(
                new Person("1", "Smith", "Mary", "f", "1987-05-03"),
                new Person("2", "Smith", "Joshua", "m", "1982-11-17"),
                new Person("3", "Smith", "Joanna", "f", "2018-03-27"),
                new Person("4", "Smith", "Alex", "m", "2020-08-01"),
                new Person("5", "McNeill", "Fiona", "f", "1989-04-07"),
                new Person("6", "McNeill", "Michael", "m", "1984-10-20"),
                new Person("7", "McNeill", "Geraldine", "f", "2020-03-02"),
                new Person("8", "McNeill", "Patrick", "m", "2022-07-04"));

        repository.saveAll(persons);
    }
```

--------------------------------

### Custom conversions configuration with ElasticsearchCustomConversions

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/object-mapping.adoc

Java configuration class registering custom converters for Address to Map and Map to Address.

```java
@Configuration
public class Config extends ElasticsearchConfiguration  {

	@Override
	public ClientConfiguration clientConfiguration() {
		return ClientConfiguration.builder() //
				.connectedTo("localhost:9200") //
				.build();
	}

  @Bean
  @Override
  public ElasticsearchCustomConversions elasticsearchCustomConversions() {
    return new ElasticsearchCustomConversions(
      Arrays.asList(new AddressToMap(), new MapToAddress()));       <1>
  }

  @WritingConverter                                                 <2>
  static class AddressToMap implements Converter<Address, Map<String, Object>> {

    @Override
    public Map<String, Object> convert(Address source) {

      LinkedHashMap<String, Object> target = new LinkedHashMap<>();
      target.put("ciudad", source.getCity());
      // ...

      return target;
    }
  }

  @ReadingConverter                                                 <3>
  static class MapToAddress implements Converter<Map<String, Object>, Address> {

    @Override
    public Address convert(Map<String, Object> source) {

      // ...
      return address;
    }
  }
}
```

--------------------------------

### Store a Search Template Script with putScript

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/misc.adoc

Stores a mustache search template script using the putScript() method. The script includes placeholders for firstName, from, and size parameters.

```java
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.script.Script;

operations.putScript(
  Script.builder()
    .withId("person-firstname")
    .withLanguage("mustache")
    .withSource("""
      {
        "query": {
          "bool": {
            "must": [
              {
                "match": {
                  "firstName": "{{firstName}}"
                }
              }
            ]
          }
        },
        "from": "{{from}}",
        "size": "{{size}}"
      }
      """)
    .build()
);
```

--------------------------------

### Configure HttpAsyncClient for RestClient

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/clients.adoc

Use this callback to configure the HttpAsyncClient used by the deprecated low level Elasticsearch RestClient. The callback provides an HttpAsyncClientBuilder.

```java
ClientConfiguration.builder()
    .connectedTo("localhost:9200", "localhost:9291")
    .withClientConfigurer(RestClients.ElasticsearchHttpClientConfigurationCallback.from(httpAsyncClientBuilder -> {
        // configure the HttpAsyncClient
        return httpAsyncClientBuilder;
    }))
    .build();
```

--------------------------------

### IndexQuery with IndexCoordinates (4.0.x)

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/migration-guides/migration-guide-3.2-4.0.adoc

In 4.0.x, the index name must be provided via IndexCoordinates. This code shows the new way of indexing an entity.

```java
IndexCoordinates indexCoordinates = elasticsearchOperations.getIndexCoordinatesFor(person.getClass());

IndexQuery indexQuery = new IndexQueryBuilder()
  .withId(person.getId().toString())
  .withObject(person)
  .build();

String documentId = elasticsearchOperations.index(indexQuery, indexCoordinates);
```

--------------------------------

### Open, Use, and Close a Point In Time (PIT)

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/misc.adoc

Demonstrates the Point In Time (PIT) API: open a PIT with a keep-alive duration, use it in queries, and close it. The PIT ID from the previous search result is used for subsequent queries.

```java
ElasticsearchOperations operations; // autowired
Duration tenSeconds = Duration.ofSeconds(10);

String pit = operations.openPointInTime(IndexCoordinates.of("person"), tenSeconds);

// create query for the pit
Query query1 = new CriteriaQueryBuilder(Criteria.where("lastName").is("Smith"))
    .withPointInTime(new Query.PointInTime(pit, tenSeconds))
    .build();
SearchHits<Person> searchHits1 = operations.search(query1, Person.class);
// do something with the data

// create 2nd query for the pit, use the id returned in the previous result
Query query2 = new CriteriaQueryBuilder(Criteria.where("lastName").is("Miller"))
    .withPointInTime(
        new Query.PointInTime(searchHits1.getPointInTimeId(), tenSeconds))
    .build();
SearchHits<Person> searchHits2 = operations.search(query2, Person.class);
// do something with the data

operations.closePointInTime(searchHits2.getPointInTimeId());
```

--------------------------------

### Supported keywords: Is

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/elasticsearch-repository-queries.adoc

The Is keyword in a method name produces a bool query with a must clause for the field.

```json
{ "query" : {
"bool" : {
"must" : [
{ "query_string" : { "query" : "?", "fields" : [ "name" ] } }
]
}
}}
```

--------------------------------

### Supported keywords: Between

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/repositories/elasticsearch-repository-queries.adoc

The Between keyword in a method name produces a range query with from and to values and include_lower and include_upper set to true.

```json
{ "query" : {
"bool" : {
"must" : [
{"range" : {"price" : {"from" : ?, "to" : ?, "include_lower" : true, "include_upper" : true } } }
]
}
}}
```

--------------------------------

### Person class with Map<String, Address> knownLocations

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/object-mapping.adoc

Java class showing a map with String keys and Address values.

```java
public class Person {

  // ...

  Map<String, Address> knownLocations;

}
```

--------------------------------

### Reactive/BeforeConvertCallback

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/entity-callbacks.adoc

Invoked before a domain object is converted to a Document. Can return the entity or a modified entity which will then be converted.

```APIDOC
## Reactive/BeforeConvertCallback

### Description
Invoked before a domain object is converted to `org.springframework.data.elasticsearch.core.document.Document`. Can return the `entity` or a modified entity which then will be converted.

### Method
`onBeforeConvert(T entity, IndexCoordinates index)`

### Parameters
- **entity** (T) - The domain object to be converted.
- **index** (IndexCoordinates) - The index coordinates.

### Order
`Ordered.LOWEST_PRECEDENCE`
```

--------------------------------

### NativeQuery - Search with aggregation

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/template.adoc

Creates a NativeQuery to search for persons with a given firstName and a terms aggregation on lastName.

```APIDOC
## NativeQuery - Search with aggregation

### Description
Creates a NativeQuery to search for persons with a given firstName and a terms aggregation on lastName.

### Method
N/A (Java API)

### Endpoint
N/A (Java API)

### Parameters
- **firstName** (string) - Required - The first name to match.
- **pageable** (Pageable) - Required - The pageable for pagination.

### Request Example
java
Query query = NativeQuery.builder()
	.withAggregation("lastNames", Aggregation.of(a -> a
		.terms(ta -> ta.field("lastName").size(10))))
	.withQuery(q -> q
		.match(m -> m
			.field("firstName")
			.query(firstName)
		)
	)
	.withPageable(pageable)
	.build();


### Response
N/A (Java API)
```

--------------------------------

### Configure RequestConfig for Rest5Client

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/clients.adoc

Use this callback to configure the RequestConfig used by the low level Elasticsearch Rest5Client. The callback provides a RequestConfigBuilder.

```java
ClientConfiguration.builder()
    .connectedTo("localhost:9200", "localhost:9291")
    .withClientConfigurer(Rest5Clients.ElasticsearchRequestConfigCallback.from(requestConfigBuilder -> {
        // configure the request config
        return requestConfigBuilder;
    }))
    .build();
```

--------------------------------

### Set custom RoutingResolver on ElasticsearchOperations

Source: https://github.com/spring-projects/spring-data-elasticsearch/blob/main/src/main/antora/modules/ROOT/pages/elasticsearch/routing.adoc

Create a RoutingResolver implementation and set it on ElasticsearchOperations using withRouting(). The method returns a copy of the original instance with the customized routing.

```java
RoutingResolver resolver = ...;

ElasticsearchOperations customOperations= operations.withRouting(resolver);

```
Tokens:
Raw