This comprehensive guide covers MongoDB integration with Spring Data, including repositories, queries, aggregation, transactions, and best practices.

1. Basic Setup and Configuration

Dependencies (pom.xml)

<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-validation</artifactId> </dependency> <dependency> <groupId>de.flapdoodle.embed</groupId> <artifactId>de.flapdoodle.embed.mongo</artifactId> <scope>test</scope> </dependency> </dependencies>

Application Configuration (application.yml)

spring: data: mongodb: uri: mongodb://localhost:27017/ecommerce auto-index-creation: true application: name: mongo-service logging: level: org.springframework.data.mongodb.core: DEBUG com.example.mongodemo: DEBUG server: port: 8080

MongoDB Configuration Class

@Configuration @EnableMongoAuditing public class MongoConfig { @Bean public MongoTemplate mongoTemplate(MongoDatabaseFactory mongoDatabaseFactory, MongoMappingContext mongoMappingContext) { MappingMongoConverter converter = new MappingMongoConverter( new DefaultDbRefResolver(mongoDatabaseFactory), mongoMappingContext); converter.setTypeMapper(new DefaultMongoTypeMapper(null)); return new MongoTemplate(mongoDatabaseFactory, converter); } @Bean public MongoTransactionManager transactionManager(MongoDatabaseFactory dbFactory) { return new MongoTransactionManager(dbFactory); } }

2. Document Models and Entities

Basic Document Entity

@Document(collection = "users") public class User { @Id private String id; @Indexed(unique = true) @Field("username") @NotBlank private String username; @NotBlank @Email private String email; @Field("full_name") @NotBlank private String fullName; private Integer age; @DBRef private List<Address> addresses = new ArrayList<>(); private UserStatus status; @CreatedDate private LocalDateTime createdAt; @LastModifiedDate private LocalDateTime updatedAt; @Version private Long version; // Constructors public User() {} public User(String username, String email, String fullName, Integer age) { this.username = username; this.email = email; this.fullName = fullName; this.age = age; this.status = UserStatus.ACTIVE; } // Business methods public void addAddress(Address address) { this.addresses.add(address); } public void deactivate() { this.status = UserStatus.INACTIVE; } public void activate() { this.status = UserStatus.ACTIVE; } // Getters and setters public String getId() { return id; } public void setId(String id) { this.id = id; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public String getFullName() { return fullName; } public void setFullName(String fullName) { this.fullName = fullName; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public List<Address> getAddresses() { return addresses; } public void setAddresses(List<Address> addresses) { this.addresses = addresses; } public UserStatus getStatus() { return status; } public void setStatus(UserStatus status) { this.status = status; } public LocalDateTime getCreatedAt() { return createdAt; } public LocalDateTime getUpdatedAt() { return updatedAt; } public Long getVersion() { return version; } } enum UserStatus { ACTIVE, INACTIVE, SUSPENDED }

Embedded Document

@Document(collection = "addresses") public class Address { @Id private String id; private String street; private String city; private String state; private String zipCode; private String country; @Field("address_type") private AddressType addressType; private Boolean isPrimary = false; // Constructors, getters, and setters public Address() {} public Address(String street, String city, String state, String zipCode, String country, AddressType addressType) { this.street = street; this.city = city; this.state = state; this.zipCode = zipCode; this.country = country; this.addressType = addressType; } // Getters and setters... } enum AddressType { HOME, WORK, BILLING, SHIPPING }

Complex Document with Embedded Objects

@Document(collection = "products") public class Product { @Id private String id; @Indexed(unique = true) private String sku; private String name; private String description; @TextIndexed private String category; private Money price; private Inventory inventory; private List<ProductAttribute> attributes = new ArrayList<>(); private Map<String, Object> metadata = new HashMap<>(); private List<Review> reviews = new ArrayList<>(); @CreatedDate private LocalDateTime createdAt; @LastModifiedDate private LocalDateTime updatedAt; // Constructors public Product() {} public Product(String sku, String name, String description, String category, Money price) { this.sku = sku; this.name = name; this.description = description; this.category = category; this.price = price; this.inventory = new Inventory(0, 0); } // Business methods public void addAttribute(String name, String value) { this.attributes.add(new ProductAttribute(name, value)); } public void addReview(Review review) { this.reviews.add(review); } public void updateInventory(int quantity, int reserved) { this.inventory = new Inventory(quantity, reserved); } public boolean isInStock() { return this.inventory.getAvailableQuantity() > 0; } public int getAvailableQuantity() { return this.inventory.getAvailableQuantity(); } // Getters and setters... } // Embedded objects class Money { private BigDecimal amount; private String currency; public Money() {} public Money(BigDecimal amount, String currency) { this.amount = amount; this.currency = currency; } // Getters and setters... } class Inventory { private Integer quantity; private Integer reserved; public Inventory() {} public Inventory(Integer quantity, Integer reserved) { this.quantity = quantity; this.reserved = reserved; } public Integer getAvailableQuantity() { return quantity - reserved; } // Getters and setters... } class ProductAttribute { private String name; private String value; public ProductAttribute() {} public ProductAttribute(String name, String value) { this.name = name; this.value = value; } // Getters and setters... } class Review { private String userId; private String username; private Integer rating; private String comment; private LocalDateTime reviewDate; public Review() {} public Review(String userId, String username, Integer rating, String comment) { this.userId = userId; this.username = username; this.rating = rating; this.comment = comment; this.reviewDate = LocalDateTime.now(); } // Getters and setters... }

3. Repository Layer

Basic Repository Interface

@Repository public interface UserRepository extends MongoRepository<User, String> { // Query methods Optional<User> findByUsername(String username); Optional<User> findByEmail(String email); List<User> findByStatus(UserStatus status); List<User> findByAgeBetween(Integer minAge, Integer maxAge); List<User> findByFullNameContainingIgnoreCase(String name); List<User> findByAddressesCity(String city); // Exists methods boolean existsByUsername(String username); boolean existsByEmail(String email); // Count methods long countByStatus(UserStatus status); long countByAgeGreaterThan(Integer age); // Delete methods void deleteByStatus(UserStatus status); // Pageable queries Page<User> findByStatus(UserStatus status, Pageable pageable); // Custom sort List<User> findByStatusOrderByCreatedAtDesc(UserStatus status); } @Repository public interface ProductRepository extends MongoRepository<Product, String> { // Basic queries Optional<Product> findBySku(String sku); List<Product> findByCategory(String category); List<Product> findByPriceAmountBetween(BigDecimal minPrice, BigDecimal maxPrice); List<Product> findByInventoryQuantityGreaterThan(Integer quantity); // Text search List<Product> findByCategoryContainingIgnoreCase(String category); // Embedded object queries List<Product> findByAttributesNameAndAttributesValue(String name, String value); List<Product> findByReviewsRatingGreaterThanEqual(Integer minRating); // Complex queries @Query("{ 'price.amount': { $gte: ?0, $lte: ?1 } }") List<Product> findProductsInPriceRange(BigDecimal minPrice, BigDecimal maxPrice); @Query("{ 'reviews': { $elemMatch: { 'rating': { $gte: ?0 }, 'userId': ?1 } } }") List<Product> findProductsWithUserRatingAbove(Integer minRating, String userId); @Query(value = "{ 'category': ?0 }", fields = "{ 'name': 1, 'price': 1, 'sku': 1 }") List<Product> findProductProjectionsByCategory(String category); // Aggregation queries @Aggregation(pipeline = { "{ '$match': { 'category': ?0 } }", "{ '$group': { '_id': '$category', 'averagePrice': { '$avg': '$price.amount' }, 'count': { '$sum': 1 } } }" }) CategoryStats getCategoryStats(String category); }

Custom Repository Implementation

// Custom repository interface public interface CustomUserRepository { List<User> findActiveUsersWithAddressInCity(String city); void updateUserStatus(String userId, UserStatus status); List<User> findUsersByComplexCriteria(UserSearchCriteria criteria); UserStats getUserStats(); } // Implementation public class CustomUserRepositoryImpl implements CustomUserRepository { private final MongoTemplate mongoTemplate; public CustomUserRepositoryImpl(MongoTemplate mongoTemplate) { this.mongoTemplate = mongoTemplate; } @Override public List<User> findActiveUsersWithAddressInCity(String city) { Query query = new Query(); query.addCriteria(Criteria.where("status").is(UserStatus.ACTIVE) .and("addresses.city").is(city)); return mongoTemplate.find(query, User.class); } @Override public void updateUserStatus(String userId, UserStatus status) { Query query = new Query(Criteria.where("id").is(userId)); Update update = new Update().set("status", status).set("updatedAt", LocalDateTime.now()); mongoTemplate.updateFirst(query, update, User.class); } @Override public List<User> findUsersByComplexCriteria(UserSearchCriteria criteria) { Criteria criteriaBuilder = new Criteria(); if (criteria.getMinAge() != null && criteria.getMaxAge() != null) { criteriaBuilder.and("age").gte(criteria.getMinAge()).lte(criteria.getMaxAge()); } if (criteria.getStatus() != null) { criteriaBuilder.and("status").is(criteria.getStatus()); } if (StringUtils.hasText(criteria.getCity())) { criteriaBuilder.and("addresses.city").is(criteria.getCity()); } if (StringUtils.hasText(criteria.getSearchTerm())) { criteriaBuilder.orOperator( Criteria.where("fullName").regex(criteria.getSearchTerm(), "i"), Criteria.where("email").regex(criteria.getSearchTerm(), "i") ); } Query query = new Query(criteriaBuilder); if (criteria.getPageable() != null) { query.with(criteria.getPageable()); } return mongoTemplate.find(query, User.class); } @Override public UserStats getUserStats() { Aggregation aggregation = Aggregation.newAggregation( Aggregation.group() .count().as("totalUsers") .sum(ConditionalOperators.when(Criteria.where("status").is(UserStatus.ACTIVE)).then(1).otherwise(0)).as("activeUsers") .avg("age").as("averageAge") .max("age").as("maxAge") .min("age").as("minAge") ); AggregationResults<UserStats> results = mongoTemplate.aggregate(aggregation, "users", UserStats.class); return results.getUniqueMappedResult(); } } // Extended repository interface public interface UserRepository extends MongoRepository<User, String>, CustomUserRepository { // Inherits all methods from both interfaces } // Supporting classes public class UserSearchCriteria { private Integer minAge; private Integer maxAge; private UserStatus status; private String city; private String searchTerm; private Pageable pageable; // Constructors, getters, and setters... } public class UserStats { private Long totalUsers; private Long activeUsers; private Double averageAge; private Integer maxAge; private Integer minAge; // Constructors, getters, and setters... } public class CategoryStats { private String category; private Double averagePrice; private Long count; // Constructors, getters, and setters... }

4. Service Layer

User Service Implementation

@Service @Transactional public class UserService { private final UserRepository userRepository; private final MongoTemplate mongoTemplate; public UserService(UserRepository userRepository, MongoTemplate mongoTemplate) { this.userRepository = userRepository; this.mongoTemplate = mongoTemplate; } public User createUser(CreateUserRequest request) { // Check if username or email already exists if (userRepository.existsByUsername(request.getUsername())) { throw new UserAlreadyExistsException("Username already exists: " + request.getUsername()); } if (userRepository.existsByEmail(request.getEmail())) { throw new UserAlreadyExistsException("Email already exists: " + request.getEmail()); } User user = new User( request.getUsername(), request.getEmail(), request.getFullName(), request.getAge() ); // Add addresses if provided if (request.getAddresses() != null) { request.getAddresses().forEach(user::addAddress); } return userRepository.save(user); } public User getUserById(String id) { return userRepository.findById(id) .orElseThrow(() -> new UserNotFoundException("User not found with id: " + id)); } public User getUserByUsername(String username) { return userRepository.findByUsername(username) .orElseThrow(() -> new UserNotFoundException("User not found with username: " + username)); } public List<User> getUsersByStatus(UserStatus status) { return userRepository.findByStatus(status); } public List<User> searchUsers(UserSearchCriteria criteria) { return userRepository.findUsersByComplexCriteria(criteria); } public User updateUser(String userId, UpdateUserRequest request) { User user = getUserById(userId); if (StringUtils.hasText(request.getFullName())) { user.setFullName(request.getFullName()); } if (request.getAge() != null) { user.setAge(request.getAge()); } return userRepository.save(user); } public void deactivateUser(String userId) { userRepository.updateUserStatus(userId, UserStatus.INACTIVE); } public void activateUser(String userId) { userRepository.updateUserStatus(userId, UserStatus.ACTIVE); } public void deleteUser(String userId) { if (!userRepository.existsById(userId)) { throw new UserNotFoundException("User not found with id: " + userId); } userRepository.deleteById(userId); } public User addAddressToUser(String userId, Address address) { User user = getUserById(userId); user.addAddress(address); return userRepository.save(user); } public UserStats getUserStatistics() { return userRepository.getUserStats(); } // Bulk operations @Transactional public void bulkUpdateUserStatus(List<String> userIds, UserStatus status) { Query query = new Query(Criteria.where("id").in(userIds)); Update update = new Update().set("status", status).set("updatedAt", LocalDateTime.now()); mongoTemplate.updateMulti(query, update, User.class); } } // Custom exceptions class UserNotFoundException extends RuntimeException { public UserNotFoundException(String message) { super(message); } } class UserAlreadyExistsException extends RuntimeException { public UserAlreadyExistsException(String message) { super(message); } }

Product Service with Advanced Features

@Service @Transactional public class ProductService { private final ProductRepository productRepository; private final MongoTemplate mongoTemplate; public ProductService(ProductRepository productRepository, MongoTemplate mongoTemplate) { this.productRepository = productRepository; this.mongoTemplate = mongoTemplate; } public Product createProduct(CreateProductRequest request) { if (productRepository.findBySku(request.getSku()).isPresent()) { throw new ProductAlreadyExistsException("Product with SKU already exists: " + request.getSku()); } Product product = new Product( request.getSku(), request.getName(), request.getDescription(), request.getCategory(), new Money(request.getPrice(), "USD") ); // Set initial inventory product.updateInventory(request.getInitialQuantity(), 0); // Add attributes if (request.getAttributes() != null) { request.getAttributes().forEach(product::addAttribute); } return productRepository.save(product); } public Product getProductById(String id) { return productRepository.findById(id) .orElseThrow(() -> new ProductNotFoundException("Product not found with id: " + id)); } public Product getProductBySku(String sku) { return productRepository.findBySku(sku) .orElseThrow(() -> new ProductNotFoundException("Product not found with SKU: " + sku)); } public List<Product> getProductsByCategory(String category) { return productRepository.findByCategory(category); } public List<Product> searchProducts(String searchTerm) { TextCriteria criteria = TextCriteria.forDefaultLanguage().matching(searchTerm); Query query = TextQuery.queryText(criteria).sortByScore(); return mongoTemplate.find(query, Product.class); } public List<Product> getProductsInPriceRange(BigDecimal minPrice, BigDecimal maxPrice) { return productRepository.findProductsInPriceRange(minPrice, maxPrice); } public Product updateProductInventory(String productId, int quantity, int reserved) { Product product = getProductById(productId); product.updateInventory(quantity, reserved); return productRepository.save(product); } public Product addProductReview(String productId, AddReviewRequest request) { Product product = getProductById(productId); Review review = new Review( request.getUserId(), request.getUsername(), request.getRating(), request.getComment() ); product.addReview(review); return productRepository.save(product); } public List<Product> getTopRatedProducts(int limit) { Aggregation aggregation = Aggregation.newAggregation( Aggregation.unwind("reviews"), Aggregation.group("id") .first("name").as("name") .first("sku").as("sku") .first("category").as("category") .first("price").as("price") .avg("reviews.rating").as("averageRating") .count().as("reviewCount"), Aggregation.match(Criteria.where("reviewCount").gte(5)), Aggregation.sort(Sort.Direction.DESC, "averageRating"), Aggregation.limit(limit) ); return mongoTemplate.aggregate(aggregation, "products", Product.class) .getMappedResults(); } public Map<String, CategoryStats> getCategoryStatistics() { Aggregation aggregation = Aggregation.newAggregation( Aggregation.group("category") .avg("price.amount").as("averagePrice") .count().as("productCount") .sum("inventory.quantity").as("totalStock") .sum("inventory.reserved").as("totalReserved"), Aggregation.project() .and("_id").as("category") .and("averagePrice").as("averagePrice") .and("productCount").as("count") .andExpression("totalStock - totalReserved").as("availableStock") ); List<CategoryStats> results = mongoTemplate.aggregate(aggregation, "products", CategoryStats.class) .getMappedResults(); return results.stream() .collect(Collectors.toMap(CategoryStats::getCategory, Function.identity())); } // Transactional operation @Transactional public void processOrder(OrderRequest order) { for (OrderItem item : order.getItems()) { Product product = getProductBySku(item.getSku()); if (product.getAvailableQuantity() < item.getQuantity()) { throw new InsufficientStockException( "Insufficient stock for product: " + product.getName() + ". Available: " + product.getAvailableQuantity() + ", Requested: " + item.getQuantity() ); } // Reserve the items product.updateInventory( product.getInventory().getQuantity(), product.getInventory().getReserved() + item.getQuantity() ); productRepository.save(product); } } }

5. REST Controllers

User Controller

@RestController @RequestMapping("/api/users") @Validated public class UserController { private final UserService userService; public UserController(UserService userService) { this.userService = userService; } @PostMapping public ResponseEntity<User> createUser(@Valid @RequestBody CreateUserRequest request) { User user = userService.createUser(request); return ResponseEntity.status(HttpStatus.CREATED).body(user); } @GetMapping("/{id}") public ResponseEntity<User> getUser(@PathVariable String id) { User user = userService.getUserById(id); return ResponseEntity.ok(user); } @GetMapping("/username/{username}") public ResponseEntity<User> getUserByUsername(@PathVariable String username) { User user = userService.getUserByUsername(username); return ResponseEntity.ok(user); } @GetMapping public ResponseEntity<List<User>> getUsers( @RequestParam(required = false) UserStatus status, @RequestParam(required = false) String city, @RequestParam(required = false) Integer minAge, @RequestParam(required = false) Integer maxAge, @RequestParam(required = false) String search, @RequestParam(defaultValue = "0") int page, @RequestParam(defaultValue = "20") int size) { UserSearchCriteria criteria = new UserSearchCriteria(); criteria.setStatus(status); criteria.setCity(city); criteria.setMinAge(minAge); criteria.setMaxAge(maxAge); criteria.setSearchTerm(search); criteria.setPageable(PageRequest.of(page, size, Sort.by("createdAt").descending())); List<User> users = userService.searchUsers(criteria); return ResponseEntity.ok(users); } @PutMapping("/{id}") public ResponseEntity<User> updateUser(@PathVariable String id, @Valid @RequestBody UpdateUserRequest request) { User user = userService.updateUser(id, request); return ResponseEntity.ok(user); } @PatchMapping("/{id}/deactivate") public ResponseEntity<Void> deactivateUser(@PathVariable String id) { userService.deactivateUser(id); return ResponseEntity.ok().build(); } @PatchMapping("/{id}/activate") public ResponseEntity<Void> activateUser(@PathVariable String id) { userService.activateUser(id); return ResponseEntity.ok().build(); } @PostMapping("/{id}/addresses") public ResponseEntity<User> addAddress(@PathVariable String id, @Valid @RequestBody Address address) { User user = userService.addAddressToUser(id, address); return ResponseEntity.ok(user); } @GetMapping("/stats") public ResponseEntity<UserStats> getUserStats() { UserStats stats = userService.getUserStatistics(); return ResponseEntity.ok(stats); } @DeleteMapping("/{id}") public ResponseEntity<Void> deleteUser(@PathVariable String id) { userService.deleteUser(id); return ResponseEntity.noContent().build(); } }

Product Controller

@RestController @RequestMapping("/api/products") @Validated public class ProductController { private final ProductService productService; public ProductController(ProductService productService) { this.productService = productService; } @PostMapping public ResponseEntity<Product> createProduct(@Valid @RequestBody CreateProductRequest request) { Product product = productService.createProduct(request); return ResponseEntity.status(HttpStatus.CREATED).body(product); } @GetMapping("/{id}") public ResponseEntity<Product> getProduct(@PathVariable String id) { Product product = productService.getProductById(id); return ResponseEntity.ok(product); } @GetMapping("/sku/{sku}") public ResponseEntity<Product> getProductBySku(@PathVariable String sku) { Product product = productService.getProductBySku(sku); return ResponseEntity.ok(product); } @GetMapping public ResponseEntity<List<Product>> getProducts( @RequestParam(required = false) String category, @RequestParam(required = false) BigDecimal minPrice, @RequestParam(required = false) BigDecimal maxPrice, @RequestParam(required = false) String search) { List<Product> products; if (search != null) { products = productService.searchProducts(search); } else if (minPrice != null && maxPrice != null) { products = productService.getProductsInPriceRange(minPrice, maxPrice); } else if (category != null) { products = productService.getProductsByCategory(category); } else { products = productService.getProductsByCategory("electronics"); // Default } return ResponseEntity.ok(products); } @GetMapping("/top-rated") public ResponseEntity<List<Product>> getTopRatedProducts( @RequestParam(defaultValue = "10") int limit) { List<Product> products = productService.getTopRatedProducts(limit); return ResponseEntity.ok(products); } @PostMapping("/{id}/reviews") public ResponseEntity<Product> addReview(@PathVariable String id, @Valid @RequestBody AddReviewRequest request) { Product product = productService.addProductReview(id, request); return ResponseEntity.ok(product); } @GetMapping("/stats/categories") public ResponseEntity<Map<String, CategoryStats>> getCategoryStats() { Map<String, CategoryStats> stats = productService.getCategoryStatistics(); return ResponseEntity.ok(stats); } @PatchMapping("/{id}/inventory") public ResponseEntity<Product> updateInventory(@PathVariable String id, @RequestBody UpdateInventoryRequest request) { Product product = productService.updateProductInventory( id, request.getQuantity(), request.getReserved()); return ResponseEntity.ok(product); } }

6. Advanced MongoDB Features

Aggregation Framework Examples

@Component public class ProductAnalyticsService { private final MongoTemplate mongoTemplate; public ProductAnalyticsService(MongoTemplate mongoTemplate) { this.mongoTemplate = mongoTemplate; } public List<ProductSales> getProductSalesStatistics(LocalDateTime startDate, LocalDateTime endDate) { Aggregation aggregation = Aggregation.newAggregation( Aggregation.match(Criteria.where("orderDate").gte(startDate).lte(endDate)), Aggregation.unwind("items"), Aggregation.group("items.productId") .first("items.productName").as("productName") .sum("items.quantity").as("totalSold") .sum("items.totalPrice").as("totalRevenue") .avg("items.unitPrice").as("averagePrice"), Aggregation.sort(Sort.Direction.DESC, "totalRevenue"), Aggregation.limit(50) ); return mongoTemplate.aggregate(aggregation, "orders", ProductSales.class) .getMappedResults(); } public List<CategoryPerformance> getCategoryPerformance() { Aggregation aggregation = Aggregation.newAggregation( Aggregation.group("category") .count().as("productCount") .avg("price.amount").as("avgPrice") .sum("inventory.quantity").as("totalStock") .avg("reviews.rating").as("avgRating"), Aggregation.project() .and("_id").as("category") .and("productCount").as("productCount") .and("avgPrice").as("averagePrice") .and("totalStock").as("totalStock") .and("avgRating").as("averageRating") .andExpression("totalStock * avgPrice").as("totalValue"), Aggregation.sort(Sort.Direction.DESC, "totalValue") ); return mongoTemplate.aggregate(aggregation, "products", CategoryPerformance.class) .getMappedResults(); } public List<UserPurchaseHistory> getUserPurchaseHistory(String userId) { Aggregation aggregation = Aggregation.newAggregation( Aggregation.match(Criteria.where("userId").is(userId)), Aggregation.unwind("items"), Aggregation.group("items.productId") .first("items.productName").as("productName") .sum("items.quantity").as("totalPurchased") .sum("items.totalPrice").as("totalSpent") .count().as("purchaseCount"), Aggregation.sort(Sort.Direction.DESC, "totalSpent") ); return mongoTemplate.aggregate(aggregation, "orders", UserPurchaseHistory.class) .getMappedResults(); } } // Aggregation result classes class ProductSales { private String productId; private String productName; private Integer totalSold; private BigDecimal totalRevenue; private BigDecimal averagePrice; // Constructors, getters, and setters... } class CategoryPerformance { private String category; private Long productCount; private Double averagePrice; private Integer totalStock; private Double averageRating; private Double totalValue; // Constructors, getters, and setters... } class UserPurchaseHistory { private String productId; private String productName; private Integer totalPurchased; private BigDecimal totalSpent; private Long purchaseCount; // Constructors, getters, and setters... }

Text Search and Index Management

@Component public class SearchService { private final MongoTemplate mongoTemplate; public SearchService(MongoTemplate mongoTemplate) { this.mongoTemplate = mongoTemplate; } public List<Product> fullTextSearch(String searchTerm) { TextCriteria criteria = TextCriteria.forDefaultLanguage() .matchingAny(searchTerm.split(" ")) .caseSensitive(false) .diacriticSensitive(false); Query query = TextQuery.queryText(criteria) .sortByScore() .with(Sort.by("price.amount").ascending()); return mongoTemplate.find(query, Product.class); } public List<Product> advancedSearch(ProductSearchCriteria criteria) { Criteria queryCriteria = new Criteria(); List<Criteria> andCriteria = new ArrayList<>(); List<Criteria> orCriteria = new ArrayList<>(); // Text search if (StringUtils.hasText(criteria.getSearchTerm())) { orCriteria.add(Criteria.where("name").regex(criteria.getSearchTerm(), "i")); orCriteria.add(Criteria.where("description").regex(criteria.getSearchTerm(), "i")); orCriteria.add(Criteria.where("category").regex(criteria.getSearchTerm(), "i")); } // Price range if (criteria.getMinPrice() != null && criteria.getMaxPrice() != null) { andCriteria.add(Criteria.where("price.amount") .gte(criteria.getMinPrice()).lte(criteria.getMaxPrice())); } // Category filter if (StringUtils.hasText(criteria.getCategory())) { andCriteria.add(Criteria.where("category").is(criteria.getCategory())); } // In stock filter if (criteria.getInStockOnly() != null && criteria.getInStockOnly()) { andCriteria.add(Criteria.where("inventory.quantity").gt(0)); } // Minimum rating if (criteria.getMinRating() != null) { andCriteria.add(Criteria.where("reviews.rating").gte(criteria.getMinRating())); } // Build final query if (!orCriteria.isEmpty()) { Criteria textSearchCriteria = new Criteria().orOperator(orCriteria.toArray(new Criteria[0])); andCriteria.add(textSearchCriteria); } if (!andCriteria.isEmpty()) { queryCriteria.andOperator(andCriteria.toArray(new Criteria[0])); } Query query = new Query(queryCriteria); // Sorting if (StringUtils.hasText(criteria.getSortBy())) { Sort.Direction direction = criteria.isSortDesc() ? Sort.Direction.DESC : Sort.Direction.ASC; query.with(Sort.by(direction, criteria.getSortBy())); } // Pagination if (criteria.getPage() != null && criteria.getSize() != null) { query.with(PageRequest.of(criteria.getPage(), criteria.getSize())); } return mongoTemplate.find(query, Product.class); } public void createTextIndex() { mongoTemplate.indexOps(Product.class).ensureIndex( new TextIndexDefinitionBuilder() .onField("name", 2.0f) .onField("description", 1.0f) .onField("category", 1.5f) .build() ); } public void createCompoundIndex() { mongoTemplate.indexOps(Product.class).ensureIndex( new Index().on("category", Sort.Direction.ASC) .on("price.amount", Sort.Direction.ASC) .on("inventory.quantity", Sort.Direction.DESC) .named("category_price_stock_idx") ); } }

7. Testing

Integration Tests

@DataMongoTest @ExtendWith(SpringExtension.class) @TestPropertySource(properties = "spring.mongodb.embedded.version=4.4.5") class UserRepositoryIntegrationTest { @Autowired private UserRepository userRepository; @Autowired private MongoTemplate mongoTemplate; @BeforeEach void setUp() { userRepository.deleteAll(); } @Test void shouldSaveAndFindUser() { // Given User user = new User("john_doe", "[email protected]", "John Doe", 30); user.addAddress(new Address("123 Main St", "New York", "NY", "10001", "USA", AddressType.HOME)); // When User savedUser = userRepository.save(user); // Then assertThat(savedUser.getId()).isNotNull(); assertThat(savedUser.getUsername()).isEqualTo("john_doe"); Optional<User> foundUser = userRepository.findByUsername("john_doe"); assertThat(foundUser).isPresent(); assertThat(foundUser.get().getEmail()).isEqualTo("[email protected]"); } @Test void shouldFindUsersByCity() { // Given User user1 = new User("user1", "[email protected]", "User One", 25); user1.addAddress(new Address("123 Main St", "New York", "NY", "10001", "USA", AddressType.HOME)); User user2 = new User("user2", "[email protected]", "User Two", 35); user2.addAddress(new Address("456 Oak St", "Los Angeles", "CA", "90001", "USA", AddressType.HOME)); userRepository.saveAll(List.of(user1, user2)); // When List<User> nyUsers = userRepository.findByAddressesCity("New York"); // Then assertThat(nyUsers).hasSize(1); assertThat(nyUsers.get(0).getUsername()).isEqualTo("user1"); } } @SpringBootTest @Testcontainers class ProductServiceIntegrationTest { @Container static MongoDBContainer mongoDBContainer = new MongoDBContainer("mongo:5.0"); @DynamicPropertySource static void setProperties(DynamicPropertyRegistry registry) { registry.add("spring.data.mongodb.uri", mongoDBContainer::getReplicaSetUrl); } @Autowired private ProductService productService; @Autowired private ProductRepository productRepository; @BeforeEach void setUp() { productRepository.deleteAll(); } @Test void shouldCreateAndRetrieveProduct() { // Given CreateProductRequest request = new CreateProductRequest( "SKU-001", "Laptop", "High-performance laptop", "electronics", new BigDecimal("999.99"), 10, new HashMap<>() ); // When Product product = productService.createProduct(request); // Then assertThat(product.getId()).isNotNull(); assertThat(product.getSku()).isEqualTo("SKU-001"); assertThat(product.isInStock()).isTrue(); Product foundProduct = productService.getProductBySku("SKU-001"); assertThat(foundProduct.getName()).isEqualTo("Laptop"); } @Test void shouldGetTopRatedProducts() { // Given Product product1 = new Product("SKU-001", "Product 1", "Description 1", "category1", new Money(new BigDecimal("100"), "USD")); product1.addReview(new Review("user1", "User One", 5, "Excellent!")); product1.addReview(new Review("user2", "User Two", 4, "Very good")); Product product2 = new Product("SKU-002", "Product 2", "Description 2", "category1", new Money(new BigDecimal("200"), "USD")); product2.addReview(new Review("user3", "User Three", 3, "Average")); productRepository.saveAll(List.of(product1, product2)); // When List<Product> topRated = productService.getTopRatedProducts(10); // Then assertThat(topRated).hasSize(1); assertThat(topRated.get(0).getSku()).isEqualTo("SKU-001"); } }

This comprehensive guide covers MongoDB integration with Spring Data, including advanced features like aggregation framework, text search, transactions, and testing strategies. The implementation follows best practices for building robust, scalable applications with MongoDB.