MongoDB không phải Postgres bỏ schema. Nếu bạn mang mô hình chuẩn hóa sang MongoDB rồi bù lại bằng transaction và $lookup, bạn chỉ có một bản sao chậm hơn của cơ sở dữ liệu quan hệ. Ngược lại, một aggregate đúng nghĩa chỉ tốn một lần đọc và một index.
Mục lục
Cập nhật 2026
- Spring Boot 4.1.2 trên Spring Framework 7.0.10; Spring Data MongoDB đi theo train 2026.0.2. Bài không pin version riêng của module vì nó không có dòng phát hành độc lập.
- Boot 4 đổi prefix cấu hình kết nối:
spring.mongodb.uri,spring.mongodb.host,spring.mongodb.databasethay chospring.data.mongodb.*. Copyspring.data.mongodb.uritừ blog cũ sẽ không bind được nữa. Riêngspring.data.mongodb.auto-index-creationvẫn giữ nguyên. IndexOperations.ensureIndexđã bị deprecated (for removal) — dùngcreateIndex.@Indexed(expireAfterSeconds = ...)cũng vậy; TTL viết bằngexpireAfter = "30d".- Toàn bộ là
jakarta.*;javax.validationkhông còn được Framework 7 hỗ trợ.
Spring Data MongoDB: chọn đúng chỗ trước khi viết code
Câu hỏi không phải “NoSQL có nhanh hơn không”, mà là “dữ liệu có phải một document không”. MongoDB đọc ghi một document như một đơn vị; nếu nghiệp vụ cần nhiều bảng cùng commit, bạn cần RDBMS.
| Tiêu chí | MongoDB là lựa chọn đúng | Dùng RDBMS thay thế |
|---|---|---|
| Mô hình | Aggregate lồng nhau, đọc ghi như một khối (order + lines, hồ sơ + cấu hình) | Nhiều bảng chuẩn hóa, dữ liệu tái sử dụng ở nhiều nơi |
| Schema | Field thay đổi theo loại bản ghi, nhiều field optional | Cố định, nhiều ràng buộc, khóa ngoại chặt |
| Transaction | Một document đủ atomic; đa document là ngoại lệ | Nhiều bảng phải commit hoặc rollback cùng nhau |
| Truy vấn | Đọc theo khóa, lọc vài field, tổng hợp trong aggregation pipeline | Join nhiều bảng, báo cáo ad-hoc, window function |
| Scale | Đọc nhiều, ghi phân tán, shard theo tenant hoặc vùng | Vertical scale và read replica đủ cho vài chục triệu bản ghi |
| Ràng buộc | Chấp nhận validate ở app hoặc bằng $jsonSchema |
Unique, FK, CHECK do database bảo đảm |
Nếu bạn tick cột giữa ở bốn dòng trở lên, MongoDB hợp lý. Nếu cột phải thắng ở transaction và join, đừng ép — đó là lúc Spring Data JPA hợp hơn.
Ánh xạ document: @Document, @Id và những gì thực sự cần
MongoDB lưu BSON, Java của bạn là POJO; Spring Data MongoDB dịch qua lại bằng mapping metadata và không sinh schema. Tên field mặc định đúng tên property Java, nên @Field chỉ cần khi document đã có tên khác.
| Annotation | Package | Việc nó làm |
|---|---|---|
@Document |
org.springframework.data.mongodb.core.mapping |
Đặt tên collection; không đặt thì lấy tên class. |
@Id |
org.springframework.data.annotation |
Ánh xạ field sang _id; null nghĩa là document mới và driver sinh ObjectId. |
@Field |
org.springframework.data.mongodb.core.mapping |
Đổi tên field trong BSON khi schema đã có sẵn. |
@Indexed |
org.springframework.data.mongodb.core.index |
Index một field; có unique, name, và expireAfter = "30d" cho TTL. |
@CompoundIndex |
org.springframework.data.mongodb.core.index |
Index nhiều field; def là JSON theo tên field trong document, không theo tên property. |
Chọn kiểu id trước khi viết class. Mặc định _id là ObjectId, Spring chuyển qua lại với String hex 12 byte. Nếu muốn UUID, khai báo String và tự sinh UUID.randomUUID().toString() — Spring không sinh hộ. Đừng trộn hai kiểu trong cùng collection: query sai kiểu trả về rỗng.
// File: src/main/java/vn/evotek/shop/order/Order.java
package vn.evotek.shop.order;
import java.math.BigDecimal;
import java.time.Instant;
import java.util.List;
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.Field;
@Document(collection = "orders")
@CompoundIndex(name = "customer_created_idx", def = "{'customerId': 1, 'createdAt': -1}")
public class Order {
@Id
private String id;
@Indexed(unique = true)
private String code;
private String customerId;
private Status status;
private List<OrderLine> lines;
private Instant createdAt;
private BigDecimal total;
public enum Status { NEW, PAID, SHIPPED, CANCELLED }
public static class OrderLine {
private String sku;
private int quantity;
@Field("unit_price")
private BigDecimal unitPrice;
}
// getters và setters
}
Một chi tiết dễ sai: def của @CompoundIndex gửi nguyên văn xuống server, nên nếu customerId được map sang customer_id bằng @Field thì def phải viết customer_id. Index trên field không tồn tại vẫn tạo được, chỉ không bao giờ được dùng.
Nhúng hay tham chiếu: biên của mảng là biên thiết kế
Document tối đa 16 MB. Một mảng events thêm một phần tử mỗi request sẽ chạm trần, và mỗi lần update MongoDB ghi lại cả document. Mảng có biên thì nhúng; mảng tăng vô hạn thì tham chiếu.
| Quan hệ | Nhúng khi | Tham chiếu khi |
|---|---|---|
| 1-1 | Luôn đọc cùng nhau, ít cập nhật riêng | Hai phía có vòng đời khác nhau |
| 1-nhiều có biên | Order + lines, bài viết + 5 ảnh | Con số có thể tăng không kiểm soát |
| 1-nhiều vô hạn | Không nên | Comment, event, log: collection riêng, bucket theo ngày nếu cần |
| Nhiều-nhiều | Chỉ khi hai phía nhỏ và luôn đọc cùng | Id hai chiều, $lookup khi thật cần |
Nhúng không miễn phí: index trên mảng là multikey, mỗi phần tử sinh một entry, nên mảng 1.000 chuỗi làm index phình tuyến tính; $lookup trên collection lớn cũng tốn bộ nhớ. Chọn theo truy vấn thật, không theo ERD đẹp.
Repository, derived query và phân trang
MongoRepository<Order, String> cho bạn CRUD, sắp xếp và phân trang; findAll() trả List vì nó mở rộng ListCrudRepository. Derived query đọc tên method: findByStatus, findByCustomerIdAndCreatedAtAfter. Quá ba điều kiện thì tên method thành câu văn, lúc đó dùng @Query.
// File: src/main/java/vn/evotek/shop/order/OrderRepository.java
package vn.evotek.shop.order;
import java.math.BigDecimal;
import java.time.Instant;
import java.util.List;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;
public interface OrderRepository extends MongoRepository<Order, String> {
Page<Order> findByStatus(Order.Status status, Pageable pageable);
List<Order> findByCustomerIdAndCreatedAtAfter(String customerId, Instant from);
// fields là projection: bỏ lines để response nhẹ hơn
@Query(value = "{ 'total': { $gte: ?0 } }", fields = "{ 'lines': 0 }")
List<Order> findLargeOrders(BigDecimal minTotal);
}
Page trả kèm tổng số phần tử, nghĩa là Mongo chạy thêm một count cùng điều kiện; với collection lớn, Slice hoặc chỉ limit rẻ hơn nhiều. Boot tự cấu hình resolver cho Pageable, nên ?page=0&size=20&sort=createdAt,desc chạy ngay.
CRUD chạy được: service và controller
Hai starter là đủ: spring-boot-starter-webmvc (thay spring-boot-starter-web đang deprecated trong Boot 4.1) và spring-boot-starter-data-mongodb. Kết nối đặt ở spring.mongodb.uri; bật auto-index-creation chỉ ở dev.
Service giữ logic, controller chỉ ánh xạ HTTP. Ví dụ nhận thẳng Order; production nên dùng DTO để client không ghi được _id.
// File: src/main/java/vn/evotek/shop/order/OrderService.java
package vn.evotek.shop.order;
import java.time.Instant;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.web.server.ResponseStatusException;
@Service
public class OrderService {
private final OrderRepository orders;
public OrderService(OrderRepository orders) { this.orders = orders; }
public Order create(Order order) {
order.setId(null); // không cho client tự đặt _id
order.setCreatedAt(Instant.now());
order.setStatus(Order.Status.NEW);
return orders.save(order);
}
public Order get(String id) {
return orders.findById(id).orElseThrow(
() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "order " + id));
}
public Page<Order> page(Order.Status status, Pageable pageable) {
return status == null ? orders.findAll(pageable) : orders.findByStatus(status, pageable);
}
public Order replace(String id, Order patch) {
Order existing = get(id);
patch.setId(existing.getId());
patch.setCreatedAt(existing.getCreatedAt());
return orders.save(patch); // thay thế toàn bộ document
}
public void delete(String id) {
if (!orders.existsById(id)) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "order " + id);
}
orders.deleteById(id);
}
}
// File: src/main/java/vn/evotek/shop/order/OrderController.java
package vn.evotek.shop.order;
import java.net.URI;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/orders")
public class OrderController {
private final OrderService service;
public OrderController(OrderService service) { this.service = service; }
@PostMapping
public ResponseEntity<Order> create(@RequestBody Order order) {
Order saved = service.create(order);
return ResponseEntity.created(URI.create("/api/orders/" + saved.getId())).body(saved);
}
@GetMapping("/{id}")
public Order get(@PathVariable String id) { return service.get(id); }
@GetMapping
public Page<Order> list(@RequestParam(required = false) Order.Status status,
Pageable pageable) {
return service.page(status, pageable);
}
@PutMapping("/{id}")
public Order replace(@PathVariable String id, @RequestBody Order order) {
return service.replace(id, order);
}
@DeleteMapping("/{id}")
public ResponseEntity<Void> delete(@PathVariable String id) {
service.delete(id);
return ResponseEntity.noContent().build();
}
}
Aggregation bằng MongoTemplate
MongoTemplate là lối thoát khi derived query không diễn đạt được phép tính: group, sum, project, $lookup, hoặc update từng phần bằng Update().set(...). Nó cũng tạo index và chạy bulk operation.
// File: src/main/java/vn/evotek/shop/report/RevenueReportService.java
package vn.evotek.shop.report;
import java.math.BigDecimal;
import java.time.Instant;
import java.util.List;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.stereotype.Service;
@Service
public class RevenueReportService {
private final MongoTemplate mongo;
public RevenueReportService(MongoTemplate mongo) { this.mongo = mongo; }
public List<RevenueByCustomer> topCustomers(Instant from) {
Aggregation pipeline = Aggregation.newAggregation(
Aggregation.match(Criteria.where("status").in("PAID", "SHIPPED")
.and("createdAt").gte(from)),
Aggregation.group("customerId")
.sum("total").as("revenue")
.count().as("orders"),
Aggregation.sort(Sort.Direction.DESC, "revenue"),
Aggregation.limit(50),
Aggregation.project("revenue", "orders").and("_id").as("customerId"));
return mongo.aggregate(pipeline, "orders", RevenueByCustomer.class).getMappedResults();
}
public record RevenueByCustomer(String customerId, BigDecimal revenue, long orders) {}
}
Pipeline chạy trên server và chỉ trả 50 document cuối. Đừng thay bằng findAll() rồi groupingBy: bạn kéo cả collection qua mạng và mất index.
Index: khai báo bằng annotation, tạo bằng createIndex
@Indexed và @CompoundIndex chỉ là khai báo; index chỉ được tạo khi auto-index-creation=true hoặc khi gọi createIndex. Ở production, tắt auto-index và tạo tường minh để kiểm soát tên và thời điểm build.
// File: src/main/java/vn/evotek/shop/config/MongoIndexConfig.java
package vn.evotek.shop.config;
import java.time.Duration;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.index.Index;
import vn.evotek.shop.cart.Cart;
import vn.evotek.shop.order.Order;
@Configuration
class MongoIndexConfig {
@Bean
CommandLineRunner createIndexes(MongoTemplate mongo) {
return args -> {
mongo.indexOps(Order.class).createIndex(new Index()
.on("customerId", Sort.Direction.ASC)
.on("createdAt", Sort.Direction.DESC)
.named("customer_created_idx"));
mongo.indexOps(Cart.class).createIndex(new Index()
.on("updatedAt", Sort.Direction.ASC)
.expire(Duration.ofDays(30))
.named("cart_ttl_idx"));
};
}
}
TTL monitor chạy nền theo chu kỳ khoảng 60 giây, nên document có thể sống lâu hơn hạn; đừng dùng TTL cho nghiệp vụ cần xóa chính xác. TTL cũng chỉ xóa khi field là kiểu date — lưu chuỗi ISO thì index không làm gì.
// File: src/main/java/vn/evotek/shop/cart/Cart.java
package vn.evotek.shop.cart;
import java.time.Instant;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
@Document(collection = "carts")
public class Cart {
@Id
private String id;
private String customerId;
private Instant updatedAt; // TTL index trỏ vào field này
}
Khi bật auto-index-creation, index từ annotation được tạo với tên do driver sinh; đừng khai báo thêm cùng field bằng createIndex, vì MongoDB từ chối hai index cùng key pattern khác tên. Chọn một đường: annotation cho dev, createIndex cho production.
Transaction: chỉ khi thật cần, và chỉ trên replica set
Transaction đa document chỉ chạy trên replica set hoặc sharded cluster; standalone mongod — kể cả bản mới nhất — trả lỗi Transaction numbers are only allowed on a replica set member or mongos. Dev cũng phải là replica set một node.
Spring không tự cấu hình transaction manager cho Mongo; bạn phải khai báo bean:
// File: src/main/java/vn/evotek/shop/config/MongoTransactionConfig.java
package vn.evotek.shop.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
class MongoTransactionConfig {
@Bean
MongoTransactionManager transactionManager(MongoDatabaseFactory factory) {
return new MongoTransactionManager(factory);
}
}
Sau đó @Transactional chạy như với JPA: commit khi trả về bình thường, rollback khi ném runtime exception. Cái giá: mỗi operation thêm round trip, giữ snapshot, giới hạn 60 giây; xung đột ghi trả TransientTransactionError và bạn phải retry cả transaction. Đừng bọc endpoint read-heavy trong transaction chỉ vì “cho an toàn” — bạn mua chậm hơn, không mua đúng hơn.
Sáu lỗi làm API Mongo chậm hoặc sai
1. Mảng không có biên
Thêm comment, event hay log vào document cha là cách nhanh nhất để chạm trần 16 MB và làm mỗi lần update nặng dần. Sửa: tách collection con hoặc bucket theo ngày.
2. Dùng Mongo như database quan hệ
Chuẩn hóa thành năm collection rồi nối bằng $lookup và bọc mọi thứ trong transaction là dấu hiệu chọn sai công cụ. Sửa: nhúng phần luôn đọc cùng nhau, chấp nhận trùng lặp có kiểm soát; không nhúng được thì xem lại cột phải của bảng trên.
3. Thiếu index hoặc index sai thứ tự
Query findByCustomerIdAndCreatedAtAfter không có compound index sẽ quét cả collection. Thứ tự field theo quy tắc ESR: Equality trước, Sort sau, Range cuối. Kiểm tra bằng explain("executionStats"): totalDocsExamined xấp xỉ nReturned là index đang làm việc; chênh hàng nghìn lần thì index sai.
4. Nghĩ rằng save là patch
save là insert khi _id mới và replace toàn bộ document khi _id đã tồn tại. Một object lấy từ projection hoặc DTO thiếu field sẽ xóa các field đó khỏi database. Sửa: update từng phần bằng mongo.updateFirst(Query.query(Criteria.where("_id").is(id)), new Update().set("status", Order.Status.SHIPPED), Order.class).
5. Lẫn lộn ObjectId và String
_id lưu ObjectId nhưng code khai báo String là bình thường, Spring convert hộ. Vấn đề ở biên API: id không phải 24 ký tự hex sẽ không khớp document nào, và converter có thể ném lỗi thành 500. Hãy validate định dạng id ở controller để trả 400.
6. Không có schema validation
@Document chỉ là metadata mapping, không ràng buộc gì. Field thiếu thành null, sai kiểu vẫn ghi được. Sửa ở hai lớp: Bean Validation trên DTO (cần spring-boot-starter-validation và @Valid), và validator $jsonSchema ở collection để mọi client, kể cả script, đều bị chặn.
Nhìn về 2027
Không có thay đổi API CRUD nào đang báo trước; train Spring Data vẫn là đơn vị phát hành. Đáng theo dõi là virtual threads: bật spring.threads.virtual.enabled=true để lệnh gọi driver đồng bộ không giữ platform thread, nhờ đó chịu tải cao rẻ hơn nhiều. Atlas Search vẫn là dịch vụ của Atlas, không có trong Community server.
Checklist
- Vẽ aggregate trước: thứ gì luôn đọc ghi cùng nhau thì nằm cùng document.
- Đặt biên cho mọi mảng; không đặt được biên thì tách collection.
- Compound index theo ESR, kiểm tra lại bằng
explaintrên dữ liệu thật. savecho create và replace; update từng field bằngUpdate().set.- Chỉ bật transaction khi một nghiệp vụ chạm từ hai collection; dev chạy replica set.
- Validate hai lớp: DTO với
@Validvà$jsonSchemaở collection.
Đọc tiếp Spring Data JPA cho người mới bắt đầu để so sánh repository proxy và dirty checking, Hibernate Basics khi bạn cần mapping quan hệ thật, và Spring Data JDBC cho aggregate không cần document. Thứ tự toàn bộ bài nằm ở lộ trình Spring Boot 2026.



