Spring Data MongoDB

Spring Data MongoDB provides integration between the Spring Framework and MongoDB. It offers two primary ways to interact with the database:

1. Template Classes: Core API usage via template classes (e.g., MongoTemplate) for fine-grained control over database operations.
2. Repositories: A lightweight, repository-style data access abstraction that allows for a consistent programming model across different Spring Data modules.

Key areas of focus include MongoDB connectivity, repository usage, observability integration, and specialized support for Kotlin.

MongoTemplate (imperative) and ReactiveMongoTemplate (reactive) are the central classes in Spring Data MongoDB for interacting with the database. They provide convenience operations for CRUD (Create, Read, Update, Delete) and handle the mapping between your domain objects and MongoDB documents.

Key Characteristics:

• Thread-safety: Once configured, MongoTemplate is thread-safe and can be reused across multiple instances.
• Interface Preference: It is recommended to reference operations via the MongoOperations interface rather than the concrete MongoTemplate class.
• Domain Object Support: Unlike the base MongoDB driver which works with Document objects, these templates allow you to pass and receive your own domain objects directly.

Spring Data MongoDB is built on the MongoDB Reactive Streams driver, providing interoperability with the Reactive Streams initiative.

While the API is dynamic (defined by your query methods), you can choose your preferred composition library by extending specific interfaces:

• Project Reactor: Use ReactiveCrudRepository or ReactiveSortingRepository. These return Flux and Mono types.
• RxJava3: Use RxJava3CrudRepository or RxJava3SortingRepository.

Spring Data handles the conversion between these reactive wrapper types behind the scenes.

In the context of Spring Data MongoDB vector searches, Score and Similarity are used to handle the similarity values returned by MongoDB.

• Score: Used to specify a threshold. For example, Score.of(0.9) returns results with a similarity of 0.9 or greater.
• Similarity: Similar to Score, Similarity.of(0.9) also returns results with a similarity of 0.9 or greater.
• Range<Similarity>: Allows for a bounded similarity search. For example, Similarity.between(0.5, 1) returns results with a similarity between 0.5 and 1.0 or greater.

Note that the scoring function is not configurable via these objects because it is tied to the MongoDB index configuration.

Auditing requires a mechanism to determine the current user (the 'auditor'). You do this by providing a bean that implements AuditorAware<T> (for imperative) or ReactiveAuditorAware<T> (for reactive).

If you have only one such bean in your ApplicationContext, Spring Data MongoDB will pick it up automatically. If you have multiple implementations, you must specify which one to use by setting the auditorAwareRef attribute in your enablement annotation.

// Imperative example
@Bean
public AuditorAware<AuditableUser> myAuditorProvider() {
    return new AuditorAwareImpl();
}

// Reactive example
@Bean
public ReactiveAuditorAware<AuditableUser> myAuditorProvider() {
    return new ReactiveAuditorAwareImpl();
}

While type-based conversion (via CustomConversions) applies to all instances of a specific type, Property Converters allow you to define conversion rules on a per-property basis.

Use Property Converters when you only want to transform specific values or properties of a type rather than the entire type globally. A PropertyValueConverter can transform a value into its store representation (write) and back (read). It has access to a ValueConversionContext which provides mapping metadata and direct read/write methods.

When using Spring Data's core web infrastructure, the MongoDB module automatically registers Jackson Modules to the ObjectMapper to handle de/serialization of common Spring Data domain types. Specifically, the MongoDB module provides GeoJsonDeserializers for the following GeoJSON types via GeoJsonConfiguration and the GeoJsonModule:

• org.springframework.data.mongodb.core.geo.GeoJsonPoint
• org.springframework.data.mongodb.core.geo.GeoJsonMultiPoint
• org.springframework.data.mongodb.core.geo.GeoJsonLineString
• org.springframework.data.mongodb.core.geo.GeoJsonMultiLineString
• org.springframework.data.mongodb.core.geo.GeoJsonPolygon
• org.springframework.data.mongodb.core.geo.GeoJsonMultiPolygon

For advanced scenarios, you can implement the WriteConcernResolver interface to apply different WriteConcern values on a per-operation basis (e.g., based on the POJO type).

The resolve(MongoAction action) method provides a MongoAction object containing context such as the collection name, the POJO class, the operation type (REMOVE, UPDATE, INSERT, INSERT_LIST, or SAVE), and the converted Document.

public class MyAppWriteConcernResolver implements WriteConcernResolver {

@Override
  public WriteConcern resolve(MongoAction action) {
    if (action.getEntityType().getSimpleName().contains("Audit")) {
      return WriteConcern.ACKNOWLEDGED;
    } else if (action.getEntityType().getSimpleName().contains("Metadata")) {
      return WriteConcern.JOURNALED;
    }
    return action.getDefaultWriteConcern();
  }
}

Explicit encryption uses the @ExplicitEncrypted annotation to perform encryption and decryption tasks via the MongoDB driver's encryption library. This annotation combines @Encrypted (for JSON Schema) and a PropertyConverter.

Encryption Behavior by Type

• Simple types (e.g., String): Encrypts the value if not null.
• Objects (e.g., Address): Encrypts the entire object and all nested fields as a single Document. To encrypt specific sub-fields, annotate those sub-fields individually.
• Collections/Maps: Encrypted as a single value, not per entry.

Referencing Data Encryption Keys (DEK)

You can reference a DEK via its id or an alternative name using @EncryptedField:

• altKeyName = "secret-key": Uses the DEK with that alternative name.
• altKeyName = "/name": Uses a field reference to read a value from the document to use as the key lookup.