Hibernate Enterprise Patterns

Core Enterprise Patterns

• Repository Pattern: Abstraction layer for data access
• Unit of Work: Transaction management and change tracking
• Domain-Driven Design: Rich domain models with business logic
• CQRS: Command Query Responsibility Segregation
• Event Sourcing: Event-driven architecture with audit trails
• Specification Pattern: Encapsulating business rules

Order Aggregate Root

@Entity
@Table(name = "orders")
public class Order {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Embedded
    private OrderNumber orderNumber;
    
    @Embedded
    private CustomerInfo customerInfo;
    
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderItem> items = new ArrayList<>();
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status;
    
    @Embedded
    private Money totalAmount;
    
    @CreationTimestamp
    private LocalDateTime createdAt;
    
    @UpdateTimestamp
    private LocalDateTime updatedAt;
    
    // Business methods
    public void addItem(Product product, int quantity) {
        if (status != OrderStatus.DRAFT) {
            throw new IllegalStateException("Cannot modify order in " + status + " status");
        }
        
        if (quantity <= 0) {
            throw new IllegalArgumentException("Quantity must be positive");
        }
        
        OrderItem item = new OrderItem(this, product, quantity);
        items.add(item);
        recalculateTotal();
    }
    
    public void removeItem(OrderItem item) {
        if (status != OrderStatus.DRAFT) {
            throw new IllegalStateException("Cannot modify order in " + status + " status");
        }
        
        items.remove(item);
        recalculateTotal();
    }
    
    public void confirm() {
        if (status != OrderStatus.DRAFT) {
            throw new IllegalStateException("Cannot confirm order in " + status + " status");
        }
        
        if (items.isEmpty()) {
            throw new IllegalStateException("Cannot confirm empty order");
        }
        
        status = OrderStatus.CONFIRMED;
        // Publish domain event
        DomainEvents.publish(new OrderConfirmedEvent(this));
    }
    
    public void cancel(String reason) {
        if (status == OrderStatus.SHIPPED || status == OrderStatus.DELIVERED) {
            throw new IllegalStateException("Cannot cancel order in " + status + " status");
        }
        
        status = OrderStatus.CANCELLED;
        // Publish domain event
        DomainEvents.publish(new OrderCancelledEvent(this, reason));
    }
    
    private void recalculateTotal() {
        Money total = items.stream()
            .map(OrderItem::getSubtotal)
            .reduce(Money.ZERO, Money::add);
        this.totalAmount = total;
    }
    
    // Getters and other methods...
}

Application Service

@Service
@Transactional
public class OrderApplicationService {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private ProductRepository productRepository;
    
    @Autowired
    private UnitOfWork unitOfWork;
    
    @Autowired
    private DomainEventPublisher eventPublisher;
    
    public OrderId createOrder(CreateOrderRequest request) {
        // Validate business rules
        validateCreateOrderRequest(request);
        
        // Create order aggregate
        Order order = new Order(
            OrderNumber.generate(),
            new CustomerInfo(request.getCustomerId(), request.getCustomerName()),
            request.getShippingAddress()
        );
        
        // Add items with business validation
        for (CreateOrderItemRequest itemRequest : request.getItems()) {
            Product product = productRepository.findById(itemRequest.getProductId())
                .orElseThrow(() -> new ProductNotFoundException(itemRequest.getProductId()));
            
            // Business rule: Check stock availability
            if (product.getStockQuantity() < itemRequest.getQuantity()) {
                throw new InsufficientStockException(product.getId(), 
                                                   product.getStockQuantity(), 
                                                   itemRequest.getQuantity());
            }
            
            order.addItem(product, itemRequest.getQuantity());
        }
        
        // Register with unit of work
        unitOfWork.registerNew(order);
        
        // Commit transaction
        unitOfWork.commit();
        
        // Publish domain events
        eventPublisher.publishAll(order.getDomainEvents());
        order.clearDomainEvents();
        
        return order.getId();
    }
    
    @Transactional(readOnly = true)
    public OrderView getOrder(OrderId orderId) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
        
        return OrderView.from(order);
    }
    
    public void confirmOrder(OrderId orderId) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
        
        order.confirm();
        
        unitOfWork.registerDirty(order);
        unitOfWork.commit();
        
        eventPublisher.publishAll(order.getDomainEvents());
        order.clearDomainEvents();
    }
    
    private void validateCreateOrderRequest(CreateOrderRequest request) {
        if (request.getItems().isEmpty()) {
            throw new IllegalArgumentException("Order must have at least one item");
        }
        // Additional validation...
    }
}