Spring Data MongoDB & Redis

It is Spring Data's reactive interface for MongoDB. Query methods return Mono<T> for zero-or-one result and Flux<T> for many. Nothing runs until you subscribe.

MongoRepository is a Spring Data interface for a MongoDB collection giving CRUD out of the box. You add method names like findByLastName, and Spring parses the name into a query automatically — no implementation code needed.

Build a Query object with Criteria (the filter conditions), then call mongoTemplate.find(query, EntityClass.class). Criteria.where("field").is(value) builds the filter; find returns a List of mapped objects.

RedisCacheManager is the CacheManager implementation that stores cache entries in Redis. When you use @Cacheable, Spring asks it for a RedisCache, which reads/writes values as Redis keys so cached data survives restarts and is shared across instances.

RedisTemplate is Spring's helper class for talking to Redis. You get an operations object like opsForValue() and call set/get. StringRedisTemplate is a ready-made version where keys and values are Strings.

@Query lets you write the raw MongoDB query as a JSON filter string on a repository method, with ?0, ?1 placeholders for arguments. Use it when the query is too complex for a readable derived method name.

updateFirst modifies the first matching document, updateMulti modifies all matching ones — both take a Query and an Update with operators like $set. insert always creates a new document; save inserts if new or replaces the whole document if the _id already exists (upsert-by-id).

You build a RedisCacheConfiguration and set options on it: entryTtl(Duration) for expiry, a value serializer (e.g. JSON), disableCachingNullValues(), and a key prefix. You pass it to RedisCacheManager as the default and/or per cache.

Define a RedisTemplate bean and call setKeySerializer/setValueSerializer (and the hash variants). Common choices: StringRedisSerializer for keys and a JSON serializer for values, so data is readable and language-neutral.

The reactive driver honours reactive-streams demand: the subscriber requests N items, and the driver fetches from MongoDB in batches to match, pausing when demand is zero. So a slow consumer naturally throttles the query instead of buffering everything.

Use Aggregation.newAggregation(...) with static stage helpers: match(Criteria) filters, group(fields).sum/count aggregates, project(...) reshapes output. Run it with mongoTemplate.aggregate(agg, "collection", OutputType.class), then read results via getMappedResults().

@DBRef stores a link to a document in another collection instead of embedding it. On load, Spring fetches the referenced document with a separate query. It has no cascade and can cause many extra reads (N+1).

@Indexed declares a secondary index on one field; @CompoundIndex (on the class) declares a multi-field index. Spring only creates them automatically if auto-index-creation is enabled, which is off by default in recent versions.

@Tailable makes a Flux query use a tailable cursor: it stays open and keeps emitting new matching documents as they are inserted, like tail -f. It requires a capped collection and must return Flux.

Use the repository for simple CRUD and derived queries. Drop to ReactiveMongoTemplate when you need dynamic queries, aggregations, partial updates, upserts, or fine control the repository abstraction cannot express, still returning Mono/Flux.

Build the manager with RedisCacheManager.builder(cf), set a default via cacheDefaults(cfg), then override specific caches with withInitialCacheConfigurations(Map<name, RedisCacheConfiguration>) — each entry a config with its own TTL/serializer.

Annotate a class with @RedisHash and give it an @Id field, then declare a CrudRepository for it. Spring stores each object as a Redis hash under a key like keyspace:id, and save/findById/delete work like JPA.

MappingMongoConverter is the component that turns your objects into BSON documents and back, using the mapping metadata. For types it can't map well, you write Converter<A,B> pairs and register them via MongoCustomConversions so they take over reading/writing that type.

changeStream on ReactiveMongoTemplate opens a Flux of change events (insert, update, delete, replace) on any collection, backed by the replica-set oplog. Unlike @Tailable it needs no capped collection, sees all operation types, and supports resume tokens.

@Aggregation lets a repository method run a MongoDB aggregation pipeline. You supply an array of pipeline stage strings ($match, $group, $sort, ...) with ?0 placeholders, and Spring maps each output document to the method's return type.

You add a derived method with the Near keyword taking a Point and a Distance, e.g. findByLocationNear(Point p, Distance d). The location field needs a geospatial index (@GeoSpatialIndexed), and returning GeoResults gives each hit's distance.

unwind flattens an array field: it emits one output document per array element. lookup performs a left-outer join to another collection, adding matched documents as a new array field. In Spring: Aggregation.unwind("items") and Aggregation.lookup("from", "localField", "foreignField", "as").

Publish with redisTemplate.convertAndSend(channel, message). To receive, register a RedisMessageListenerContainer bean, give it the connection factory, and addMessageListener(listener, topic) where the listener implements MessageListener (often via a MessageListenerAdapter that delegates to a POJO).

Add @Indexed to a field; Spring keeps a Redis SET of ids per field value (like people:firstname:Ann). Then a derived finder such as findByFirstname reads that set. Without @Indexed you can't query by that field.

Handle stream errors with resubscription, persist and resume from tokens for gap-free at-least-once delivery, make handlers idempotent, keep the oplog window larger than max consumer lag, bound backpressure, and coordinate consumers so events are processed once across instances.

Use derived methods for simple readable finders, @Query for native JSON filters/projections too complex for a name, @Aggregation for grouping and multi-stage pipelines, and MongoTemplate when the query must be built dynamically at runtime.

Filter early with an indexed $match, sort/limit for top-N, and set AggregationOptions.allowDiskUse(true) when $group/$sort exceed the 100 MB in-memory stage limit. Spring maps each result document to your output DTO via getMappedResults; unmatched fields are dropped.

Use Redis as the shared cache (RedisCacheManager) so all instances see the same entries, and broadcast invalidations via pub/sub (RedisMessageListenerContainer) when local near-caches must be evicted. For failures, wrap the cache with a CacheErrorHandler or circuit breaker so Redis outages degrade to the DB instead of erroring.

On read, MappingMongoConverter picks a persistence constructor (or default), maps constructor args from document fields, then sets remaining properties by field access. It writes a _class type hint so polymorphic/abstract types can be reconstructed. Immutable objects and missing/extra fields are the main edge cases.