Spring Data MongoDB

spring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/orders_db

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

@Document(collection = "orders")
public class Order {

    @Id
    private String id;                       // maps to _id; String, ObjectId, or a custom type

    @Field("customer_id")
    private String customerId;                // stored as "customer_id" in the document

    private String status;
    private BigDecimal totalAmount;
    private Instant placedAt;

    private List<LineItem> items;             // embedded sub-documents, mapped by convention

    // getters and setters omitted
}

public class LineItem {
    private String sku;
    private int quantity;
    private BigDecimal unitPrice;
}

public abstract class Payment {

    @Id
    private String id;

    private BigDecimal amount;
}

@TypeAlias("card")               // shortens the stored discriminator from the full class name to "card"
public class CardPayment extends Payment {

    private String last4Digits;
}

@TypeAlias("bank_transfer")
public class BankTransferPayment extends Payment {

    private String iban;
}

public interface PaymentRepository extends MongoRepository<Payment, String> {

    List<Payment> findByAmountGreaterThan(BigDecimal threshold);
}

// each element is really a CardPayment or BankTransferPayment instance,
// resolved from the document's stored "_class" discriminator
List<Payment> payments = paymentRepository.findByAmountGreaterThan(BigDecimal.valueOf(100));

public interface OrderRepository extends MongoRepository<Order, String> {

    // derived query -- method name parsed into a MongoDB query
    List<Order> findByStatus(String status);

    List<Order> findByCustomerIdAndStatus(String customerId, String status);

    Optional<Order> findFirstByCustomerIdOrderByPlacedAtDesc(String customerId);

    // @Query for anything the derived-query syntax cannot express cleanly
    @Query("{ 'totalAmount' : { $gte: ?0 } }")
    List<Order> findWithTotalAtLeast(BigDecimal minAmount);

    long countByStatus(String status);
}

@Service
public class OrderService {

    private final OrderRepository orders;

    public OrderService(OrderRepository orders) {
        this.orders = orders;
    }

    public Order place(Order order) {
        return orders.save(order);              // insert or upsert by _id
    }

    public Page<Order> forCustomer(String customerId, Pageable pageable) {
        return orders.findAll(pageable);         // paging/sorting from Spring Data Commons
    }
}

Window<Order> findFirst20ByStatus(String status, Sort sort, ScrollPosition position);

// usage
Window<Order> window = orders.findFirst20ByStatus(
        "SHIPPED", Sort.by("id"), ScrollPosition.keyset());

@Document(collection = "orders")
@CompoundIndex(name = "customer_status_idx", def = "{'customer_id': 1, 'status': 1}")
public class Order {

    @Id
    private String id;

    @Indexed
    @Field("customer_id")
    private String customerId;

    @Indexed(unique = true)
    private String orderNumber;

    @Indexed(expireAfterSeconds = 2_592_000)     // TTL index: auto-delete after 30 days
    private Instant placedAt;

    private String status;
}

@Configuration
@EnableMongoAuditing
public class MongoConfig {

    @Bean
    public AuditorAware<String> auditorProvider() {
        return () -> Optional.ofNullable(SecurityContextHolder.getContext().getAuthentication())
                .map(Authentication::getName);
    }
}

@Document(collection = "orders")
public class Order {

    @Id
    private String id;

    @CreatedDate
    private Instant createdAt;

    @LastModifiedDate
    private Instant updatedAt;

    @CreatedBy
    private String createdBy;

    @LastModifiedBy
    private String lastModifiedBy;
}

@Document(collection = "orders")
public class Order {

    @Id
    private String id;

    private String status;

    @Version
    private Long version;
}

@Configuration
public class TransactionConfig {

    @Bean
    MongoTransactionManager transactionManager(MongoDatabaseFactory dbFactory) {
        return new MongoTransactionManager(dbFactory);
    }
}

@Service
public class OrderTransferService {

    private final MongoTemplate mongoTemplate;

    public OrderTransferService(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    @Transactional
    public void moveOrder(String orderId, String fromCustomerId, String toCustomerId) {
        Order order = mongoTemplate.findById(orderId, Order.class);
        order.setCustomerId(toCustomerId);
        mongoTemplate.save(order);

        mongoTemplate.updateFirst(
                Query.query(Criteria.where("customerId").is(fromCustomerId)),
                new Update().inc("openOrderCount", -1),
                Customer.class);
        // both writes commit or roll back together
    }
}

@Component
public class OrderChangeListener {

    public OrderChangeListener(MongoTemplate mongoTemplate) {
        MessageListenerContainer container = new DefaultMessageListenerContainer(mongoTemplate);
        container.start();

        ChangeStreamRequest<Order> request = ChangeStreamRequest.builder((Order order) ->
                        System.out.println("Order changed: " + order))
                .collection("orders")
                .filter(Aggregation.newAggregation(
                        Aggregation.match(Criteria.where("operationType").is("update"))))
                .build();

        container.register(request, Order.class);
    }
}