[Advanced Spring Boot] NoSQL với Spring Data: MongoDB và Redis

curl -s "https://start.spring.io/starter.zip?type=gradle-project&language=java&bootVersion=4.1.1&javaVersion=21&groupId=com.example&artifactId=demo&name=demo&packageName=com.example.demo&dependencies=web,data-mongodb,data-redis,validation,actuator" -o demo.zip

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-actuator'
	implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
	implementation 'org.springframework.boot:spring-boot-starter-validation'
	implementation 'org.springframework.boot:spring-boot-starter-webmvc'
	testImplementation 'org.springframework.boot:spring-boot-starter-actuator-test'
	testImplementation 'org.springframework.boot:spring-boot-starter-data-mongodb-test'
	testImplementation 'org.springframework.boot:spring-boot-starter-data-redis-test'
	testImplementation 'org.springframework.boot:spring-boot-starter-validation-test'
	testImplementation 'org.springframework.boot:spring-boot-starter-webmvc-test'
	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

+--- org.springframework.boot:spring-boot-starter-data-mongodb -> 4.1.1
|    +--- org.springframework.boot:spring-boot-starter-mongodb:4.1.1
|    |    +--- org.springframework.boot:spring-boot-starter:4.1.1 (*)
|    |    +--- org.springframework.boot:spring-boot-mongodb:4.1.1
|    |    \--- org.mongodb:mongodb-driver-sync:5.8.1
|    \--- org.springframework.boot:spring-boot-data-mongodb:4.1.1
|         ...
|         \--- org.springframework.data:spring-data-mongodb:5.1.1

Multiple Spring Data modules found, entering strict repository configuration mode
Bootstrapping Spring Data MongoDB repositories in DEFAULT mode.
Spring Data MongoDB - Could not safely identify store assignment for repository candidate interface com.example.demo.reservation.ReservationRepository; If you want this repository to be a MongoDB repository, consider annotating your entities with one of these annotations: org.springframework.data.mongodb.core.mapping.Document (preferred), or consider extending one of the following types with your repository: org.springframework.data.mongodb.repository.MongoRepository
Finished Spring Data repository scanning in 60 ms. Found 3 MongoDB repository interfaces.
Multiple Spring Data modules found, entering strict repository configuration mode
Bootstrapping Spring Data Redis repositories in DEFAULT mode.
Finished Spring Data repository scanning in 3 ms. Found 1 Redis repository interface.

docker run -d --name sba-a11-mongo --memory 1g -p 27111:27017 mongo:8 --replSet rs0 --wiredTigerCacheSizeGB 0.25

docker exec sba-a11-mongo mongosh --quiet --eval 'rs.initiate({_id: "rs0", members: [{_id: 0, host: "localhost:27017"}]})'

docker run -d --name sba-a11-redis --memory 512m -p 6311:6379 redis:8

org.springframework.dao.DataAccessResourceFailureException: Timed out while waiting for a server that matches WritableServerSelector. Client view of cluster state is {type=REPLICA_SET, servers=[{address=localhost:27017, type=UNKNOWN, state=CONNECTING, exception={com.mongodb.MongoSocketOpenException: Exception opening socket}, caused by {java.net.ConnectException: Connection refused}}]

java -Xmx512m -jar build/libs/demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=lab --lab=queries --spring.main.web-application-type=none

package com.example.demo.product;
 
import java.time.Instant;
 
public record Review(String author, int rating, String comment, Instant createdAt) {
}

package com.example.demo.brand;
 
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
 
@Document("brands")
public record Brand(@Id String id, String name, String country) {
}

package com.example.demo.product;
 
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
 
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.CompoundIndex;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.DocumentReference;
import org.springframework.data.mongodb.core.mapping.Field;
 
import com.example.demo.brand.Brand;
 
@Document("products")
@CompoundIndex(name = "category_price", def = "{ 'category': 1, 'price': 1 }")
public class Product {
 
    @Id
    private String id;
 
    @Indexed(unique = true)
    private String sku;
 
    private String name;
 
    private String description;
 
    private String category;
 
    private BigDecimal price;
 
    @Field("qty")
    private int stock;
 
    @DocumentReference
    private Brand brand;
 
    private Map<String, Object> attributes = new LinkedHashMap<>();
 
    private List<Review> reviews = new ArrayList<>();
 
    private int reviewCount;
 
    protected Product() {
    }
 
    public Product(String sku, String name, String category, BigDecimal price, int stock, Brand brand) {
        this.sku = sku;
        this.name = name;
        this.category = category;
        this.price = price;
        this.stock = stock;
        this.brand = brand;
    }
 
    public void addReview(Review review) {
        reviews.add(review);
        reviewCount++;
    }
 
    // getters for every field; setters for description, price and stock
}

Product k2 = new Product("KB-K2-BRN", "Keychron K2 Wireless", "keyboard", new BigDecimal("89.00"), 25, keychron);
attributes(k2, "layout", "75%", "switchType", "brown", "wireless", true);
k2.setDescription("Compact wireless mechanical keyboard");
k2.addReview(review("minh", 5, "Great switches"));
k2.addReview(review("lan", 4, "Battery could be better"));
k2.addReview(review("tuan", 5, "Perfect for Mac"));

docker exec sba-a11-mongo mongosh catalog --quiet --eval 'printjson(db.products.findOne({sku: "KB-K2-BRN"}))'

{
  _id: ObjectId('6aace449f1341b7637fcb0d4'),
  sku: 'KB-K2-BRN',
  name: 'Keychron K2 Wireless',
  description: 'Compact wireless mechanical keyboard',
  category: 'keyboard',
  price: Decimal128('89.00'),
  qty: 25,
  brand: ObjectId('6aace448f1341b7637fcb0cd'),
  attributes: {
    layout: '75%',
    switchType: 'brown',
    wireless: true
  },
  reviews: [
    {
      author: 'minh',
      rating: 5,
      comment: 'Great switches',
      createdAt: ISODate('2026-09-18T07:00:00.000Z')
    },
    {
      author: 'lan',
      rating: 4,
      comment: 'Battery could be better',
      createdAt: ISODate('2026-09-18T07:00:00.000Z')
    },
    { … }
  ],
  reviewCount: 3,
  _class: 'com.example.demo.product.Product'
}

{"_id": {"$oid": "6aace4692b01124767e79b4c"}, "note": "id left null", "_class": "com.example.demo.lab.MappingProbeLab$IdProbe"}
{"_id": "sku-KB-K2-BRN", "note": "id set to a plain string", "_class": "com.example.demo.lab.MappingProbeLab$IdProbe"}
{"_id": {"$oid": "6aace4692b01124767e79b4d"}, "note": "id set to 24 hex characters", "_class": "com.example.demo.lab.MappingProbeLab$IdProbe"}

{"_id": "promo", "discounts": [{"percent": 10, "_class": "com.example.demo.lab.MappingProbeLab$PercentOff"}, {"amount": {"$numberDecimal": "5.00"}, "_class": "fixed"}], "_class": "com.example.demo.lab.MappingProbeLab$Promo"}

org.springframework.data.mapping.model.MappingInstantiationException: Failed to instantiate com.example.demo.lab.MappingProbeLab$Discount using constructor NO_CONSTRUCTOR with arguments 

{"find": "products", "filter": {}, "$db": "catalog"}
{"find": "brands", "filter": {"_id": {"$oid": "6aace448f1341b7637fcb0cd"}}, "limit": 1, "singleBatch": true, "$db": "catalog"}
{"find": "brands", "filter": {"_id": {"$oid": "6aace448f1341b7637fcb0cd"}}, "limit": 1, "singleBatch": true, "$db": "catalog"}
{"find": "brands", "filter": {"_id": {"$oid": "6aace448f1341b7637fcb0ce"}}, "limit": 1, "singleBatch": true, "$db": "catalog"}
{"find": "brands", "filter": {"_id": {"$oid": "6aace448f1341b7637fcb0cf"}}, "limit": 1, "singleBatch": true, "$db": "catalog"}
{"find": "brands", "filter": {"_id": {"$oid": "6aace448f1341b7637fcb0d0"}}, "limit": 1, "singleBatch": true, "$db": "catalog"}
{"find": "brands", "filter": {"_id": {"$oid": "6aace448f1341b7637fcb0d1"}}, "limit": 1, "singleBatch": true, "$db": "catalog"}
{"find": "brands", "filter": {"_id": {"$oid": "6aace449f1341b7637fcb0d2"}}, "limit": 1, "singleBatch": true, "$db": "catalog"}
{"find": "brands", "filter": {"_id": {"$oid": "6aace449f1341b7637fcb0d3"}}, "limit": 1, "singleBatch": true, "$db": "catalog"}

package com.example.demo.product;
 
import java.math.BigDecimal;
 
import org.bson.types.ObjectId;
import org.springframework.data.mongodb.core.mapping.Field;
 
public record ProductListItem(String id, String name, BigDecimal price, @Field("brand") ObjectId brandId) {
}

List<ProductListItem> items = products.findAllBy(ProductListItem.class);
Set<String> brandIds = items.stream().map(i -> i.brandId().toHexString()).collect(Collectors.toSet());
Map<String, Brand> byId = brands.findAllById(brandIds).stream()
        .collect(Collectors.toMap(Brand::id, Function.identity()));

{"find": "products", "filter": {}, "projection": {"price": 1, "brand": 1, "name": 1, "_id": 1}, "$db": "catalog"}
{"find": "brands", "filter": {"_id": {"$in": [{"$oid": "6aace449f1341b7637fcb0d3"}, {"$oid": "6aace449f1341b7637fcb0d2"}, {"$oid": "6aace448f1341b7637fcb0d0"}, {"$oid": "6aace448f1341b7637fcb0d1"}, {"$oid": "6aace448f1341b7637fcb0ce"}, {"$oid": "6aace448f1341b7637fcb0cd"}, {"$oid": "6aace448f1341b7637fcb0cf"}]}}, "$db": "catalog"}

package com.example.demo.product;
 
import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;
 
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;
 
public interface ProductRepository extends MongoRepository<Product, String> {
 
    Optional<Product> findBySku(String sku);
 
    List<Product> findByCategoryAndPriceLessThan(String category, BigDecimal maxPrice, Sort sort);
 
    List<Product> findByNameContainingIgnoreCase(String text);
 
    List<Product> findByStockLessThan(int threshold);
 
    List<Product> findByReviewsRatingGreaterThanEqual(int rating);
 
    List<Product> findByDescriptionContaining(String text);
 
    @Query("{ 'category': ?0, 'attributes.switchType': ?1 }")
    List<Product> findKeyboardsBySwitch(String category, String switchType);
 
    @Query(value = "{ 'reviewCount': { '$gte': ?0 } }", fields = "{ 'sku': 1, 'name': 1, 'reviewCount': 1 }")
    List<Product> findWellReviewed(int minReviews);
 
    <T> List<T> findByCategory(String category, Class<T> type);
 
    <T> List<T> findAllBy(Class<T> type);
}

org.springframework.dao.IncorrectResultSizeDataAccessException: Query { "$java" : Query: { "sku" : "KB-K8-RED"}, Fields: {}, Sort: {} } returned non unique result

Command "find" started on database "catalog" using a connection with driver-generated ID 3 and server-generated ID 26 to localhost:27111. The request ID is 5 and the operation ID is 5. Command: {"find": "products", "filter": {"sku": "KB-K2-BRN"}, "limit": 2, "$db": "catalog", …}
Command "find" started on database "catalog" … Command: {"find": "brands", "filter": {"_id": {"$oid": "6aace448f1341b7637fcb0cd"}}, "limit": 1, "singleBatch": true, "$db": "catalog", …}

Query query = new Query(Criteria.where("category").is("headphones")
        .and("attributes.anc").is(true)
        .and("price").lte(new BigDecimal("350")))
        .with(Sort.by(Sort.Direction.DESC, "reviewCount"))
        .limit(5);
mongo.find(query, ProductListItem.class, "products").forEach(System.out::println);
 
Query attention = new Query(new Criteria().orOperator(
        Criteria.where("reviews").elemMatch(Criteria.where("rating").lte(2)),
        Criteria.where("stock").is(0)));
mongo.find(attention, Product.class).forEach(p -> System.out.println(p.getSku()));
 
System.out.println(mongo.count(new Query(Criteria.where("attributes.wireless").is(true)), Product.class));

{"find": "products", "filter": {"category": "headphones", "attributes.anc": true, "price": {"$lte": {"$numberDecimal": "350"}}}, "sort": {"reviewCount": -1}, "limit": 5, "$db": "catalog"}
ProductListItem[id=6aace449f1341b7637fcb0d9, name=Sony WH-1000XM5, price=329.00, brandId=6aace448f1341b7637fcb0d1]
ProductListItem[id=6aace449f1341b7637fcb0db, name=Sennheiser Momentum 4, price=299.95, brandId=6aace449f1341b7637fcb0d3]
{"find": "products", "filter": {"$or": [{"reviews": {"$elemMatch": {"rating": {"$lte": 2}}}}, {"qty": 0}]}, "$db": "catalog"}
MN-27GP850
{"aggregate": "products", "pipeline": [{"$match": {"attributes.wireless": true}}, {"$group": {"_id": 1, "n": {"$sum": 1}}}], "cursor": {}, "$db": "catalog"}
3

public void addReview(String sku, Review review) {
    Product product = products.findBySku(sku).orElseThrow(() -> new ProductNotFoundException(sku)); 
    product.addReview(review); 
    products.save(product); 
    UpdateResult result = mongo.updateFirst( 
            Query.query(Criteria.where("sku").is(sku)), 
            new Update().push("reviews", review).inc("reviewCount", 1), 
            Product.class); 
    if (result.getMatchedCount() == 0) { 
        throw new ProductNotFoundException(sku); 
    } 
}

{ q: { _id: ObjectId('6aace449f1341b7637fcb0db') }, upsert: true,
  uKeys: [ '_id', 'sku', 'name', 'category', 'price', 'qty', 'brand', 'attributes', 'reviews', 'reviewCount', '_class' ],
  nModified: 1, docsExamined: 1 }
{ q: { sku: 'HP-MOMENTUM4' }, upsert: false,
  uKeys: [ '$push', '$inc' ],
  nModified: 1, docsExamined: 8 }

public static Map<String, Integer> run(int threads, IntConsumer task) throws InterruptedException {
    CountDownLatch start = new CountDownLatch(1);
    CountDownLatch done = new CountDownLatch(threads);
    Map<String, Integer> errors = new ConcurrentHashMap<>();
    try (ExecutorService pool = Executors.newFixedThreadPool(threads)) {
        for (int i = 0; i < threads; i++) {
            int n = i;
            pool.submit(() -> {
                try {
                    start.await();
                    task.accept(n);
                } catch (Exception e) {
                    errors.merge(e.getClass().getSimpleName(), 1, Integer::sum);
                } finally {
                    done.countDown();
                }
            });
        }
        start.countDown();
        done.await();
    }
    return errors;
}

load-modify-save   round 1: 50 calls, reviews stored=1, reviewCount=1, errors={}
load-modify-save   round 2: 50 calls, reviews stored=5, reviewCount=5, errors={}
load-modify-save   round 3: 50 calls, reviews stored=5, reviewCount=5, errors={}
atomic $push/$inc  round 1: 50 calls, reviews stored=50, reviewCount=50, errors={}
atomic $push/$inc  round 2: 50 calls, reviews stored=50, reviewCount=50, errors={}
atomic $push/$inc  round 3: 50 calls, reviews stored=50, reviewCount=50, errors={}

    private int reviewCount;
 
    @Version
    private Long version; 

org.springframework.dao.DuplicateKeyException: Write operation error on MongoDB server localhost:27111. Write error: WriteError{code=11000, message='E11000 duplicate key error collection: catalog.products index: _id_ dup key: { _id: ObjectId('6aace449f1341b7637fcb0db') }', details={}}.

both loaded version 0
Calling update using query: { "_id" : { "$oid" : "6aace449f1341b7637fcb0d7"}, "version" : 0} and update: { "sku" : "MN-U2723QE", …, "price" : { "$numberDecimal" : "549.00"}, …, "version" : 1, … } in collection: products
alice saved, version now 1
Calling update using query: { "_id" : { "$oid" : "6aace449f1341b7637fcb0d7"}, "version" : 0} and update: { "sku" : "MN-U2723QE", …, "price" : { "$numberDecimal" : "579.00"}, "qty" : 17, …, "version" : 1, … } in collection: products
OptimisticLockingFailureException: Cannot save entity 6aace449f1341b7637fcb0d7 with version 1 to collection products; Has it been modified meanwhile

load-modify-save   round 1: 50 calls, reviews stored=1, reviewCount=1, errors={OptimisticLockingFailureException=49}
load-modify-save   round 2: 50 calls, reviews stored=5, reviewCount=5, errors={OptimisticLockingFailureException=45}
load-modify-save   round 3: 50 calls, reviews stored=5, reviewCount=5, errors={OptimisticLockingFailureException=45}
atomic $push/$inc  round 1: 50 calls, reviews stored=50, reviewCount=50, errors={}
atomic $push/$inc  round 2: 50 calls, reviews stored=50, reviewCount=50, errors={}
atomic $push/$inc  round 3: 50 calls, reviews stored=50, reviewCount=50, errors={}

[ { v: 2, key: { _id: 1 }, name: '_id_' } ]

[
  { v: 2, key: { _id: 1 }, name: '_id_' },
  { v: 2, key: { category: 1, price: 1 }, name: 'category_price' },
  { v: 2, key: { sku: 1 }, name: 'sku', unique: true }
]

Caused by: org.springframework.dao.DuplicateKeyException: Write failed with error code 11000 and error message 'Index build failed: fd68fcdd-dcc0-496f-b9ee-1c09dd96876d: Collection catalog.products ( 376762f5-674e-44c9-8243-c915b2577c77 ) :: caused by :: E11000 duplicate key error collection: catalog.products index: sku dup key: { sku: "KB-K8-RED" }'

function stages(p) { const out = []; while (p) { out.push(p.stage + (p.indexName ? "(" + p.indexName + ")" : "")); p = p.inputStage; } return out.join(" <- "); }
function run(label, cursorFn) {
  let best = null, ex;
  for (let i = 0; i < 6; i++) {
    ex = cursorFn().explain("executionStats");
    const t = ex.executionStats.executionTimeMillis;
    if (i > 0 && (best === null || t < best)) best = t;   // first run is warm-up
  }
  const s = ex.executionStats;
  print(label + ": plan " + stages(ex.queryPlanner.winningPlan.queryPlan || ex.queryPlanner.winningPlan) +
        " | nReturned " + s.nReturned + " | totalKeysExamined " + s.totalKeysExamined +
        " | totalDocsExamined " + s.totalDocsExamined + " | executionTimeMillis best of 5: " + best);
}
run("sku", () => db.products.find({ sku: "GEN-123456" }));
run("category+price", () => db.products.find({ category: "headphones", price: { $lt: NumberDecimal("20") } }).sort({ price: 1 }));

docker cp explain.js sba-a11-mongo:/tmp/explain.js

docker exec sba-a11-mongo mongosh catalog --quiet /tmp/explain.js

sku: plan COLLSCAN | nReturned 1 | totalKeysExamined 0 | totalDocsExamined 300008 | executionTimeMillis best of 5: 58
category+price: plan SORT <- COLLSCAN | nReturned 466 | totalKeysExamined 0 | totalDocsExamined 300008 | executionTimeMillis best of 5: 63

sku: plan EXPRESS_IXSCAN(sku) | nReturned 1 | totalKeysExamined 1 | totalDocsExamined 1 | executionTimeMillis best of 5: 0
category+price: plan FETCH <- IXSCAN(category_price) | nReturned 466 | totalKeysExamined 466 | totalDocsExamined 466 | executionTimeMillis best of 5: 0

public List<CategoryRating> ratingsByCategory() {
    Aggregation pipeline = Aggregation.newAggregation(
            Aggregation.match(Criteria.where("stock").gt(0)),
            Aggregation.unwind("reviews"),
            Aggregation.group("category")
                    .avg("reviews.rating").as("averageRating")
                    .count().as("reviews"),
            Aggregation.sort(Sort.by(Sort.Order.desc("averageRating"), Sort.Order.asc("_id"))),
            Aggregation.project("averageRating", "reviews").and("category").previousOperation());
    return mongo.aggregate(pipeline, Product.class, CategoryRating.class).getMappedResults();
}

package com.example.demo.product;
 
public record CategoryRating(String category, double averageRating, int reviews) {
}

[
  { "$match": { "qty": { "$gt": 0 } } },
  { "$unwind": "$reviews" },
  { "$group": { "_id": "$category", "averageRating": { "$avg": "$reviews.rating" }, "reviews": { "$sum": 1 } } },
  { "$sort": { "averageRating": -1, "_id": 1 } },
  { "$project": { "averageRating": 1, "reviews": 1, "_id": 0, "category": "$_id" } }
]

CategoryRating[category=monitor, averageRating=4.666666666666667, reviews=3]
CategoryRating[category=headphones, averageRating=4.333333333333333, reviews=6]
CategoryRating[category=keyboard, averageRating=4.333333333333333, reviews=6]

package com.example.demo.order;
 
import java.time.Instant;
 
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import com.example.demo.product.Product;
import com.mongodb.client.result.UpdateResult;
 
@Service
public class OrderService {
 
    private final OrderRepository orders;
    private final MongoTemplate mongo;
 
    public OrderService(OrderRepository orders, MongoTemplate mongo) {
        this.orders = orders;
        this.mongo = mongo;
    }
 
    @Transactional
    public Order place(String sku, int quantity) {
        Order order = orders.insert(new Order(null, sku, quantity, Instant.now()));
        UpdateResult stock = mongo.updateFirst(
                Query.query(Criteria.where("sku").is(sku).and("stock").gte(quantity)),
                new Update().inc("stock", -quantity),
                Product.class);
        if (stock.getModifiedCount() == 0) {
            throw new InsufficientStockException(sku, quantity);
        }
        return order;
    }
}

transaction managers: []
OrderService is a proxy: false
stock of MN-27GP850 before: 0
Inserting Document containing fields: [sku, quantity, placedAt, _class] in collection: orders
Calling update using query: { "sku" : "MN-27GP850", "qty" : { "$gte" : 1}} and update: { "$inc" : { "qty" : -1, "version" : 1}} in collection: products
com.example.demo.order.InsufficientStockException: Not enough stock of MN-27GP850 for 1
orders after the failed call: 1

package com.example.demo.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDatabaseFactory;
import org.springframework.data.mongodb.MongoTransactionManager;
 
@Configuration(proxyBeanMethods = false)
public class MongoConfig {
 
    @Bean
    MongoTransactionManager transactionManager(MongoDatabaseFactory databaseFactory) { 
        return new MongoTransactionManager(databaseFactory); 
    } 
}

transaction managers: [transactionManager]
OrderService is a proxy: true
Creating new transaction with name [com.example.demo.order.OrderService.place]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
{"insert": "orders", "ordered": true, "$db": "catalog", "txnNumber": 1, "startTransaction": true, "autocommit": false, "documents": [{"_id": {"$oid": "6aace62721a2347324ca600d"}, "sku": "MN-27GP850", "quantity": 1, "placedAt": {"$date": "2026-09-18T07:20:07.48Z"}, "_class": "com.example.demo.order.Order"}]}
{"update": "products", "ordered": true, "$db": "catalog", "txnNumber": 1, "autocommit": false, "updates": [{"q": {"sku": "MN-27GP850", "qty": {"$gte": 1}}, "u": {"$inc": {"qty": -1, "version": 1}}}]}
Initiating transaction rollback
{"abortTransaction": 1, "$db": "admin", "txnNumber": 1, "autocommit": false}
com.example.demo.order.InsufficientStockException: Not enough stock of MN-27GP850 for 1
orders after the failed call: 0

org.springframework.data.mongodb.UncategorizedMongoDbException: This MongoDB deployment does not support retryable writes. Please add retryWrites=false to your connection string.
  caused by com.mongodb.MongoClientException: This MongoDB deployment does not support retryable writes. Please add retryWrites=false to your connection string.

com.mongodb.MongoCommandException: Command execution failed on MongoDB server with error 20 (IllegalOperation): 'Transaction numbers are only allowed on a replica set member or mongos' on server localhost:27112.

{"sku": "MS-MX3S", "name": "Logitech MX Master 3S", "desc": "Ergonomic wireless mouse with quiet clicks", "category": "mouse", ...}
{"sku": "SP-FLIP6", "name": "JBL Flip 6", "desc": "Portable wireless speaker, IP67", "category": "speaker", ...}

--- findByDescriptionContaining("wireless")
find using query: { "description" : { "$regularExpression" : { "pattern" : ".*wireless.*", "options" : ""}}} fields: Document{{}} sort: null for class: class com.example.demo.product.Product in collection: products
KB-K2-BRN
--- load a legacy product
SP-FLIP6 description=null

{"_id": {"$oid": "6aace69a0cef47a41e37c8a2"}, "sku": "SP-FLIP6", "name": "JBL Flip 6", "category": "speaker", "price": {"$numberDecimal": "119.00"}, "qty": 10, "attributes": {}, "reviews": [], "reviewCount": 0, "version": 1, "_class": "com.example.demo.product.Product"}

@Component
@Order(0)
public class RenameDescToDescription implements ApplicationRunner {
 
    private static final Logger log = LoggerFactory.getLogger(RenameDescToDescription.class);
 
    private final MongoTemplate mongo;
 
    public RenameDescToDescription(MongoTemplate mongo) {
        this.mongo = mongo;
    }
 
    @Override
    public void run(ApplicationArguments args) {
        UpdateResult result = mongo.updateMulti(
                Query.query(Criteria.where("desc").exists(true)),
                new Update().rename("desc", "description"),
                Product.class);
        log.info("Renamed desc to description in {} product(s)", result.getModifiedCount());
    }
}

Calling update using query: { "desc" : { "$exists" : true}} and update: { "$rename" : { "desc" : "description"}, "$inc" : { "version" : 1}} in collection: products
Renamed desc to description in 1 product(s)
KB-K2-BRN
MS-MX3S

redisTemplate value serializer: JdkSerializationRedisSerializer, key serializer: JdkSerializationRedisSerializer, default: JdkSerializationRedisSerializer
stringRedisTemplate value serializer: StringRedisSerializer

package com.example.demo.product;
 
import java.io.Serializable;
import java.math.BigDecimal;
 
public record ProductSummary(String sku, String name, BigDecimal price) implements Serializable {
}

redisTemplate.opsForValue().set("product:summary:" + summary.sku(), summary);
System.out.println("read back: " + redisTemplate.opsForValue().get("product:summary:" + summary.sku()));
stringRedisTemplate.opsForValue().set("greeting", "hello");
System.out.println("StringRedisTemplate reads it as: " + stringRedisTemplate.opsForValue().get("product:summary:" + summary.sku()));

read back: ProductSummary[sku=KB-K2-BRN, name=Keychron K2 Wireless, price=89.00]
StringRedisTemplate reads it as: null

docker exec sba-a11-redis redis-cli --no-raw KEYS '*'

1) "product:summary:KB-K2-BRN"
2) "greeting"
3) "\xac\xed\x00\x05t\x00\x19product:summary:KB-K2-BRN"

"\xac\xed\x00\x05sr\x00'com.example.demo.product.ProductSummary\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x03L\x00\x04namet\x00\x12Ljava/lang/String;L\x00\x05pricet\x00\x16Ljava/math/BigDecimal;…"

package com.example.demo.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JacksonJsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
 
import com.example.demo.product.ProductSummary;
 
@Configuration(proxyBeanMethods = false)
public class RedisConfig {
 
    @Bean
    RedisTemplate<String, ProductSummary> productSummaryTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, ProductSummary> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        template.setKeySerializer(RedisSerializer.string());
        template.setValueSerializer(new JacksonJsonRedisSerializer<>(ProductSummary.class));
        return template;
    }
}

@Component
public class ProductSummaryStore {
 
    private final RedisTemplate<Object, Object> redis; 
    private final RedisTemplate<String, ProductSummary> redis; 
 
    public ProductSummaryStore(RedisTemplate<Object, Object> redis) { 
    public ProductSummaryStore(RedisTemplate<String, ProductSummary> redis) { 
        this.redis = redis;
    }
 
    public void put(ProductSummary summary) {
        redis.opsForValue().set("product:summary:" + summary.sku(), summary);
    }
 
    public ProductSummary get(String sku) {
        return redis.opsForValue().get("product:summary:" + sku);
    }
}

"product:summary:KB-K2-BRN"
"{\"sku\":\"KB-K2-BRN\",\"name\":\"Keychron K2 Wireless\",\"price\":89.00}"

@Component
public class ViewCounter {
 
    private final StringRedisTemplate redis;
 
    public ViewCounter(StringRedisTemplate redis) {
        this.redis = redis;
    }
 
    public long increment(String sku) {
        return redis.opsForValue().increment(key(sku));
    }
 
    public long count(String sku) {
        String value = redis.opsForValue().get(key(sku));
        return value == null ? 0 : Long.parseLong(value);
    }
 
    private static String key(String sku) {
        return "views:product:" + sku;
    }
}

"INCR" "views:product:KB-K2-BRN"
"INCR" "views:product:KB-K2-BRN"

GET + SET round 1: 10000 increments, counter = 907, 517 ms
GET + SET round 2: 10000 increments, counter = 908, 427 ms
GET + SET round 3: 10000 increments, counter = 897, 271 ms
INCR      round 1: 10000 increments, counter = 10000, 138 ms
INCR      round 2: 10000 increments, counter = 10000, 127 ms
INCR      round 3: 10000 increments, counter = 10000, 114 ms

@Component
public class BestsellerBoard {
 
    private static final String KEY = "bestsellers";
 
    private final StringRedisTemplate redis;
 
    public BestsellerBoard(StringRedisTemplate redis) {
        this.redis = redis;
    }
 
    public void recordSale(String sku, int quantity) {
        redis.opsForZSet().incrementScore(KEY, sku, quantity);
    }
 
    public List<Bestseller> top(int n) {
        return redis.opsForZSet().reverseRangeWithScores(KEY, 0, n - 1).stream()
                .map(t -> new Bestseller(t.getValue(), t.getScore().longValue()))
                .toList();
    }
}

"ZINCRBY" "bestsellers" "2.0" "KB-K2-BRN"
"ZINCRBY" "bestsellers" "1.0" "HP-WH1000XM5"
"ZINCRBY" "bestsellers" "1.0" "MN-U2723QE"
"ZINCRBY" "bestsellers" "3.0" "HP-WH1000XM5"
"ZINCRBY" "bestsellers" "1.0" "KB-K8-RED"
"ZREVRANGE" "bestsellers" "0" "2" "WITHSCORES"

[Bestseller[sku=HP-WH1000XM5, sold=4], Bestseller[sku=KB-K2-BRN, sold=2], Bestseller[sku=MN-U2723QE, sold=1]]

@Component
public class CartStore {
 
    private static final Duration IDLE_LIFETIME = Duration.ofDays(7);
 
    private final StringRedisTemplate redis;
    private final HashOperations<String, String, String> hashes;
 
    public CartStore(StringRedisTemplate redis) {
        this.redis = redis;
        this.hashes = redis.opsForHash();
    }
 
    public void add(String customerId, String sku, int quantity) {
        String key = key(customerId);
        hashes.increment(key, sku, quantity);
        redis.expire(key, IDLE_LIFETIME);
    }
 
    public void remove(String customerId, String sku) {
        hashes.delete(key(customerId), sku);
    }
 
    public Map<String, Integer> items(String customerId) {
        Map<String, Integer> items = new TreeMap<>();
        hashes.entries(key(customerId)).forEach((sku, qty) -> items.put(sku, Integer.parseInt(qty)));
        return items;
    }
 
    private static String key(String customerId) {
        return "cart:" + customerId;
    }
}

"HINCRBY" "cart:c-1001" "KB-K2-BRN" "1"
"PEXPIRE" "cart:c-1001" "604800000"
"HINCRBY" "cart:c-1001" "HP-WH1000XM5" "1"
"PEXPIRE" "cart:c-1001" "604800000"
"HINCRBY" "cart:c-1001" "KB-K2-BRN" "2"
"PEXPIRE" "cart:c-1001" "604800000"
"HDEL" "cart:c-1001" "HP-WH1000XM5"
"HGETALL" "cart:c-1001"

{KB-K2-BRN=3}

@Component
public class OneTimeCodes {
 
    private static final Duration LIFETIME = Duration.ofMinutes(5);
 
    private final StringRedisTemplate redis;
    private final SecureRandom random = new SecureRandom();
 
    public OneTimeCodes(StringRedisTemplate redis) {
        this.redis = redis;
    }
 
    public String issue(String email) {
        String code = "%06d".formatted(random.nextInt(1_000_000));
        redis.opsForValue().set(key(email), code, LIFETIME);
        return code;
    }
 
    public long secondsLeft(String email) {
        return redis.getExpire(key(email));
    }
 
    public boolean verify(String email, String code) {
        String stored = redis.opsForValue().getAndDelete(key(email));
        return code.equals(stored);
    }
 
    private static String key(String email) {
        return "otp:" + email;
    }
}

"SET" "otp:an@example.com" "641297" "EX" "300"
"TTL" "otp:an@example.com"
"GETDEL" "otp:an@example.com"
"GETDEL" "otp:an@example.com"

issued 641297, seconds left 300
first verify: true
second verify: false

@GetMapping("/{sku}")
public ProductResponse get(@PathVariable String sku) {
    Product product = products.get(sku);
    return ProductResponse.from(product, views.increment(sku));
}
 
@PostMapping("/{sku}/reviews")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void addReview(@PathVariable String sku, @Valid @RequestBody ReviewRequest request) {
    products.addReview(sku, new Review(request.author(), request.rating(), request.comment(), Instant.now()));
}

@PostMapping
public ResponseEntity<Order> place(@Valid @RequestBody OrderRequest request) {
    Order order = orders.place(request.sku(), request.quantity());
    bestsellers.recordSale(order.sku(), order.quantity());
    return ResponseEntity.created(URI.create("/api/orders/" + order.id())).body(order);
}

@ExceptionHandler(ProductNotFoundException.class)
ProblemDetail productNotFound(ProductNotFoundException ex) {
    return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
}
 
@ExceptionHandler(InsufficientStockException.class)
ProblemDetail insufficientStock(InsufficientStockException ex) {
    return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT, ex.getMessage());
}

curl -s http://localhost:8211/api/products/KB-K8-RED

{"sku":"KB-K8-RED","name":"Keychron K8 Pro","category":"keyboard","price":109.00,"stock":12,"brand":"Keychron","attributes":{"layout":"TKL","switchType":"red","wireless":true},"reviews":[{"author":"hoa","rating":4,"comment":"Quiet and smooth","createdAt":"2026-09-18T07:00:00Z"},{"author":"nam","rating":3,"comment":"Keycaps feel cheap","createdAt":"2026-09-18T07:00:00Z"}],"views":1}

HTTP/1.1 404
Content-Type: application/problem+json
 
{"detail":"No product with SKU NOPE","instance":"/api/products/NOPE","status":404,"title":"Not Found"}
 
HTTP/1.1 422
Content-Type: application/problem+json
 
{"detail":"Request has 2 invalid value(s).","instance":"/api/products/KB-K8-RED/reviews","status":422,"title":"Unprocessable Content","errors":[{"field":"author","message":"must not be blank"},{"field":"rating","message":"must be less than or equal to 5"}]}

curl -s -i -H "Content-Type: application/json" -d '{"sku":"HP-QC-ULTRA","quantity":2}' http://localhost:8211/api/orders

HTTP/1.1 201
Location: /api/orders/6aace8b1953cefdd3aaa828b
Content-Type: application/json
 
{"id":"6aace8b1953cefdd3aaa828b","sku":"HP-QC-ULTRA","quantity":2,"placedAt":"2026-09-18T07:30:57.759287Z"}
 
HTTP/1.1 409
Content-Type: application/problem+json
 
{"detail":"Not enough stock of HP-QC-ULTRA for 2","instance":"/api/orders","status":409,"title":"Conflict"}

package com.example.demo.reservation;
 
import org.springframework.data.annotation.Id;
import org.springframework.data.redis.core.RedisHash;
import org.springframework.data.redis.core.TimeToLive;
import org.springframework.data.redis.core.index.Indexed;
 
@RedisHash("reservations")
public record Reservation(@Id String id, @Indexed String sku, @Indexed String customerId, int quantity,
        @TimeToLive long ttlSeconds) {
}

package com.example.demo.reservation;
 
import java.util.List;
 
import org.springframework.data.repository.CrudRepository;
 
public interface ReservationRepository extends CrudRepository<Reservation, String> {
 
    List<Reservation> findBySku(String sku);
 
    List<Reservation> findByCustomerId(String customerId);
}

"DEL" "reservations:1a2b3c4d-5e6f-4000-8000-000000000001"
"HMSET" "reservations:1a2b3c4d-5e6f-4000-8000-000000000001" "_class" "com.example.demo.reservation.Reservation" "customerId" "c-1001" "id" "1a2b3c4d-5e6f-4000-8000-000000000001" "quantity" "1" "sku" "KB-K2-BRN" "ttlSeconds" "15"
"SADD" "reservations" "1a2b3c4d-5e6f-4000-8000-000000000001"
"EXPIRE" "reservations:1a2b3c4d-5e6f-4000-8000-000000000001" "15"
"SADD" "reservations:sku:KB-K2-BRN" "1a2b3c4d-5e6f-4000-8000-000000000001"
"SADD" "reservations:1a2b3c4d-5e6f-4000-8000-000000000001:idx" "reservations:sku:KB-K2-BRN"
"SADD" "reservations:customerId:c-1001" "1a2b3c4d-5e6f-4000-8000-000000000001"
"SADD" "reservations:1a2b3c4d-5e6f-4000-8000-000000000001:idx" "reservations:customerId:c-1001"

docker exec sba-a11-redis redis-cli --no-raw SCAN 0 MATCH 'reservations*' COUNT 100

1) "0"
2)  1) "reservations:sku:HP-WH1000XM5"
    2) "reservations:1a2b3c4d-5e6f-4000-8000-000000000001:idx"
    3) "reservations:1a2b3c4d-5e6f-4000-8000-000000000002"
    4) "reservations:1a2b3c4d-5e6f-4000-8000-000000000003"
    5) "reservations:1a2b3c4d-5e6f-4000-8000-000000000002:idx"
    6) "reservations:sku:KB-K2-BRN"
    7) "reservations"
    8) "reservations:1a2b3c4d-5e6f-4000-8000-000000000003:idx"
    9) "reservations:customerId:c-1002"
   10) "reservations:1a2b3c4d-5e6f-4000-8000-000000000001"
   11) "reservations:customerId:c-1001"

count(): 3
findBySku(KB-K2-BRN): []
findAll(): [null, null, Reservation[id=1a2b3c4d-5e6f-4000-8000-000000000003, sku=HP-WH1000XM5, customerId=c-1001, quantity=1, ttlSeconds=3564]]

package com.example.demo.config;
 
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisKeyValueAdapter.EnableKeyspaceEvents;
import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;
 
@Configuration(proxyBeanMethods = false)
@EnableRedisRepositories(basePackages = "com.example.demo.reservation", enableKeyspaceEvents = EnableKeyspaceEvents.ON_STARTUP)
public class RedisRepositoryConfig {
}

"DEL" "reservations:1a2b3c4d-5e6f-4000-8000-000000000001:phantom"
"HMSET" "reservations:1a2b3c4d-5e6f-4000-8000-000000000001:phantom" "_class" "com.example.demo.reservation.Reservation" "customerId" "c-1001" "id" "1a2b3c4d-5e6f-4000-8000-000000000001" "quantity" "1" "sku" "KB-K2-BRN" "ttlSeconds" "15"
"EXPIRE" "reservations:1a2b3c4d-5e6f-4000-8000-000000000001:phantom" "315"

"HGETALL" "reservations:1a2b3c4d-5e6f-4000-8000-000000000001:phantom"
"DEL" "reservations:1a2b3c4d-5e6f-4000-8000-000000000001:phantom"
"SREM" "reservations" "1a2b3c4d-5e6f-4000-8000-000000000001"
"SREM" "reservations:sku:KB-K2-BRN" "1a2b3c4d-5e6f-4000-8000-000000000001"
"SREM" "reservations:customerId:c-1001" "1a2b3c4d-5e6f-4000-8000-000000000001"
"DEL" "reservations:1a2b3c4d-5e6f-4000-8000-000000000001:idx"

void oneByOne() {
    for (int i = 0; i < N; i++) {
        redis.opsForValue().set("stock:SKU-" + i, Integer.toString(i));
    }
}
 
void pipelined() {
    List<Object> replies = redis.executePipelined((RedisCallback<Object>) connection -> {
        for (int i = 0; i < N; i++) {
            connection.stringCommands().set(("stock:SKU-" + i).getBytes(UTF_8), Integer.toString(i).getBytes(UTF_8));
        }
        return null;
    });
    if (replies.size() != N) {
        throw new IllegalStateException("expected " + N + " replies, got " + replies.size());
    }
}

round 1: 10000 SETs one by one 1209 ms, pipelined 55 ms
round 2: 10000 SETs one by one 1104 ms, pipelined 47 ms
round 3: 10000 SETs one by one 1153 ms, pipelined 46 ms
round 4: 10000 SETs one by one 1130 ms, pipelined 44 ms
round 5: 10000 SETs one by one 1118 ms, pipelined 38 ms

RedisConnectionFactory: org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
RedisTemplate bean productSummaryTemplate: RedisTemplate
RedisTemplate bean redisTemplate: RedisTemplate
RedisTemplate bean stringRedisTemplate: StringRedisTemplate

"HELLO" "3"
"CLIENT" "SETINFO" "lib-name" "Lettuce(spring-data-redis_v4.1.1)"
"CLIENT" "SETINFO" "lib-ver" "7.5.2.RELEASE/5728917"

id=75 addr=192.168.65.1:40321 … cmd=exists user=default redir=-1 resp=3 lib-name=Lettuce(spring-data-redis_v4.1.1) lib-ver=7.5.2.RELEASE/5728917 …

create table products (
    id         bigint generated always as identity primary key,
    sku        varchar(40) not null unique,
    name       varchar(120) not null,
    category   varchar(40) not null,
    price      numeric(10, 2) not null,
    attributes jsonb not null default '{}'
);
 
insert into products (sku, name, category, price, attributes) values
  ('KB-K2-BRN',    'Keychron K2 Wireless',    'keyboard',   89.00, '{"layout": "75%", "switchType": "brown", "wireless": true}'),
  ('KB-K8-RED',    'Keychron K8 Pro',         'keyboard',  109.00, '{"layout": "TKL", "switchType": "red", "wireless": true}'),
  ('KB-G915-TKL',  'Logitech G915 TKL',       'keyboard',  199.99, '{"layout": "TKL", "switchType": "brown", "wireless": true, "lowProfile": true}'),
  ('MN-U2723QE',   'Dell UltraSharp U2723QE', 'monitor',   579.00, '{"sizeInches": 27, "resolution": "3840x2160", "panel": "IPS Black", "usbC": true}'),
  ('HP-WH1000XM5', 'Sony WH-1000XM5',         'headphones', 329.00, '{"type": "over-ear", "anc": true, "batteryHours": 30}');
 
insert into products (sku, name, category, price, attributes)
select 'GEN-' || lpad(i::text, 6, '0'), 'Generated ' || i, 'keyboard', 50 + (i % 100),
       jsonb_build_object('layout', 'TKL', 'switchType', (array['red', 'blue', 'black', 'silver'])[1 + i % 4], 'wireless', i % 2 = 0)
from generate_series(1, 300000) as i;
 
create index products_attributes_gin on products using gin (attributes jsonb_path_ops);
analyze products;
 
select sku, name, attributes ->> 'layout' as layout
from products
where attributes @> '{"switchType": "brown"}';
 
explain (analyze, costs off, timing off, summary off)
select sku from products where attributes @> '{"switchType": "brown"}';
 
select sku, (attributes ->> 'sizeInches')::int as size
from products
where category = 'monitor' and (attributes ->> 'sizeInches')::int >= 27;

docker run -d --name sba-a11-pg --memory 256m -e POSTGRES_USER=demo -e POSTGRES_PASSWORD=demo -e POSTGRES_DB=catalog postgres:18

docker cp jsonb.sql sba-a11-pg:/tmp/jsonb.sql

docker exec sba-a11-pg psql -U demo -d catalog -f /tmp/jsonb.sql

     sku     |         name         | layout 
-------------+----------------------+--------
 KB-K2-BRN   | Keychron K2 Wireless | 75%
 KB-G915-TKL | Logitech G915 TKL    | TKL
(2 rows)
 
                                  QUERY PLAN                                   
-------------------------------------------------------------------------------
 Bitmap Heap Scan on products (actual rows=2.00 loops=1)
   Recheck Cond: (attributes @> '{"switchType": "brown"}'::jsonb)
   Heap Blocks: exact=1
   Buffers: shared hit=3
   ->  Bitmap Index Scan on products_attributes_gin (actual rows=2.00 loops=1)
         Index Cond: (attributes @> '{"switchType": "brown"}'::jsonb)
         Index Searches: 1
         Buffers: shared hit=2
 Planning:
   Buffers: shared hit=1
(10 rows)
 
    sku     | size 
------------+------
 MN-U2723QE |   27
(1 row)