Spring Data MongoDB

https://github.com/spring-projects/spring-data-mongodb
Admin
Spring Data MongoDB provides integration with MongoDB, offering a POJO-centric model and...
Tokens:1,236,145
Snippets:5,879
Trust Score:9.7
License:Apache-2.0
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Start MongoDB server

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/getting-started.adoc

Command to start a MongoDB server after installation.

```bash
/bin/mongod
```

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

### Start MongoDB client

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

Starts the MongoDB client to initialize the replica set. The output shows the MongoDB server version 8.0.0.

```bash
$ $MONGODB_HOME/bin/mongo
MongoDB server version: 8.0.0
...
```

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

### Typed Example Query

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

Runs a query by example on the Template API. By default Example is strictly typed, adding a type match (e.g., _class : { $in : [ com.acme.Person] }) to the query.

```java
Person probe = new Person();
probe.lastname = "stark";

Example example = Example.of(probe);

Query query = new Query(new Criteria().alike(example));
List<Person> result = template.find(query, Person.class);
```

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

### Start MongoDB server with replica set

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

Starts a MongoDB server with a replica set named rs0 on port 27017. The --dbpath option sets the data directory to a sub-directory under $MONGODB_HOME. The output shows the message "Successfully connected to host" when the server starts.

```bash
$ $MONGODB_HOME/bin/mongod --dbpath $MONGODB_HOME/runtime/data --ipv6 --port 27017 --replSet rs0
...
"msg":"Successfully connected to host"
```

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

### Output of Map-Reduce example

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/mongo-mapreduce.adoc

Output produced by the preceding Map-Reduce example. Each line shows the `ValueObject` representation.

```text
ValueObject [id=a, value=1.0]
ValueObject [id=b, value=2.0]
ValueObject [id=c, value=2.0]
ValueObject [id=d, value=1.0]
```

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

### Querydsl query examples for imperative and reactive repositories

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

Shows how to use Querydsl predicates with repository.findAll() in both imperative and reactive MongoDB repositories. The imperative example includes a Page query with sorting and pagination. The reactive example returns a Flux. QPerson is generated by annotation processing.

```java
QPerson person = QPerson.person;
List<Person> result = repository.findAll(person.address.zipCode.eq("C0123"));

Page<Person> page = repository.findAll(person.lastname.contains("a"),
                                       PageRequest.of(0, 2, Direction.ASC, "lastname"));
```

```java
QPerson person = QPerson.person;

Flux<Person> result = repository.findAll(person.address.zipCode.eq("C0123"));
```

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

### Example output

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/getting-started.adoc

Sample output from running the main program, showing debug logs and the printed Person object.

```text
10:01:32,265 DEBUG o.s.data.mongodb.core.MongoTemplate - insert Document containing fields: [_class, age, name] in collection: Person
10:01:32,765 DEBUG o.s.data.mongodb.core.MongoTemplate - findOne using query: { "name" : "Joe"} in db.collection: database.Person
Person [id=4ddbba3c0be56b7e1b210166, name=Joe, age=34]
10:01:32,984 DEBUG o.s.data.mongodb.core.MongoTemplate - Dropped collection [database.person]
```

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

### Untyped Example Query with UntypedExampleMatcher

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

Bypasses the default type restriction by using UntypedExampleMatcher.matching() so any domain type with matching field names can serve as the probe. The example creates a probe with a field annotated @Field("lastname") and uses it to build an Example, then runs a query with Criteria.alike(example).

```java
class JustAnArbitraryClassWithMatchingFieldName {
  @Field("lastname") String value;
}

JustAnArbitraryClassWithMatchingFieldNames probe = new JustAnArbitraryClassWithMatchingFieldNames();
probe.value = "stark";

Example example = Example.of(probe, UntypedExampleMatcher.matching());

Query query = new Query(new Criteria().alike(example));
List<Person> result = template.find(query, Person.class);
```

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

### Query by Example using a repository

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

Defines a PersonRepository extending QueryByExampleExecutor<Person> and a PersonService that uses Example.of(probe) to find people matching the probe.

```java
public interface PersonRepository extends QueryByExampleExecutor<Person> {

}

public class PersonService {

  @Autowired PersonRepository personRepository;

  public List<Person> findPeople(Person probe) {
    return personRepository.findAll(Example.of(probe));
  }
}
```

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

### XML: mongo-client with host, port, and connection string

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/migration-guide/migration-guide-2.x-to-3.x.adoc

Configuration examples for specifying host and port, or using a connection string with placeholders.

```xml
<context:property-placeholder location="classpath:..."/>

<mongo:mongo.mongo-client id="client-just-host-port"
                          host="${mongo.host}" port="${mongo.port}" />

<mongo:mongo.mongo-client id="client-using-connection-string"
                          connection-string="mongodb://${mongo.host}:${mongo.port}/?replicaSet=rs0" />
```

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

### Input documents for Map-Reduce example

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/mongo-mapreduce.adoc

Three documents in the collection `jmr1` used for the Map-Reduce example. Each document has a key 'x' with an array of letters.

```json
{ "_id" : ObjectId("4e5ff893c0277826074ec533"), "x" : [ "a", "b" ] }
{ "_id" : ObjectId("4e5ff893c0277826074ec534"), "x" : [ "b", "c" ] }
{ "_id" : ObjectId("4e5ff893c0277826074ec535"), "x" : [ "c", "d" ] }
```

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

### Facet Aggregation Examples

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

Two facet aggregation examples: one categorizes by country using match and sortByCount, the other categorizes by year using project and bucketAuto. Both generate $facet pipelines.

```java
// generates {$facet: {categorizedByCountry: [ { $match: { country: {$exists : true}}}, { $sortByCount: "$country"}]}}
facet(match(Criteria.where("country").exists(true)), sortByCount("country")).as("categorizedByCountry"))
```

```java
// generates {$facet: {categorizedByYear: [
//     { $project: { title: 1, publicationYear: { $year: "publicationDate"}}},
//     { $bucketAuto: {groupBy: $price, buckets: 5, output: { titles: {$push:"$title"}}}}
// ]}}
facet(project("title").and("publicationDate").extractYear().as("publicationYear"),
      bucketAuto("publicationYear", 5).andOutput("title").push().as("titles"))
  .as("categorizedByYear"))
```

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

### Domain classes for aggregation example

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

Defines the domain classes used in the aggregation example: `ZipInfo` maps the input collection structure, `City` is a nested output structure, and `ZipInfoStats` defines the desired output format.

```java
class ZipInfo {
   String id;
   String city;
   String state;
   @Field("pop") int population;
   @Field("loc") double[] location;
}

class City {
   String name;
   int population;
}

class ZipInfoStats {
   String id;
   String state;
   City biggestCity;
   City smallestCity;
}
```

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

### Bucket operation examples with bucket()

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

Shows how to define bucket operations with the `bucket()` method, specifying boundaries, a default bucket, and output accumulations. Boundaries must be sorted. Each call generates a `$bucket` aggregation stage.

```java
// generates {$bucket: {groupBy: $price, boundaries: [0, 100, 400]}}
bucket("price").withBoundaries(0, 100, 400);

// generates {$bucket: {groupBy: $price, default: "Other" boundaries: [0, 100]}}
bucket("price").withBoundaries(0, 100).withDefault("Other");

// generates {$bucket: {groupBy: $price, boundaries: [0, 100], output: { count: { $sum: 1}}}}
bucket("price").withBoundaries(0, 100).andOutputCount().as("count");

// generates {$bucket: {groupBy: $price, boundaries: [0, 100], 5, output: { titles: { $push: "$title"}}}
bucket("price").withBoundaries(0, 100).andOutput("title").push().as("titles");
```

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

### Configure EntityCallbacks (imperative and reactive)

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

Configures EntityCallbacks on MongoTemplate and ReactiveMongoTemplate beans. The imperative example uses EntityCallbacks.create(...), while the reactive example uses ReactiveEntityCallbacks.create(...).

```java
@Bean
MongoOperations mongoTemplate(MongoClient mongoClient) {
    MongoTemplate template = new MongoTemplate(mongoClient, "...");
	template.setEntityCallbacks(EntityCallbacks.create(...));
	// ...
}
```

```java
@Bean
ReactiveMongoOperations mongoTemplate(MongoClient mongoClient) {
    ReactiveMongoTemplate template = new ReactiveMongoTemplate(mongoClient, "...");
	template.setEntityCallbacks(ReactiveEntityCallbacks.create(...));
	// ...
}
```

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

### Aggregation Framework Example 1

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

Aggregation pipeline that counts tag occurrences, unwinds tags, groups by tag, projects the count, and sorts descending by count.

```java
import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;

Aggregation agg = newAggregation(
    project("tags"),
    unwind("tags"),
    group("tags").count().as("n"),
    project("n").and("tag").previousOperation(),
    sort(DESC, "n")
);
```

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

### BucketAuto operation examples with bucketAuto()

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

Shows how to define auto bucket operations with `bucketAuto()`, specifying the number of buckets, an optional granularity, and output accumulations. The granularity uses preferred number series to round boundary edges.

```java
// generates {$bucketAuto: {groupBy: $price, buckets: 5}}
bucketAuto("price", 5)

// generates {$bucketAuto: {groupBy: $price, buckets: 5, granularity: "E24"}}
bucketAuto("price", 5).withGranularity(Granularities.E24).withDefault("Other");

// generates {$bucketAuto: {groupBy: $price, buckets: 5, output: { titles: { $push: "$title"}}}
bucketAuto("price", 5).andOutput("title").push().as("titles");
```

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

### Facet operation example with facet()

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

Shows how to define a multi-faceted aggregation with `facet()`, combining a match filter and a bucketAuto operation into a single `$facet` stage. The result is stored under the specified alias.

```java
// generates {$facet: {categorizedByPrice: [ { $match: { price: {$exists : true}}}, { $bucketAuto: {groupBy: $price, buckets: 5}}]}}
facet(match(Criteria.where("price").exists(true)), bucketAuto("price", 5)).as("categorizedByPrice")
```

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

### Projection Expression Examples

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

Shows three projection expression examples using the Aggregation.project method. The first projects fields directly, the second aliases a field, and the third combines direct fields with an aliased field. References to projected fields in later stages are valid only for included fields or their aliases.

```java
// generates {$project: {name: 1, netPrice: 1}}
project("name", "netPrice")

// generates {$project: {thing1: $thing2}}
project().and("thing1").as("thing2")

// generates {$project: {a: 1, b: 1, thing2: $thing1}}
project("a","b").and("thing1").as("thing2")
```

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

### Spring Data MongoDB repository and configuration example

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

Shows a PersonRepository interface extending CrudRepository, a MyService using the repository, and a configuration class enabling Mongo repositories. Demonstrates basic CRUD operations and query methods.

```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("Drotbohm");
    repository.save(person);

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

@Configuration
@EnableMongoRepositories
class ApplicationConfig extends AbstractMongoClientConfiguration {

  @Override
  protected String getDatabaseName() {
    return "springdata";
  }
}
```

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

### findAndModify overloads and example

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

findAndModify overloads and an example that inserts Person objects and performs a findAndUpdate operation. The overloads take Query and Update and convert from Document to POJOs, optionally with collection name and FindAndModifyOptions.

```java
<T> T findAndModify(Query query, Update update, Class<T> entityClass);

<T> T findAndModify(Query query, Update update, Class<T> entityClass, String collectionName);

<T> T findAndModify(Query query, Update update, FindAndModifyOptions options, Class<T> entityClass);

<T> T findAndModify(Query query, Update update, FindAndModifyOptions options, Class<T> entityClass, String collectionName);
```

```java
template.insert(new Person("Tom", 21));
template.insert(new Person("Dick", 22));
template.insert(new Person("Harry", 23));

Query query = new Query(Criteria.where("firstName").is("Harry"));
Update update = new Update().inc("age", 1);
```

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

### Build Spring Data MongoDB with Maven wrapper

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

Builds Spring Data MongoDB using the Maven wrapper. This command is entered after starting MongoDB and initializing the replica set.

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

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

### Imperative MongoTemplate save, update, and remove example

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

Shows how to use MongoTemplate to insert, find, update, and remove a Person object. The example includes log output showing the operations and their results.

```java
public class MongoApplication {

  private static final Log log = LogFactory.getLog(MongoApplication.class);

  public static void main(String[] args) {

    MongoOperations template = new MongoTemplate(new SimpleMongoClientDbFactory(MongoClients.create(), "database"));

    Person p = new Person("Joe", 34);

    // Insert is used to initially store the object into the database.
    template.insert(p);
    log.info("Insert: " + p);

    // Find
    p = template.findById(p.getId(), Person.class);
    log.info("Found: " + p);

    // Update
    template.updateFirst(query(where("name").is("Joe")), update("age", 35), Person.class);
    p = template.findOne(query(where("name").is("Joe")), Person.class);
    log.info("Updated: " + p);

    // Delete
    template.remove(p);

    // Check that deletion worked
    List<Person> people =  template.findAll(Person.class);
    log.info("Number of people = : " + people.size());


    template.dropCollection(Person.class);
  }
}
```

```text
DEBUG apping.MongoPersistentEntityIndexCreator:  80 - Analyzing class class org.spring.example.Person for index information.
DEBUG work.data.mongodb.core.MongoTemplate: 632 - insert Document containing fields: [_class, age, name] in collection: person
INFO               org.spring.example.MongoApp:  30 - Insert: Person [id=4ddc6e784ce5b1eba3ceaf5c, name=Joe, age=34]
DEBUG work.data.mongodb.core.MongoTemplate:1246 - findOne using query: { "_id" : { "$oid" : "4ddc6e784ce5b1eba3ceaf5c"}} in db.collection: database.person
INFO               org.spring.example.MongoApp:  34 - Found: Person [id=4ddc6e784ce5b1eba3ceaf5c, name=Joe, age=34]
DEBUG work.data.mongodb.core.MongoTemplate: 778 - calling update using query: { "name" : "Joe"} and update: { "$set" : { "age" : 35}} in collection: person
DEBUG work.data.mongodb.core.MongoTemplate:1246 - findOne using query: { "name" : "Joe"} in db.collection: database.person
INFO               org.spring.example.MongoApp:  39 - Updated: Person [id=4ddc6e784ce5b1eba3ceaf5c, name=Joe, age=35]
DEBUG work.data.mongodb.core.MongoTemplate: 823 - remove using query: { "id" : "4ddc6e784ce5b1eba3ceaf5c"} in collection: person
INFO               org.spring.example.MongoApp:  46 - Number of people = : 0
DEBUG work.data.mongodb.core.MongoTemplate: 376 - Dropped collection [database.person]
```

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

### Sample documents with GeoJSON points

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

Example documents with GeoJSON Point locations used to illustrate distance calculations with `$geoNear`.

```json
{
    "_id" : ObjectId("5c10f3735d38908db52796a5"),
    "name" : "Penn Station",
    "location" : { "type" : "Point", "coordinates" : [  -73.99408, 40.75057 ] }
}
{
    "_id" : ObjectId("5c10f3735d38908db52796a6"),
    "name" : "10gen Office",
    "location" : { "type" : "Point", "coordinates" : [ -73.99171, 40.738868 ] }
}
{
    "_id" : ObjectId("5c10f3735d38908db52796a9"),
    "name" : "City Bakery ",
    "location" : { "type" : "Point", "coordinates" : [ -73.992491, 40.738673 ] }
}
{
    "_id" : ObjectId("5c10f3735d38908db52796aa"),
    "name" : "Splash Bar",
    "location" : { "type" : "Point", "coordinates" : [ -73.992491, 40.738673 ] }
}
{
    "_id" : ObjectId("5c10f3735d38908db52796ab"),
    "name" : "Momofuku Milk Bar",
    "location" : { "type" : "Point", "coordinates" : [ -73.985839, 40.731698 ] }
}
```

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

### Multi-Stage Aggregation using Projection and Sorting

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

Illustrates multi-stage aggregation with projection and sorting. The first two examples work because the sort references the projected field name or its alias. The third example fails because it sorts on 'firstname', which is not included in the projection.

```java
// generates {$project: {name: 1, netPrice: 1}}, {$sort: {name: 1}}
project("name", "netPrice"), sort(ASC, "name")

// generates {$project: {name: $firstname}}, {$sort: {name: 1}}
project().and("firstname").as("name"), sort(ASC, "name")

// does not work
project().and("firstname").as("name"), sort(ASC, "firstname")
```

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

### Query files in GridFS using GridFsOperations

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

Imperative example of querying files in GridFS using GridFsOperations.find(Query) with a query built from GridFsCriteria.whereFilename().is("filename.txt").

```java
class GridFsClient {

  @Autowired
  GridFsOperations operations;

  @Test
  public void findFilesInGridFs() {
    GridFSFindIterable result = operations.find(query(whereFilename().is("filename.txt")));
  }
}
```

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

### Using Distance with Metrics

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

Example showing how to use a Distance parameter with a Metric in a repository query method. The query uses $nearSphere instead of $near when a Metric is set, and the distance is calculated according to the Metric.

```java
Point point = new Point(43.7, 48.8);
Distance distance = new Distance(200, Metrics.KILOMETERS);
… = repository.findByLocationNear(point, distance);
// {'location' : {'$nearSphere' : [43.7, 48.8], '$maxDistance' : 0.03135711885774796}}
```

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

### Initialize MongoDB replica set

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

Initializes the MongoDB replica set with the name rs0 and a single member at 127.0.0.1:27017. This command is entered in the mongo client and only needs to be run once on the first server start.

```bash
mongo> rs.initiate({ _id: 'rs0', members: [ { _id: 0, host: '127.0.0.1:27017' } ] })
```

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

### Create Hashed Index Programmatically with IndexOperations

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

Creates a hashed index programmatically using IndexOperations and HashedIndex. This approach gives more control over index creation compared to annotation-based setup.

```java
mongoOperations.indexOpsFor(Jedi.class)
  .ensureIndex(HashedIndex.hashed("useTheForce"));
```

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

### Post-process query results with map()

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

Demonstrates using map(...) to post-process query results with a QueryResultConverter that receives the raw Document and the mapped object. The example converts each mapped Jedi into an Optional<Jedi>.

```java
List<Optional<Jedi>> result = template.query(Person.class)
    .as(Jedi.class)
    .matching(query(where("firstname").is("luke")))
    .map((document, reader) -> Optional.of(reader.get()))
    .all();
```

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

### Sample data for group_test_collection

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/mongo-group.adoc

Sample documents for the group_test_collection used in the group operation example. Each document has an _id and an x field with values 1, 1, 2, 3, 3, 3.

```json
{ "_id" : ObjectId("4ec1d25d41421e2015da64f1"), "x" : 1 }
{ "_id" : ObjectId("4ec1d25d41421e2015da64f2"), "x" : 1 }
{ "_id" : ObjectId("4ec1d25d41421e2015da64f3"), "x" : 2 }
{ "_id" : ObjectId("4ec1d25d41421e2015da64f4"), "x" : 3 }
{ "_id" : ObjectId("4ec1d25d41421e2015da64f5"), "x" : 3 }
{ "_id" : ObjectId("4ec1d25d41421e2015da64f6"), "x" : 3 }
```

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

### Store file to GridFS using ReactiveGridFsTemplate

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

Reactive example of storing a file to GridFS using ReactiveGridFsTemplate.store(Publisher<DataBuffer>, String, Object). The metadata can be an arbitrary object marshaled by the MongoConverter, or a Document.

```java
class ReactiveGridFsClient {

  @Autowired
  ReactiveGridFsTemplate operations;

  @Test
  public Mono<ObjectId> storeFileToGridFs() {

    FileMetadata metadata = new FileMetadata();
    // populate metadata
    Publisher<DataBuffer> file = … // lookup File or Resource

    return operations.store(file, "filename.txt", metadata);
  }
}
```

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

### Example Compound Index Usage

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

Defines a compound index on the Person class with lastName ascending and age descending. The index is named 'age_idx' and is created automatically when index creation is enabled.

```java
package com.mycompany.domain;

@Document
@CompoundIndex(name = "age_idx", def = "{'lastName': 1, 'age': -1}")
public class Person {

  @Id
  private ObjectId id;
  private Integer age;
  private String firstName;
  private String lastName;

}
```

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

### Basic Aggregation with newAggregation and MongoTemplate.aggregate

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

Canonical example of using the Spring Data MongoDB Aggregation Framework. Creates an Aggregation from pipeline operations and runs it with MongoTemplate.aggregate, specifying the input collection name and output type. The result is obtained via getMappedResults().

```java
import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;

Aggregation agg = newAggregation(
    pipelineOP1(),
    pipelineOP2(),
    pipelineOPn()
);

AggregationResults<OutputType> results = mongoTemplate.aggregate(agg, "INPUT_COLLECTION_NAME", OutputType.class);
List<OutputType> mappedResult = results.getMappedResults();
```

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

### Register MongoDB Micrometer customizer setup for observation

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

Registers a MongoClientSettingsBuilderCustomizer bean to add a context provider and a MongoObservationCommandListener for Spring Data MongoDB's observability support. Requires Spring Boot Actuator and manual enabling of management metrics as shown in the associated application.properties example.

```java
@Bean
MongoClientSettingsBuilderCustomizer mongoMetricsSynchronousContextProvider(ObservationRegistry registry) {
    return (clientSettingsBuilder) -> {
        clientSettingsBuilder.contextProvider(ContextProviderFactory.create(registry))
                             .addCommandListener(new MongoObservationCommandListener(registry));
    };
}
```

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

### Build reference documentation with Maven wrapper

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

Builds the project and generates the reference documentation without running tests. The resulting documentation is available from target/antora/site/index.html.

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

```

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

### Configure MongoDB repositories with @EnableMongoRepositories, @EnableReactiveMongoRepositories, or XML

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

Configuration examples for enabling MongoDB repositories. The imperative variant uses `@EnableMongoRepositories` and extends `AbstractMongoClientConfiguration`; the reactive variant uses `@EnableReactiveMongoRepositories` and extends `AbstractReactiveMongoConfiguration`. The XML variant uses the `mongo:repositories` element. Note that reactive support requires a separate configuration for MongoDB's Reactive Streams driver, and using both reactive and blocking templates/repositories results in two different connections.

```java
@Configuration
@EnableMongoRepositories("com.acme.*.repositories")
class ApplicationConfig extends AbstractMongoClientConfiguration {

  @Override
  protected String getDatabaseName() {
    return "e-store";
  }

  @Override
  protected String getMappingBasePackage() {
    return "com.acme.*.repositories";
  }
}
```

```java
@Configuration
@EnableReactiveMongoRepositories("com.acme.*.repositories")
class ApplicationConfig extends AbstractReactiveMongoConfiguration {

  @Override
  protected String getDatabaseName() {
    return "e-store";
  }

  @Override
  protected String getMappingBasePackage() {
    return "com.acme.*.repositories";
  }
}
```

```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:mongo="http://www.springframework.org/schema/data/mongo"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/data/mongo
    https://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd">

  <mongo:mongo-client id="mongoClient" />

  <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
    <constructor-arg ref="mongoClient" />
    <constructor-arg value="databaseName" />
  </bean>

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

</beans>
```

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

### Person class definition

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

Defines the Person domain class used in the save, update, and remove examples. The class is referenced by the imperative and reactive examples.

```java
include::example$example/Person.java[tags=class]
```

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

### Publisher document example

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

Example of a Publisher document stored in MongoDB. The _id field is used as the reference value for linking Book documents to Publisher documents.

```json
{
  "_id" : 8cfb002,
  "acronym" : "DR",
  "name" : "Del Rey"
}
```

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

### Using ClientSession with MongoOperations and ReactiveMongoOperations

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/client-session-transactions.adoc

Shows how to use a ClientSession with the imperative MongoOperations and the reactive ReactiveMongoOperations. The imperative version uses a Supplier to provide the session, while the reactive version uses a Publisher and defers session acquisition until subscription. Both examples demonstrate automatic session application to operations and the need to close the session.

```java
ClientSessionOptions sessionOptions = ClientSessionOptions.builder()
    .causallyConsistent(true)
    .build();

ClientSession session = client.startSession(sessionOptions); <1>

template.withSession(() -> session)
    .execute(action -> {

        Query query = query(where("name").is("Durzo Blint"));
        Person durzo = action.findOne(query, Person.class);  <2>

        Person azoth = new Person("Kylar Stern");
        azoth.setMaster(durzo);

        action.insert(azoth);                                <3>

        return azoth;
    });

session.close()                                              <4>
```

```java
ClientSessionOptions sessionOptions = ClientSessionOptions.builder()
.causallyConsistent(true)
.build();

Publisher<ClientSession> session = client.startSession(sessionOptions); <1>

template.withSession(session)
.execute(action -> {

        Query query = query(where("name").is("Durzo Blint"));
        return action.findOne(query, Person.class)
            .flatMap(durzo -> {

                Person azoth = new Person("Kylar Stern");
                azoth.setMaster(durzo);

                return action.insert(azoth);                            <2>
            });
    }, ClientSession::close)                                            <3>
    .subscribe();                                                       <4>
```

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

### Example of non-mergeable schema due to type mismatch

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

Example of a definition that cannot be merged automatically because of a data type mismatch for the property 'value'. In this case a ConflictResolutionFunction must be provided to MongoJsonSchemaCreator.

```java
class A extends Root {
	String value;
}

class B extends Root {
	Integer value;
}
```

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

### Using ReactiveMongoDatabaseFactory in standard Java code (Reactive)

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

Shows how to use SimpleReactiveMongoDatabaseFactory with MongoClients.create() to create a ReactiveMongoTemplate in a plain Java main method.

```java
public class ReactiveMongoApplication {

  public static void main(String[] args) throws Exception {

    ReactiveMongoOperations mongoOps = new MongoTemplate(new SimpleReactiveMongoDatabaseFactory(MongoClients.create(), "database"));

    // ...
  }
}

```

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

### Running Map-Reduce with classpath resources

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/mongo-mapreduce.adoc

Runs a Map-Reduce operation using `MongoOperations.mapReduce` with map and reduce functions from classpath resources. The results are iterated and printed.

```java
MapReduceResults<ValueObject> results = mongoOperations.mapReduce("jmr1", "classpath:map.js", "classpath:reduce.js", ValueObject.class);
for (ValueObject valueObject : results) {
  System.out.println(valueObject);
}
```

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

### Find and Modify with upsert option

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

Extends the previous findAndModify example by adding upsert(true) to the FindAndModifyOptions, which inserts a new document if no match is found. The example also sets returnNew(true) to obtain the newly created or updated document.

```java
Person upserted = template.update(Person.class)
  .matching(new Query(Criteria.where("firstName").is("Mary")))
  .apply(update)
  .withOptions(FindAndModifyOptions.options().upsert(true).returnNew(true))
  .findAndModifyValue()
```

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

### Using MongoDatabaseFactory in standard Java code (Imperative)

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

Shows how to use SimpleMongoClientDatabaseFactory with MongoClients.create() to create a MongoTemplate in a plain Java main method.

```java
public class MongoApplication {

  public static void main(String[] args) throws Exception {

    MongoOperations mongoOps = new MongoTemplate(new SimpleMongoClientDatabaseFactory(MongoClients.create(), "database"));

    // ...
  }
}

```

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

### ReactiveMongoTemplate save, update, and remove example

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

Shows how to use ReactiveMongoTemplate to insert, find, update, and remove a Person object using reactive types. The example uses a CountDownLatch to keep the main thread alive until the reactive stream completes.

```java
public class ReactiveMongoApplication {

  private static final Logger log = LoggerFactory.getLogger(ReactiveMongoApplication.class);

  public static void main(String[] args) throws Exception {

    CountDownLatch latch = new CountDownLatch(1);

    ReactiveMongoTemplate template = new ReactiveMongoTemplate(MongoClients.create(), "database");

    template.insert(new Person("Joe", 34)).doOnNext(person -> log.info("Insert: " + person))
      .flatMap(person -> template.findById(person.getId(), Person.class))
      .doOnNext(person -> log.info("Found: " + person))
      .zipWith(person -> template.updateFirst(query(where("name").is("Joe")), update("age", 35), Person.class))
      .flatMap(tuple -> template.remove(tuple.getT1())).flatMap(deleteResult -> template.findAll(Person.class))
      .count().doOnSuccess(count -> {
        log.info("Number of people: " + count);
        latch.countDown();
      })

      .subscribe();

    latch.await();
  }
}
```

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

### Manual Collection Setup for Queryable Encryption

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/mongo-encryption.adoc

Creates data encryption keys and configures a collection for Queryable Encryption (QE) using CollectionOptions.encryptedCollection. Defines encrypted fields with algorithms (Indexed, Range) and query options (equality, range) with contention factors and bounds. Provides full control over encryption configuration.

```java
BsonBinary pinDK = clientEncryption.createDataKey("local", new com.mongodb.client.model.vault.DataKeyOptions());
BsonBinary ssnDK = clientEncryption.createDataKey("local", new com.mongodb.client.model.vault.DataKeyOptions());
BsonBinary ageDK = clientEncryption.createDataKey("local", new com.mongodb.client.model.vault.DataKeyOptions());
BsonBinary signDK = clientEncryption.createDataKey("local", new com.mongodb.client.model.vault.DataKeyOptions());

CollectionOptions collectionOptions = CollectionOptions.encryptedCollection(options -> options
    .encrypted(string("pin"), pinDK)
    .queryable(encrypted(string("ssn")).algorithm("Indexed").keyId(ssnDK.asUuid()), equality().contention(0))
    .queryable(encrypted(int32("age")).algorithm("Range").keyId(ageDK.asUuid()), range().contention(8).min(0).max(150))
    .queryable(encrypted(int64("address.sign")).algorithm("Range").keyId(signDK.asUuid()), range().contention(2).min(-10L).max(10L))
);

```

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

### Complex Mapping Example with Annotations

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

Example of a complex mapping using annotations like @Document, @CompoundIndex, @Id, @Indexed, @Field, @Transient, @DBRef, and @PersistenceCreator. Shows a generic Person class with a constructor for persistence and a comment noting that other getters/setters are omitted.

```java
@Document
@CompoundIndex(name = "age_idx", def = "{'lastName': 1, 'age': -1}")
public class Person<T extends Address> {

  @Id
  private String id;

  @Indexed(unique = true)
  private Integer ssn;

  @Field("fName")
  private String firstName;

  @Indexed
  private String lastName;

  private Integer age;

  @Transient
  private Integer accountTotal;

  @DBRef
  private List<Account> accounts;

  private T address;

  public Person(Integer ssn) {
    this.ssn = ssn;
  }

  @PersistenceCreator
  public Person(Integer ssn, String firstName, String lastName, Integer age, T address) {
    this.ssn = ssn;
    this.firstName = firstName;
    this.lastName = lastName;
    this.age = age;
    this.address = address;
  }

  public String getId() {
    return id;
  }

  // no setter for Id.  (getter is only exposed for some unit testing)

  public Integer getSsn() {
    return ssn;
  }

// other getters/setters omitted
}
```

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

### Repository interfaces extending QuerydslPredicateExecutor

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

Shows how to add Querydsl support to a repository by extending the executor interfaces. The imperative example extends MongoRepository and QuerydslPredicateExecutor; the reactive example extends ReactiveMongoRepository and ReactiveQuerydslPredicateExecutor. Note that joins (DBRef's) are not supported with reactive MongoDB support.

```java
interface PersonRepository extends MongoRepository<Person, String>, QuerydslPredicateExecutor<Person> {

    // additional query methods go here
}
```

```java
interface PersonRepository extends ReactiveMongoRepository<Person, String>, ReactiveQuerydslPredicateExecutor<Person> {

    // additional query methods go here
}
```

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

### Configuring MongoClient with credentials (Java)

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

Shows a @Configuration class extending AbstractMongoClientConfiguration to set database name and configure MongoClient settings with MongoCredential and cluster settings.

```java
@Configuration
public class MongoAppConfig extends AbstractMongoClientConfiguration {

  @Override
  public String getDatabaseName() {
    return "database";
  }

  @Override
  protected void configureClientSettings(Builder builder) {

    builder
        .credential(MongoCredential.createCredential("name", "db", "pwd".toCharArray()))
        .applyToClusterSettings(settings  -> {
          settings.hosts(singletonList(new ServerAddress("127.0.0.1", 27017)));
        });
  }
}

```

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

### Query Vector Index

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/mongo-search-indexes.adoc

Queries a vector index using the $vectorSearch aggregation stage. The Java example uses VectorSearchOperation with the index name, path, vector, numCandidates, limit, and optionally adds a search score field. The Shell example shows the equivalent aggregation with a $addFields stage for the score.

```java
VectorSearchOperation search = VectorSearchOperation.search("vector_index") <1>
  .path("plotEmbedding") <2>
  .vector( ... )
  .numCandidates(150)
  .limit(10)
  .withSearchScore("score"); <3>

AggregationResults<MovieWithSearchScore> results = mongoTemplate
  .aggregate(newAggregation(Movie.class, search), MovieWithSearchScore.class);
```

```console
db.embedded_movies.aggregate([
  {
    "$vectorSearch": {
      "index": "vector_index",
      "path": "plot_embedding", <1>
      "queryVector": [ ... ],
      "numCandidates": 150,
      "limit": 10
    }
  },
  {
    "$addFields": {
      "score": { $meta: "vectorSearchScore" }
    }
  }
])
```

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

### TagCount Domain Class

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

Domain class used in the aggregation example to hold the result of counting tags.

```java
class TagCount {
 String tag;
 int n;
}
```

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

### Tailable Cursors with MessageListener instances

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/tailable-cursors.adoc

Shows how to set up a MessageListenerContainer to listen to a capped collection using the sync driver. The container must be started before registering requests, and stopped when no longer needed. The listener receives messages converted to the requested domain type, or Document for raw results.

```java
MessageListenerContainer container = new DefaultMessageListenerContainer(template);
container.start();                                                                  <1>

MessageListener<Document, User> listener = System.out::println;                     <2>

TailableCursorRequest request = TailableCursorRequest.builder()
  .collection("orders")                                                             <3>
  .filter(query(where("value").lt(100)))                                            <4>
  .publishTo(listener)                                                              <5>
  .build();

container.register(request, User.class);                                            <6>

// ...

container.stop();                                                                   <7>
```

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

### Applying Index Hints with withHint()

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

Apply index hints to a query using either the index name or its field definition. Use withHint() on the query object.

```java
template.query(Person.class)
    .matching(query("...").withHint("index-to-use"));

template.query(Person.class)
    .matching(query("...").withHint("{ firstname : 1 }"));
```

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

### Aggregation pipeline update with AggregationUpdate and MongoDB shell

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

Demonstrates an aggregation pipeline update using `AggregationUpdate` in Java and the equivalent MongoDB shell command. The Java example uses `Aggregation.newUpdate()` with `set` and `switchCases` to compute an average and assign a grade, then applies it via `template.update(Student.class).apply(update).all()`. The JavaScript example shows the same logic with `$set`, `$avg`, `$switch`, and `multi: true`.

```java
AggregationUpdate update = Aggregation.newUpdate()
    .set("average").toValue(ArithmeticOperators.valueOf("tests").avg())     <1>
    .set("grade").toValue(ConditionalOperators.switchCases(                 <2>
        when(valueOf("average").greaterThanEqualToValue(90)).then("A"),
        when(valueOf("average").greaterThanEqualToValue(80)).then("B"),
        when(valueOf("average").greaterThanEqualToValue(70)).then("C"),
        when(valueOf("average").greaterThanEqualToValue(60)).then("D"))
        .defaultTo("F")
    );

template.update(Student.class)                                              <3>
    .apply(update)
    .all();                                                                 <4>
```

```javascript
db.students.update(                                                         <3>
   { },
   [
     { $set: { average : { $avg: "$tests" } } },                            <1>
     { $set: { grade: { $switch: {                                          <2>
                           branches: [
                               { case: { $gte: [ "$average", 90 ] }, then: "A" },
                               { case: { $gte: [ "$average", 80 ] }, then: "B" },
                               { case: { $gte: [ "$average", 70 ] }, then: "C" },
                               { case: { $gte: [ "$average", 60 ] }, then: "D" }
                           ],
                           default: "F"
     } } } }
   ],
   { multi: true }                                                          <4>
)
```

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

### SpEL Array Creation in Projection

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

Example of using SpEL 'new' to create an array in a projection expression, generating a $setEquals operation.

```java
// { $setEquals : [$a, [5, 8, 13] ] }
.andExpression("setEquals(a, new int[]{5, 8, 13})");
```

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

### SpEL Expression Example

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

SpEL expression used in projection expressions to define complex calculations. Translated into MongoDB projection expression parts.

```java
1 + (q + 1) / (q - 1)
```

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

### Map-Reduce with static import for options

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/mongo-mapreduce.adoc

Uses the static import `import static org.springframework.data.mongodb.core.mapreduce.MapReduceOptions.options;` to make the syntax more compact when specifying the output collection.

```java
MapReduceResults<ValueObject> results = mongoOperations.mapReduce("jmr1", "classpath:map.js", "classpath:reduce.js",
                                                                     options().outputCollection("jmr1_out"), ValueObject.class);
```

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

### XML: mongo-client with defaults

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/migration-guide/migration-guide-2.x-to-3.x.adoc

Basic configuration for a MongoDB client with default settings.

```xml
<mongo:mongo.mongo-client id="with-defaults" />
```

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

### MongoTemplate optimistic locking save example

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

Updates a versioned document with `template.save` and then attempts to save a stale copy, which throws `OptimisticLockingFailureException` because the version has changed.

```java
daenerys.setLastname("Targaryen");
template.save(daenerys);                                                              <3>

template.save(tmp); // throws OptimisticLockingFailureException                       <4>
```

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

### Sort By Count Example

Source: https://github.com/spring-projects/spring-data-mongodb/blob/main/src/main/antora/modules/ROOT/pages/mongodb/aggregation-framework.adoc

Sort by count operation that groups documents by the value of the specified field and sorts by count. Requires a grouping field or expression.

```java
// generates { $sortByCount: "$country" }
sortByCount("country");
```

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

### Create a Collation with Collation.of and options

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

Creates a French collation with secondary strength including case, numeric ordering, shifted punctuation alternate, forward diacritic sort, and normalization enabled. The locale is mandatory for creation; strength options depend on the selected level.

```java
Collation collation = Collation.of("fr")         <1>

  .strength(ComparisonLevel.secondary()          <2>
    .includeCase())

  .numericOrderingEnabled()                      <3>

  .alternate(Alternate.shifted().punct())        <4>

  .forwardDiacriticSort()                        <5>

  .normalizationEnabled();                       <6>
```

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

### MongoCustomConversions Configuration with PropertyValueConversions

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

Configures MongoCustomConversions with a custom PropertyValueConverterFactory and a registry of programmatically registered converters. This setup is used to enable programmatic value conversions.

```java
MongoCustomConversions.create(configurationAdapter -> {

    SimplePropertyValueConversions valueConversions = new SimplePropertyValueConversions();
    valueConversions.setConverterFactory(…);
    valueConversions.setValueConverterRegistry(new PropertyValueConverterRegistrar()
        .registerConverter(…)
        .buildRegistry());

    configurationAdapter.setPropertyValueConversions(valueConversions);
});
```

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

### Using Collations in Queries

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

Specify a Collation instance in the query to use collations with collection operations. The example shows creating a Collation for German locale and using it in a query.

```java
Collation collation = Collation.of("de");

Query query = new Query(Criteria.where("firstName").is("Amél"))
    .collation(collation);

List<Person> results = template.find(query, Person.class);
```
Tokens:
Raw