MACRO NEPAL
DDD Bounded Contexts in Java: Complete Implementation Guide
awiskar acharya
November 17, 2025
10:03 am

Learn how to implement Domain-Driven Design (DDD) Bounded Contexts in Java with practical examples and modern architectures.

Table of Contents

  1. Bounded Contexts Fundamentals
  2. Strategic Design Patterns
  3. E-Commerce Case Study
  4. Context Mapping
  5. Implementation Architecture
  6. Communication Patterns
  7. Testing Strategies

Bounded Contexts Fundamentals

What are Bounded Contexts?

Bounded Contexts define explicit boundaries within which a particular domain model applies. Each context has its own:

  • Ubiquitous Language
  • Domain Models
  • Business Rules
  • Data Persistence

Key Principles:

  • Explicit Boundaries: Clear separation between contexts
  • Autonomy: Each context can evolve independently
  • Integration: Well-defined communication patterns
  • Consistency Boundaries: Transactions within single context

Strategic Design Patterns

1. Core Domain Models

// Shared Kernel - Common types used across contexts
public class SharedKernel {
// Common value objects
public record Money(BigDecimal amount, Currency currency) {
public Money {
if (amount.compareTo(BigDecimal.ZERO) < 0) {
throw new IllegalArgumentException("Amount cannot be negative");
}
}
public Money add(Money other) {
if (!this.currency.equals(other.currency)) {
throw new IllegalArgumentException("Currency mismatch");
}
return new Money(this.amount.add(other.amount), this.currency);
}
}
public enum Currency {
USD, EUR, GBP, JPY
}
public record Address(
String street,
String city,
String state,
String zipCode,
String country
) {
public Address {
if (street == null || street.isBlank()) {
throw new IllegalArgumentException("Street is required");
}
if (city == null || city.isBlank()) {
throw new IllegalArgumentException("City is required");
}
}
}
// Common identifiers
public record CustomerId(String value) {
public CustomerId {
if (value == null || value.isBlank()) {
throw new IllegalArgumentException("Customer ID cannot be empty");
}
}
}
public record OrderId(String value) {
public OrderId {
if (value == null || value.isBlank()) {
throw new IllegalArgumentException("Order ID cannot be empty");
}
}
}
}

E-Commerce Case Study

2. Bounded Context: Identity & Access

// Identity Context - Manages users, authentication, and authorization
public class IdentityContext {
// Core Domain Models
public record UserId(String value) {
public UserId {
if (value == null || value.isBlank()) {
throw new IllegalArgumentException("User ID cannot be empty");
}
}
}
public enum UserStatus {
PENDING_VERIFICATION, ACTIVE, SUSPENDED, DELETED
}
public enum UserRole {
CUSTOMER, SELLER, ADMIN, SUPPORT
}
// Aggregate Root
public static class User {
private final UserId id;
private String email;
private String passwordHash;
private UserStatus status;
private Set<UserRole> roles;
private final Instant createdAt;
private Instant updatedAt;
public User(UserId id, String email, String passwordHash, Set<UserRole> roles) {
this.id = id;
this.email = email;
this.passwordHash = passwordHash;
this.roles = new HashSet<>(roles);
this.status = UserStatus.PENDING_VERIFICATION;
this.createdAt = Instant.now();
this.updatedAt = Instant.now();
validate();
}
// Domain methods
public void verifyEmail() {
if (this.status != UserStatus.PENDING_VERIFICATION) {
throw new IllegalStateException("User is not pending verification");
}
this.status = UserStatus.ACTIVE;
this.updatedAt = Instant.now();
}
public void suspend() {
this.status = UserStatus.SUSPENDED;
this.updatedAt = Instant.now();
}
public void addRole(UserRole role) {
this.roles.add(role);
this.updatedAt = Instant.now();
}
public boolean hasRole(UserRole role) {
return this.roles.contains(role);
}
private void validate() {
if (email == null || !email.contains("@")) {
throw new IllegalArgumentException("Invalid email address");
}
if (passwordHash == null || passwordHash.isBlank()) {
throw new IllegalArgumentException("Password hash is required");
}
if (roles.isEmpty()) {
throw new IllegalArgumentException("User must have at least one role");
}
}
// Getters
public UserId getId() { return id; }
public String getEmail() { return email; }
public UserStatus getStatus() { return status; }
public Set<UserRole> getRoles() { return Set.copyOf(roles); }
public Instant getCreatedAt() { return createdAt; }
public Instant getUpdatedAt() { return updatedAt; }
}
// Domain Service
public interface PasswordHasher {
String hash(String plainPassword);
boolean verify(String plainPassword, String hash);
}
public static class AuthenticationService {
private final PasswordHasher passwordHasher;
private final UserRepository userRepository;
public AuthenticationService(PasswordHasher passwordHasher, UserRepository userRepository) {
this.passwordHasher = passwordHasher;
this.userRepository = userRepository;
}
public User authenticate(String email, String plainPassword) {
var user = userRepository.findByEmail(email)
.orElseThrow(() -> new AuthenticationException("Invalid credentials"));
if (user.getStatus() != UserStatus.ACTIVE) {
throw new AuthenticationException("User account is not active");
}
if (!passwordHasher.verify(plainPassword, user.passwordHash)) {
throw new AuthenticationException("Invalid credentials");
}
return user;
}
}
// Repository interface
public interface UserRepository {
Optional<User> findById(UserId id);
Optional<User> findByEmail(String email);
void save(User user);
boolean existsByEmail(String email);
}
}

3. Bounded Context: Catalog

// Catalog Context - Manages products, categories, and inventory
public class CatalogContext {
// Value Objects
public record ProductId(String value) {
public ProductId {
if (value == null || value.isBlank()) {
throw new IllegalArgumentException("Product ID cannot be empty");
}
}
}
public record CategoryId(String value) {
public CategoryId {
if (value == null || value.isBlank()) {
throw new IllegalArgumentException("Category ID cannot be empty");
}
}
}
public record StockQuantity(int value) {
public StockQuantity {
if (value < 0) {
throw new IllegalArgumentException("Stock quantity cannot be negative");
}
}
public StockQuantity add(StockQuantity other) {
return new StockQuantity(this.value + other.value);
}
public StockQuantity subtract(StockQuantity other) {
int result = this.value - other.value;
if (result < 0) {
throw new IllegalArgumentException("Insufficient stock");
}
return new StockQuantity(result);
}
}
// Entities
public static class Product {
private final ProductId id;
private String name;
private String description;
private SharedKernel.Money price;
private CategoryId categoryId;
private StockQuantity stockQuantity;
private boolean active;
private final Instant createdAt;
private Instant updatedAt;
public Product(ProductId id, String name, SharedKernel.Money price, 
CategoryId categoryId, StockQuantity initialStock) {
this.id = id;
this.name = name;
this.price = price;
this.categoryId = categoryId;
this.stockQuantity = initialStock;
this.active = true;
this.createdAt = Instant.now();
this.updatedAt = Instant.now();
validate();
}
// Domain methods
public void updatePrice(SharedKernel.Money newPrice) {
this.price = newPrice;
this.updatedAt = Instant.now();
}
public void updateStock(StockQuantity newStock) {
this.stockQuantity = newStock;
this.updatedAt = Instant.now();
}
public void increaseStock(StockQuantity quantity) {
this.stockQuantity = this.stockQuantity.add(quantity);
this.updatedAt = Instant.now();
}
public void decreaseStock(StockQuantity quantity) {
this.stockQuantity = this.stockQuantity.subtract(quantity);
this.updatedAt = Instant.now();
}
public void deactivate() {
this.active = false;
this.updatedAt = Instant.now();
}
public void activate() {
this.active = true;
this.updatedAt = Instant.now();
}
public boolean isAvailable() {
return active && stockQuantity.value() > 0;
}
private void validate() {
if (name == null || name.isBlank()) {
throw new IllegalArgumentException("Product name is required");
}
if (price == null) {
throw new IllegalArgumentException("Product price is required");
}
if (categoryId == null) {
throw new IllegalArgumentException("Category is required");
}
}
// Getters
public ProductId getId() { return id; }
public String getName() { return name; }
public SharedKernel.Money getPrice() { return price; }
public CategoryId getCategoryId() { return categoryId; }
public StockQuantity getStockQuantity() { return stockQuantity; }
public boolean isActive() { return active; }
public Instant getCreatedAt() { return createdAt; }
public Instant getUpdatedAt() { return updatedAt; }
}
public static class Category {
private final CategoryId id;
private String name;
private String description;
private CategoryId parentCategoryId;
private final Instant createdAt;
private Instant updatedAt;
public Category(CategoryId id, String name) {
this.id = id;
this.name = name;
this.createdAt = Instant.now();
this.updatedAt = Instant.now();
validate();
}
private void validate() {
if (name == null || name.isBlank()) {
throw new IllegalArgumentException("Category name is required");
}
}
// Getters and setters
public CategoryId getId() { return id; }
public String getName() { return name; }
public String getDescription() { return description; }
public CategoryId getParentCategoryId() { return parentCategoryId; }
public Instant getCreatedAt() { return createdAt; }
public Instant getUpdatedAt() { return updatedAt; }
public void setName(String name) { 
this.name = name; 
this.updatedAt = Instant.now();
}
public void setDescription(String description) { 
this.description = description; 
this.updatedAt = Instant.now();
}
public void setParentCategory(CategoryId parentCategoryId) { 
this.parentCategoryId = parentCategoryId; 
this.updatedAt = Instant.now();
}
}
// Domain Service
public static class ProductSearchService {
private final ProductRepository productRepository;
public ProductSearchService(ProductRepository productRepository) {
this.productRepository = productRepository;
}
public List<Product> searchActiveProducts(String query, CategoryId categoryId) {
return productRepository.findActiveProducts(query, categoryId);
}
public List<Product> findProductsInStock() {
return productRepository.findProductsInStock();
}
}
// Repository interfaces
public interface ProductRepository {
Optional<Product> findById(ProductId id);
List<Product> findActiveProducts(String query, CategoryId categoryId);
List<Product> findProductsInStock();
List<Product> findByCategory(CategoryId categoryId);
void save(Product product);
}
public interface CategoryRepository {
Optional<Category> findById(CategoryId id);
List<Category> findAll();
List<Category> findSubcategories(CategoryId parentId);
void save(Category category);
}
}

4. Bounded Context: Ordering

// Ordering Context - Manages orders, payments, and fulfillment
public class OrderingContext {
// Value Objects
public record OrderItem(
CatalogContext.ProductId productId,
String productName,
SharedKernel.Money unitPrice,
int quantity,
SharedKernel.Money subtotal
) {
public OrderItem {
if (productId == null) {
throw new IllegalArgumentException("Product ID is required");
}
if (productName == null || productName.isBlank()) {
throw new IllegalArgumentException("Product name is required");
}
if (unitPrice == null) {
throw new IllegalArgumentException("Unit price is required");
}
if (quantity <= 0) {
throw new IllegalArgumentException("Quantity must be positive");
}
if (subtotal == null) {
throw new IllegalArgumentException("Subtotal is required");
}
}
public static OrderItem create(CatalogContext.ProductId productId, 
String productName, 
SharedKernel.Money unitPrice, 
int quantity) {
SharedKernel.Money subtotal = new SharedKernel.Money(
unitPrice.amount().multiply(BigDecimal.valueOf(quantity)),
unitPrice.currency()
);
return new OrderItem(productId, productName, unitPrice, quantity, subtotal);
}
}
public enum OrderStatus {
DRAFT, PENDING_PAYMENT, CONFIRMED, PROCESSING, SHIPPED, DELIVERED, CANCELLED
}
public enum PaymentStatus {
PENDING, PROCESSING, COMPLETED, FAILED, REFUNDED
}
// Aggregate Root
public static class Order {
private final SharedKernel.OrderId id;
private final SharedKernel.CustomerId customerId;
private OrderStatus status;
private final List<OrderItem> items;
private SharedKernel.Money totalAmount;
private SharedKernel.Address shippingAddress;
private SharedKernel.Address billingAddress;
private PaymentStatus paymentStatus;
private final Instant createdAt;
private Instant updatedAt;
public Order(SharedKernel.OrderId id, SharedKernel.CustomerId customerId, 
SharedKernel.Address shippingAddress, SharedKernel.Address billingAddress) {
this.id = id;
this.customerId = customerId;
this.status = OrderStatus.DRAFT;
this.items = new ArrayList<>();
this.totalAmount = new SharedKernel.Money(BigDecimal.ZERO, SharedKernel.Currency.USD);
this.shippingAddress = shippingAddress;
this.billingAddress = billingAddress;
this.paymentStatus = PaymentStatus.PENDING;
this.createdAt = Instant.now();
this.updatedAt = Instant.now();
validate();
}
// Domain methods
public void addItem(OrderItem item) {
if (status != OrderStatus.DRAFT) {
throw new IllegalStateException("Cannot modify order in status: " + status);
}
items.add(item);
recalculateTotal();
this.updatedAt = Instant.now();
}
public void removeItem(OrderItem item) {
if (status != OrderStatus.DRAFT) {
throw new IllegalStateException("Cannot modify order in status: " + status);
}
items.remove(item);
recalculateTotal();
this.updatedAt = Instant.now();
}
public void submit() {
if (status != OrderStatus.DRAFT) {
throw new IllegalStateException("Order is not in draft status");
}
if (items.isEmpty()) {
throw new IllegalStateException("Cannot submit empty order");
}
this.status = OrderStatus.PENDING_PAYMENT;
this.updatedAt = Instant.now();
}
public void confirmPayment() {
if (status != OrderStatus.PENDING_PAYMENT) {
throw new IllegalStateException("Order is not pending payment");
}
this.status = OrderStatus.CONFIRMED;
this.paymentStatus = PaymentStatus.COMPLETED;
this.updatedAt = Instant.now();
}
public void cancel() {
if (status == OrderStatus.SHIPPED || status == OrderStatus.DELIVERED) {
throw new IllegalStateException("Cannot cancel shipped or delivered order");
}
this.status = OrderStatus.CANCELLED;
this.updatedAt = Instant.now();
}
public void markAsShipped() {
if (status != OrderStatus.CONFIRMED) {
throw new IllegalStateException("Order must be confirmed before shipping");
}
this.status = OrderStatus.SHIPPED;
this.updatedAt = Instant.now();
}
public void markAsDelivered() {
if (status != OrderStatus.SHIPPED) {
throw new IllegalStateException("Order must be shipped before delivery");
}
this.status = OrderStatus.DELIVERED;
this.updatedAt = Instant.now();
}
private void recalculateTotal() {
BigDecimal total = items.stream()
.map(item -> item.subtotal().amount())
.reduce(BigDecimal.ZERO, BigDecimal::add);
this.totalAmount = new SharedKernel.Money(total, totalAmount.currency());
}
private void validate() {
if (customerId == null) {
throw new IllegalArgumentException("Customer ID is required");
}
if (shippingAddress == null) {
throw new IllegalArgumentException("Shipping address is required");
}
if (billingAddress == null) {
throw new IllegalArgumentException("Billing address is required");
}
}
// Getters
public SharedKernel.OrderId getId() { return id; }
public SharedKernel.CustomerId getCustomerId() { return customerId; }
public OrderStatus getStatus() { return status; }
public List<OrderItem> getItems() { return List.copyOf(items); }
public SharedKernel.Money getTotalAmount() { return totalAmount; }
public SharedKernel.Address getShippingAddress() { return shippingAddress; }
public SharedKernel.Address getBillingAddress() { return billingAddress; }
public PaymentStatus getPaymentStatus() { return paymentStatus; }
public Instant getCreatedAt() { return createdAt; }
public Instant getUpdatedAt() { return updatedAt; }
}
// Domain Service
public static class OrderPricingService {
private final CatalogContext.ProductRepository productRepository;
public OrderPricingService(CatalogContext.ProductRepository productRepository) {
this.productRepository = productRepository;
}
public SharedKernel.Money calculateOrderTotal(List<OrderItem> items) {
BigDecimal total = BigDecimal.ZERO;
SharedKernel.Currency currency = null;
for (OrderItem item : items) {
if (currency == null) {
currency = item.unitPrice().currency();
} else if (!currency.equals(item.unitPrice().currency())) {
throw new IllegalArgumentException("Mixed currencies in order items");
}
total = total.add(item.subtotal().amount());
}
if (currency == null) {
currency = SharedKernel.Currency.USD; // Default currency
}
return new SharedKernel.Money(total, currency);
}
public void validateProductAvailability(OrderItem item) {
var product = productRepository.findById(item.productId())
.orElseThrow(() -> new IllegalArgumentException("Product not found"));
if (!product.isActive()) {
throw new IllegalArgumentException("Product is not active");
}
if (product.getStockQuantity().value() < item.quantity()) {
throw new IllegalArgumentException("Insufficient stock for product: " + product.getName());
}
}
}
// Repository interface
public interface OrderRepository {
Optional<Order> findById(SharedKernel.OrderId id);
List<Order> findByCustomerId(SharedKernel.CustomerId customerId);
List<Order> findByStatus(OrderStatus status);
void save(Order order);
}
}

5. Bounded Context: Shipping

// Shipping Context - Manages logistics, tracking, and delivery
public class ShippingContext {
// Value Objects
public record TrackingNumber(String value) {
public TrackingNumber {
if (value == null || value.isBlank()) {
throw new IllegalArgumentException("Tracking number cannot be empty");
}
}
}
public record PackageWeight(double value, WeightUnit unit) {
public PackageWeight {
if (value <= 0) {
throw new IllegalArgumentException("Weight must be positive");
}
}
public enum WeightUnit {
GRAMS, KILOGRAMS, POUNDS, OUNCES
}
}
public record PackageDimensions(double length, double width, double height, LengthUnit unit) {
public PackageDimensions {
if (length <= 0 || width <= 0 || height <= 0) {
throw new IllegalArgumentException("Dimensions must be positive");
}
}
public enum LengthUnit {
CENTIMETERS, INCHES
}
}
public enum ShippingStatus {
PENDING, LABEL_CREATED, IN_TRANSIT, OUT_FOR_DELIVERY, DELIVERED, FAILED
}
// Aggregate Root
public static class Shipment {
private final SharedKernel.OrderId orderId;
private final TrackingNumber trackingNumber;
private ShippingStatus status;
private final PackageWeight weight;
private final PackageDimensions dimensions;
private SharedKernel.Address origin;
private SharedKernel.Address destination;
private String carrier;
private String serviceLevel;
private final Instant createdAt;
private Instant updatedAt;
private Instant estimatedDelivery;
private Instant actualDelivery;
public Shipment(SharedKernel.OrderId orderId, TrackingNumber trackingNumber,
PackageWeight weight, PackageDimensions dimensions,
SharedKernel.Address origin, SharedKernel.Address destination,
String carrier, String serviceLevel) {
this.orderId = orderId;
this.trackingNumber = trackingNumber;
this.status = ShippingStatus.PENDING;
this.weight = weight;
this.dimensions = dimensions;
this.origin = origin;
this.destination = destination;
this.carrier = carrier;
this.serviceLevel = serviceLevel;
this.createdAt = Instant.now();
this.updatedAt = Instant.now();
validate();
}
// Domain methods
public void createShippingLabel() {
if (status != ShippingStatus.PENDING) {
throw new IllegalStateException("Shipment is not pending");
}
this.status = ShippingStatus.LABEL_CREATED;
this.updatedAt = Instant.now();
}
public void markAsInTransit() {
if (status != ShippingStatus.LABEL_CREATED) {
throw new IllegalStateException("Shipping label must be created first");
}
this.status = ShippingStatus.IN_TRANSIT;
this.updatedAt = Instant.now();
}
public void markAsOutForDelivery() {
if (status != ShippingStatus.IN_TRANSIT) {
throw new IllegalStateException("Shipment must be in transit first");
}
this.status = ShippingStatus.OUT_FOR_DELIVERY;
this.updatedAt = Instant.now();
}
public void markAsDelivered() {
if (status != ShippingStatus.OUT_FOR_DELIVERY) {
throw new IllegalStateException("Shipment must be out for delivery first");
}
this.status = ShippingStatus.DELIVERED;
this.actualDelivery = Instant.now();
this.updatedAt = Instant.now();
}
public void markAsFailed(String reason) {
this.status = ShippingStatus.FAILED;
this.updatedAt = Instant.now();
}
public void updateTracking(String carrier, String trackingUrl) {
this.carrier = carrier;
this.updatedAt = Instant.now();
}
private void validate() {
if (orderId == null) {
throw new IllegalArgumentException("Order ID is required");
}
if (origin == null) {
throw new IllegalArgumentException("Origin address is required");
}
if (destination == null) {
throw new IllegalArgumentException("Destination address is required");
}
if (carrier == null || carrier.isBlank()) {
throw new IllegalArgumentException("Carrier is required");
}
}
// Getters
public SharedKernel.OrderId getOrderId() { return orderId; }
public TrackingNumber getTrackingNumber() { return trackingNumber; }
public ShippingStatus getStatus() { return status; }
public PackageWeight getWeight() { return weight; }
public PackageDimensions getDimensions() { return dimensions; }
public SharedKernel.Address getOrigin() { return origin; }
public SharedKernel.Address getDestination() { return destination; }
public String getCarrier() { return carrier; }
public String getServiceLevel() { return serviceLevel; }
public Instant getCreatedAt() { return createdAt; }
public Instant getUpdatedAt() { return updatedAt; }
public Instant getEstimatedDelivery() { return estimatedDelivery; }
public Instant getActualDelivery() { return actualDelivery; }
}
// Domain Service
public static class ShippingCostCalculator {
private static final Map<String, BigDecimal> CARRIER_RATES = Map.of(
"UPS", new BigDecimal("0.15"),
"FEDEX", new BigDecimal("0.18"),
"USPS", new BigDecimal("0.12")
);
public SharedKernel.Money calculateCost(PackageWeight weight, 
PackageDimensions dimensions,
String carrier, 
String serviceLevel,
int distanceMiles) {
BigDecimal baseRate = CARRIER_RATES.getOrDefault(carrier, new BigDecimal("0.15"));
// Simple calculation: base rate * weight * distance
double weightInPounds = convertToPounds(weight);
BigDecimal cost = baseRate
.multiply(BigDecimal.valueOf(weightInPounds))
.multiply(BigDecimal.valueOf(distanceMiles));
// Add service level premium
if ("EXPRESS".equals(serviceLevel)) {
cost = cost.multiply(new BigDecimal("1.5"));
} else if ("OVERNIGHT".equals(serviceLevel)) {
cost = cost.multiply(new BigDecimal("2.0"));
}
return new SharedKernel.Money(cost, SharedKernel.Currency.USD);
}
private double convertToPounds(PackageWeight weight) {
return switch (weight.unit()) {
case GRAMS -> weight.value() / 453.592;
case KILOGRAMS -> weight.value() * 2.20462;
case POUNDS -> weight.value();
case OUNCES -> weight.value() / 16;
};
}
}
// Repository interface
public interface ShipmentRepository {
Optional<Shipment> findByOrderId(SharedKernel.OrderId orderId);
Optional<Shipment> findByTrackingNumber(TrackingNumber trackingNumber);
List<Shipment> findByStatus(ShippingStatus status);
void save(Shipment shipment);
}
}

Context Mapping

6. Context Integration Patterns

// Anti-Corruption Layer (ACL) for context integration
public class ContextIntegration {
// ACL for Identity Context integration
public static class IdentityContextACL {
private final IdentityContext.UserRepository userRepository;
public IdentityContextACL(IdentityContext.UserRepository userRepository) {
this.userRepository = userRepository;
}
public CustomerInfo getCustomerInfo(SharedKernel.CustomerId customerId) {
var userId = new IdentityContext.UserId(customerId.value());
var user = userRepository.findById(userId)
.orElseThrow(() -> new CustomerNotFoundException(customerId));
return new CustomerInfo(
customerId,
user.getEmail(),
user.getStatus() == IdentityContext.UserStatus.ACTIVE,
user.getRoles()
);
}
public void validateCustomerActive(SharedKernel.CustomerId customerId) {
var info = getCustomerInfo(customerId);
if (!info.active()) {
throw new CustomerNotActiveException(customerId);
}
}
public record CustomerInfo(
SharedKernel.CustomerId customerId,
String email,
boolean active,
Set<IdentityContext.UserRole> roles
) {}
}
// ACL for Catalog Context integration
public static class CatalogContextACL {
private final CatalogContext.ProductRepository productRepository;
public CatalogContextACL(CatalogContext.ProductRepository productRepository) {
this.productRepository = productRepository;
}
public ProductInfo getProductInfo(CatalogContext.ProductId productId) {
var product = productRepository.findById(productId)
.orElseThrow(() -> new ProductNotFoundException(productId));
return new ProductInfo(
productId,
product.getName(),
product.getPrice(),
product.getStockQuantity(),
product.isActive()
);
}
public void reserveProduct(CatalogContext.ProductId productId, int quantity) {
var product = productRepository.findById(productId)
.orElseThrow(() -> new ProductNotFoundException(productId));
if (!product.isAvailable()) {
throw new ProductNotAvailableException(productId);
}
if (product.getStockQuantity().value() < quantity) {
throw new InsufficientStockException(productId, quantity, product.getStockQuantity().value());
}
product.decreaseStock(new CatalogContext.StockQuantity(quantity));
productRepository.save(product);
}
public record ProductInfo(
CatalogContext.ProductId productId,
String name,
SharedKernel.Money price,
CatalogContext.StockQuantity stock,
boolean active
) {}
}
// Domain Events for inter-context communication
public interface DomainEvent {
String eventId();
Instant occurredOn();
String eventType();
}
public record OrderCreatedEvent(
String eventId,
Instant occurredOn,
SharedKernel.OrderId orderId,
SharedKernel.CustomerId customerId,
SharedKernel.Money totalAmount,
List<OrderItem> items
) implements DomainEvent {
public OrderCreatedEvent(SharedKernel.OrderId orderId, SharedKernel.CustomerId customerId,
SharedKernel.Money totalAmount, List<OrderItem> items) {
this(UUID.randomUUID().toString(), Instant.now(), orderId, customerId, totalAmount, items);
}
@Override
public String eventType() {
return "ORDER_CREATED";
}
}
public record PaymentCompletedEvent(
String eventId,
Instant occurredOn,
SharedKernel.OrderId orderId,
SharedKernel.CustomerId customerId,
SharedKernel.Money amount
) implements DomainEvent {
public PaymentCompletedEvent(SharedKernel.OrderId orderId, SharedKernel.CustomerId customerId,
SharedKernel.Money amount) {
this(UUID.randomUUID().toString(), Instant.now(), orderId, customerId, amount);
}
@Override
public String eventType() {
return "PAYMENT_COMPLETED";
}
}
public record ProductStockUpdatedEvent(
String eventId,
Instant occurredOn,
CatalogContext.ProductId productId,
CatalogContext.StockQuantity newStock,
CatalogContext.StockQuantity oldStock
) implements DomainEvent {
public ProductStockUpdatedEvent(CatalogContext.ProductId productId,
CatalogContext.StockQuantity newStock,
CatalogContext.StockQuantity oldStock) {
this(UUID.randomUUID().toString(), Instant.now(), productId, newStock, oldStock);
}
@Override
public String eventType() {
return "PRODUCT_STOCK_UPDATED";
}
}
// Event handlers for cross-context integration
public static class OrderEventsHandler {
private final ShippingContext.ShipmentRepository shipmentRepository;
private final CatalogContextACL catalogACL;
public OrderEventsHandler(ShippingContext.ShipmentRepository shipmentRepository,
CatalogContextACL catalogACL) {
this.shipmentRepository = shipmentRepository;
this.catalogACL = catalogACL;
}
public void handleOrderCreated(OrderCreatedEvent event) {
// Reserve products in catalog
for (var item : event.items()) {
catalogACL.reserveProduct(item.productId(), item.quantity());
}
// Create shipment in shipping context
var shipment = new ShippingContext.Shipment(
event.orderId(),
new ShippingContext.TrackingNumber(generateTrackingNumber()),
calculatePackageWeight(event.items()),
calculatePackageDimensions(event.items()),
getWarehouseAddress(),
getCustomerAddress(event.customerId()), // Would need address service
"UPS",
"GROUND"
);
shipmentRepository.save(shipment);
}
public void handlePaymentCompleted(PaymentCompletedEvent event) {
// Update order status and trigger shipment
var shipment = shipmentRepository.findByOrderId(event.orderId())
.orElseThrow(() -> new ShipmentNotFoundException(event.orderId()));
shipment.createShippingLabel();
shipmentRepository.save(shipment);
}
private ShippingContext.PackageWeight calculatePackageWeight(List<OrderItem> items) {
// Simplified calculation
double totalWeight = items.size() * 0.5; // 0.5kg per item
return new ShippingContext.PackageWeight(totalWeight, 
ShippingContext.PackageWeight.WeightUnit.KILOGRAMS);
}
private ShippingContext.PackageDimensions calculatePackageDimensions(List<OrderItem> items) {
// Simplified calculation
return new ShippingContext.PackageDimensions(30.0, 20.0, 15.0, 
ShippingContext.PackageDimensions.LengthUnit.CENTIMETERS);
}
private SharedKernel.Address getWarehouseAddress() {
return new SharedKernel.Address(
"123 Warehouse St", "Commerce City", "CO", "80022", "US"
);
}
private SharedKernel.Address getCustomerAddress(SharedKernel.CustomerId customerId) {
// Would integrate with customer profile context
return new SharedKernel.Address(
"456 Customer Ave", "Denver", "CO", "80202", "US"
);
}
private String generateTrackingNumber() {
return "TRK" + System.currentTimeMillis() + 
ThreadLocalRandom.current().nextInt(1000, 9999);
}
}
}

Implementation Architecture

7. Spring Boot Application Structure

// Application layer for Identity Context
@RestController
@RequestMapping("/api/identity")
public class IdentityController {
private final IdentityContext.AuthenticationService authenticationService;
private final IdentityContext.UserRepository userRepository;
public IdentityController(IdentityContext.AuthenticationService authenticationService,
IdentityContext.UserRepository userRepository) {
this.authenticationService = authenticationService;
this.userRepository = userRepository;
}
@PostMapping("/register")
public ResponseEntity<UserResponse> register(@RequestBody RegisterRequest request) {
// Validate request
if (userRepository.existsByEmail(request.email())) {
throw new UserAlreadyExistsException(request.email());
}
// Create user
var userId = new IdentityContext.UserId(UUID.randomUUID().toString());
var user = new IdentityContext.User(
userId,
request.email(),
hashPassword(request.password()),
Set.of(IdentityContext.UserRole.CUSTOMER)
);
userRepository.save(user);
return ResponseEntity.status(HttpStatus.CREATED)
.body(UserResponse.fromDomain(user));
}
@PostMapping("/authenticate")
public ResponseEntity<AuthenticationResponse> authenticate(@RequestBody AuthenticationRequest request) {
var user = authenticationService.authenticate(request.email(), request.password());
var token = generateAuthToken(user);
return ResponseEntity.ok(new AuthenticationResponse(token, UserResponse.fromDomain(user)));
}
// DTOs
public record RegisterRequest(String email, String password, String confirmPassword) {}
public record AuthenticationRequest(String email, String password) {}
public record UserResponse(String userId, String email, String status, Set<String> roles) {
public static UserResponse fromDomain(IdentityContext.User user) {
return new UserResponse(
user.getId().value(),
user.getEmail(),
user.getStatus().name(),
user.getRoles().stream()
.map(Enum::name)
.collect(Collectors.toSet())
);
}
}
public record AuthenticationResponse(String token, UserResponse user) {}
private String hashPassword(String plainPassword) {
// Implementation would use proper password hashing
return "hashed_" + plainPassword;
}
private String generateAuthToken(IdentityContext.User user) {
// Implementation would use JWT or similar
return "token_" + user.getId().value();
}
}
// Application layer for Ordering Context
@RestController
@RequestMapping("/api/orders")
public class OrderController {
private final OrderingContext.OrderRepository orderRepository;
private final OrderingContext.OrderPricingService pricingService;
private final ContextIntegration.IdentityContextACL identityACL;
private final ContextIntegration.CatalogContextACL catalogACL;
private final ContextIntegration.OrderEventsHandler eventsHandler;
public OrderController(OrderingContext.OrderRepository orderRepository,
OrderingContext.OrderPricingService pricingService,
ContextIntegration.IdentityContextACL identityACL,
ContextIntegration.CatalogContextACL catalogACL,
ContextIntegration.OrderEventsHandler eventsHandler) {
this.orderRepository = orderRepository;
this.pricingService = pricingService;
this.identityACL = identityACL;
this.catalogACL = catalogACL;
this.eventsHandler = eventsHandler;
}
@PostMapping
public ResponseEntity<OrderResponse> createOrder(@RequestBody CreateOrderRequest request) {
// Validate customer
identityACL.validateCustomerActive(request.customerId());
// Create order
var orderId = new SharedKernel.OrderId(UUID.randomUUID().toString());
var order = new OrderingContext.Order(
orderId,
request.customerId(),
request.shippingAddress(),
request.billingAddress()
);
// Add items
for (var itemRequest : request.items()) {
var productInfo = catalogACL.getProductInfo(itemRequest.productId());
var orderItem = OrderingContext.OrderItem.create(
itemRequest.productId(),
productInfo.name(),
productInfo.price(),
itemRequest.quantity()
);
order.addItem(orderItem);
}
// Submit order
order.submit();
orderRepository.save(order);
// Publish domain event
var event = new ContextIntegration.OrderCreatedEvent(
orderId,
request.customerId(),
order.getTotalAmount(),
order.getItems()
);
eventsHandler.handleOrderCreated(event);
return ResponseEntity.status(HttpStatus.CREATED)
.body(OrderResponse.fromDomain(order));
}
@PostMapping("/{orderId}/payment")
public ResponseEntity<OrderResponse> processPayment(@PathVariable String orderId, 
@RequestBody PaymentRequest request) {
var order = orderRepository.findById(new SharedKernel.OrderId(orderId))
.orElseThrow(() -> new OrderNotFoundException(orderId));
// Process payment (simplified)
order.confirmPayment();
orderRepository.save(order);
// Publish domain event
var event = new ContextIntegration.PaymentCompletedEvent(
order.getId(),
order.getCustomerId(),
order.getTotalAmount()
);
eventsHandler.handlePaymentCompleted(event);
return ResponseEntity.ok(OrderResponse.fromDomain(order));
}
// DTOs
public record CreateOrderRequest(
SharedKernel.CustomerId customerId,
SharedKernel.Address shippingAddress,
SharedKernel.Address billingAddress,
List<OrderItemRequest> items
) {}
public record OrderItemRequest(CatalogContext.ProductId productId, int quantity) {}
public record PaymentRequest(String paymentMethod, String transactionId) {}
public record OrderResponse(
String orderId,
String customerId,
String status,
List<OrderItemResponse> items,
MoneyResponse totalAmount,
AddressResponse shippingAddress,
AddressResponse billingAddress,
String paymentStatus,
Instant createdAt
) {
public static OrderResponse fromDomain(OrderingContext.Order order) {
return new OrderResponse(
order.getId().value(),
order.getCustomerId().value(),
order.getStatus().name(),
order.getItems().stream()
.map(OrderItemResponse::fromDomain)
.collect(Collectors.toList()),
MoneyResponse.fromDomain(order.getTotalAmount()),
AddressResponse.fromDomain(order.getShippingAddress()),
AddressResponse.fromDomain(order.getBillingAddress()),
order.getPaymentStatus().name(),
order.getCreatedAt()
);
}
}
public record OrderItemResponse(
String productId,
String productName,
MoneyResponse unitPrice,
int quantity,
MoneyResponse subtotal
) {
public static OrderItemResponse fromDomain(OrderingContext.OrderItem item) {
return new OrderItemResponse(
item.productId().value(),
item.productName(),
MoneyResponse.fromDomain(item.unitPrice()),
item.quantity(),
MoneyResponse.fromDomain(item.subtotal())
);
}
}
public record MoneyResponse(BigDecimal amount, String currency) {
public static MoneyResponse fromDomain(SharedKernel.Money money) {
return new MoneyResponse(money.amount(), money.currency().name());
}
}
public record AddressResponse(String street, String city, String state, 
String zipCode, String country) {
public static AddressResponse fromDomain(SharedKernel.Address address) {
return new AddressResponse(
address.street(), address.city(), address.state(),
address.zipCode(), address.country()
);
}
}
}

Communication Patterns

8. Asynchronous Communication with Events

// Event publishing and consumption
@Component
public class DomainEventPublisher {
private final ApplicationEventPublisher eventPublisher;
public DomainEventPublisher(ApplicationEventPublisher eventPublisher) {
this.eventPublisher = eventPublisher;
}
public void publish(ContextIntegration.DomainEvent event) {
eventPublisher.publishEvent(event);
}
}
// Event listeners for cross-context integration
@Component
public class CrossContextEventListeners {
private final ContextIntegration.OrderEventsHandler orderEventsHandler;
private final CatalogContext.ProductRepository productRepository;
public CrossContextEventListeners(ContextIntegration.OrderEventsHandler orderEventsHandler,
CatalogContext.ProductRepository productRepository) {
this.orderEventsHandler = orderEventsHandler;
this.productRepository = productRepository;
}
@EventListener
public void handleOrderCreated(ContextIntegration.OrderCreatedEvent event) {
orderEventsHandler.handleOrderCreated(event);
}
@EventListener
public void handlePaymentCompleted(ContextIntegration.PaymentCompletedEvent event) {
orderEventsHandler.handlePaymentCompleted(event);
}
@EventListener
public void handleProductStockUpdated(ContextIntegration.ProductStockUpdatedEvent event) {
// Update read models or trigger other actions
System.out.println("Product stock updated: " + event.productId().value() + 
" from " + event.oldStock().value() + 
" to " + event.newStock().value());
}
}
// Message-based integration (Kafka example)
@Component
public class KafkaEventPublisher {
private final KafkaTemplate<String, Object> kafkaTemplate;
private final ObjectMapper objectMapper;
public KafkaEventPublisher(KafkaTemplate<String, Object> kafkaTemplate,
ObjectMapper objectMapper) {
this.kafkaTemplate = kafkaTemplate;
this.objectMapper = objectMapper;
}
public void publishToKafka(ContextIntegration.DomainEvent event) {
try {
String topic = "domain-events-" + event.eventType().toLowerCase();
String message = objectMapper.writeValueAsString(event);
kafkaTemplate.send(topic, event.eventId(), message)
.addCallback(
result -> logger.info("Event published successfully: {}", event.eventId()),
failure -> logger.error("Failed to publish event: {}", event.eventId(), failure)
);
} catch (Exception e) {
logger.error("Error publishing event to Kafka", e);
}
}
}
@Component
public class KafkaEventConsumer {
private final ContextIntegration.OrderEventsHandler orderEventsHandler;
public KafkaEventConsumer(ContextIntegration.OrderEventsHandler orderEventsHandler) {
this.orderEventsHandler = orderEventsHandler;
}
@KafkaListener(topics = "domain-events-order-created")
public void consumeOrderCreated(String message) {
try {
var event = objectMapper.readValue(message, ContextIntegration.OrderCreatedEvent.class);
orderEventsHandler.handleOrderCreated(event);
} catch (Exception e) {
logger.error("Error processing OrderCreated event", e);
}
}
}

Testing Strategies

9. Comprehensive Testing

// Unit tests for domain models
class OrderTests {
@Test
void shouldCreateOrderInDraftStatus() {
// Given
var orderId = new SharedKernel.OrderId("order-123");
var customerId = new SharedKernel.CustomerId("customer-456");
var address = new SharedKernel.Address("123 Main St", "City", "State", "12345", "US");
// When
var order = new OrderingContext.Order(orderId, customerId, address, address);
// Then
assertEquals(OrderingContext.OrderStatus.DRAFT, order.getStatus());
assertEquals(0, order.getItems().size());
assertEquals(BigDecimal.ZERO, order.getTotalAmount().amount());
}
@Test
void shouldAddItemToOrder() {
// Given
var order = createTestOrder();
var item = OrderingContext.OrderItem.create(
new CatalogContext.ProductId("product-1"),
"Test Product",
new SharedKernel.Money(new BigDecimal("29.99"), SharedKernel.Currency.USD),
2
);
// When
order.addItem(item);
// Then
assertEquals(1, order.getItems().size());
assertEquals(new BigDecimal("59.98"), order.getTotalAmount().amount());
}
@Test
void shouldNotAddItemToSubmittedOrder() {
// Given
var order = createTestOrder();
order.submit();
var item = OrderingContext.OrderItem.create(
new CatalogContext.ProductId("product-1"),
"Test Product",
new SharedKernel.Money(new BigDecimal("29.99"), SharedKernel.Currency.USD),
1
);
// When & Then
assertThrows(IllegalStateException.class, () -> order.addItem(item));
}
private OrderingContext.Order createTestOrder() {
var orderId = new SharedKernel.OrderId("order-123");
var customerId = new SharedKernel.CustomerId("customer-456");
var address = new SharedKernel.Address("123 Main St", "City", "State", "12345", "US");
return new OrderingContext.Order(orderId, customerId, address, address);
}
}
// Integration tests for context mapping
@SpringBootTest
class ContextIntegrationTests {
@Autowired
private OrderingContext.OrderRepository orderRepository;
@Autowired
private ContextIntegration.IdentityContextACL identityACL;
@Autowired
private ContextIntegration.CatalogContextACL catalogACL;
@Test
void shouldCreateOrderWithValidCustomerAndProducts() {
// Given
var customerId = new SharedKernel.CustomerId("valid-customer");
var productId = new CatalogContext.ProductId("valid-product");
// When & Then
assertDoesNotThrow(() -> {
identityACL.validateCustomerActive(customerId);
catalogACL.reserveProduct(productId, 1);
});
}
}
// Test doubles for isolated testing
class TestDoubles {
static class InMemoryUserRepository implements IdentityContext.UserRepository {
private final Map<IdentityContext.UserId, IdentityContext.User> users = new HashMap<>();
@Override
public Optional<IdentityContext.User> findById(IdentityContext.UserId id) {
return Optional.ofNullable(users.get(id));
}
@Override
public Optional<IdentityContext.User> findByEmail(String email) {
return users.values().stream()
.filter(user -> user.getEmail().equals(email))
.findFirst();
}
@Override
public void save(IdentityContext.User user) {
users.put(user.getId(), user);
}
@Override
public boolean existsByEmail(String email) {
return users.values().stream()
.anyMatch(user -> user.getEmail().equals(email));
}
}
static class InMemoryOrderRepository implements OrderingContext.OrderRepository {
private final Map<SharedKernel.OrderId, OrderingContext.Order> orders = new HashMap<>();
@Override
public Optional<OrderingContext.Order> findById(SharedKernel.OrderId id) {
return Optional.ofNullable(orders.get(id));
}
@Override
public List<OrderingContext.Order> findByCustomerId(SharedKernel.CustomerId customerId) {
return orders.values().stream()
.filter(order -> order.getCustomerId().equals(customerId))
.collect(Collectors.toList());
}
@Override
public List<OrderingContext.Order> findByStatus(OrderingContext.OrderStatus status) {
return orders.values().stream()
.filter(order -> order.getStatus() == status)
.collect(Collectors.toList());
}
@Override
public void save(OrderingContext.Order order) {
orders.put(order.getId(), order);
}
}
}

This comprehensive DDD Bounded Contexts implementation provides:

  • Clear context boundaries with explicit domain models
  • Strategic design patterns including ACL and domain events
  • Practical e-commerce case study with multiple contexts
  • Spring Boot integration for modern applications
  • Testing strategies for maintainable code
  • Communication patterns for context integration

The architecture ensures each bounded context can evolve independently while maintaining clear integration points and preserving domain integrity.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper