MACRO NEPAL
Application Service Layer in Java
awiskar acharya
November 8, 2025
1:56 pm

The Application Service Layer orchestrates business use cases, coordinates domain objects, and handles cross-cutting concerns like transactions and security. It sits between the presentation layer and domain layer.

Basic Application Service Structure

1. Service Interfaces and DTOs

// Common base interface for application services
public interface ApplicationService {
// Marker interface
}
// Result pattern for service responses
public class ServiceResult<T> {
private final boolean success;
private final T data;
private final String error;
private final List<ValidationError> validationErrors;
private ServiceResult(boolean success, T data, String error, List<ValidationError> validationErrors) {
this.success = success;
this.data = data;
this.error = error;
this.validationErrors = validationErrors != null ? new ArrayList<>(validationErrors) : new ArrayList<>();
}
// Factory methods
public static <T> ServiceResult<T> success(T data) {
return new ServiceResult<>(true, data, null, null);
}
public static <T> ServiceResult<T> error(String error) {
return new ServiceResult<>(false, null, error, null);
}
public static <T> ServiceResult<T> validationError(List<ValidationError> errors) {
return new ServiceResult<>(false, null, "Validation failed", errors);
}
// Getters
public boolean isSuccess() { return success; }
public T getData() { return data; }
public String getError() { return error; }
public List<ValidationError> getValidationErrors() { return Collections.unmodifiableList(validationErrors); }
}
// Validation error details
public class ValidationError {
private final String field;
private final String message;
private final String code;
public ValidationError(String field, String message, String code) {
this.field = field;
this.message = message;
this.code = code;
}
// Getters
public String getField() { return field; }
public String getMessage() { return message; }
public String getCode() { return code; }
}
// Pagination support
public class PaginatedResult<T> {
private final List<T> items;
private final int totalPages;
private final long totalItems;
private final int currentPage;
private final int pageSize;
public PaginatedResult(List<T> items, int totalPages, long totalItems, int currentPage, int pageSize) {
this.items = new ArrayList<>(items);
this.totalPages = totalPages;
this.totalItems = totalItems;
this.currentPage = currentPage;
this.pageSize = pageSize;
}
// Getters
public List<T> getItems() { return Collections.unmodifiableList(items); }
public int getTotalPages() { return totalPages; }
public long getTotalItems() { return totalItems; }
public int getCurrentPage() { return currentPage; }
public int getPageSize() { return pageSize; }
public boolean hasNext() { return currentPage < totalPages; }
public boolean hasPrevious() { return currentPage > 1; }
}

2. Customer Management Service

// DTOs for customer operations
public class CreateCustomerRequest {
private String email;
private String name;
private String street;
private String city;
private String state;
private String zipCode;
private String country;
// Constructors, getters, and setters
public CreateCustomerRequest() {}
public CreateCustomerRequest(String email, String name, String street, 
String city, String state, String zipCode, String country) {
this.email = email;
this.name = name;
this.street = street;
this.city = city;
this.state = state;
this.zipCode = zipCode;
this.country = country;
}
// Getters and setters
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getStreet() { return street; }
public void setStreet(String street) { this.street = street; }
public String getCity() { return city; }
public void setCity(String city) { this.city = city; }
public String getState() { return state; }
public void setState(String state) { this.state = state; }
public String getZipCode() { return zipCode; }
public void setZipCode(String zipCode) { this.zipCode = zipCode; }
public String getCountry() { return country; }
public void setCountry(String country) { this.country = country; }
}
public class CustomerResponse {
private final UUID id;
private final String email;
private final String name;
private final String status;
private final String address;
private final LocalDateTime createdAt;
private final double totalSpent;
public CustomerResponse(UUID id, String email, String name, String status,
String address, LocalDateTime createdAt, double totalSpent) {
this.id = id;
this.email = email;
this.name = name;
this.status = status;
this.address = address;
this.createdAt = createdAt;
this.totalSpent = totalSpent;
}
// Getters
public UUID getId() { return id; }
public String getEmail() { return email; }
public String getName() { return name; }
public String getStatus() { return status; }
public String getAddress() { return address; }
public LocalDateTime getCreatedAt() { return createdAt; }
public double getTotalSpent() { return totalSpent; }
}
// Customer service interface
public interface CustomerService extends ApplicationService {
ServiceResult<CustomerResponse> createCustomer(CreateCustomerRequest request);
ServiceResult<CustomerResponse> getCustomer(UUID customerId);
ServiceResult<CustomerResponse> updateCustomer(UUID customerId, UpdateCustomerRequest request);
ServiceResult<Void> deactivateCustomer(UUID customerId);
ServiceResult<Void> activateCustomer(UUID customerId);
ServiceResult<PaginatedResult<CustomerResponse>> searchCustomers(CustomerSearchCriteria criteria);
ServiceResult<List<OrderResponse>> getCustomerOrders(UUID customerId);
}
// Search criteria
public class CustomerSearchCriteria {
private String email;
private String name;
private String status;
private LocalDate createdAfter;
private LocalDate createdBefore;
private int page = 1;
private int size = 20;
private String sortBy = "createdAt";
private String sortDirection = "DESC";
// Constructors, getters, and setters
public CustomerSearchCriteria() {}
// Getters and setters
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
public LocalDate getCreatedAfter() { return createdAfter; }
public void setCreatedAfter(LocalDate createdAfter) { this.createdAfter = createdAfter; }
public LocalDate getCreatedBefore() { return createdBefore; }
public void setCreatedBefore(LocalDate createdBefore) { this.createdBefore = createdBefore; }
public int getPage() { return page; }
public void setPage(int page) { this.page = page; }
public int getSize() { return size; }
public void setSize(int size) { this.size = size; }
public String getSortBy() { return sortBy; }
public void setSortBy(String sortBy) { this.sortBy = sortBy; }
public String getSortDirection() { return sortDirection; }
public void setSortDirection(String sortDirection) { this.sortDirection = sortDirection; }
}

3. Customer Service Implementation

import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;
@Service
@Transactional
public class CustomerServiceImpl implements CustomerService {
private final CustomerRepository customerRepository;
private final OrderRepository orderRepository;
private final EmailService emailService;
private final EventPublisher eventPublisher;
public CustomerServiceImpl(CustomerRepository customerRepository,
OrderRepository orderRepository,
EmailService emailService,
EventPublisher eventPublisher) {
this.customerRepository = customerRepository;
this.orderRepository = orderRepository;
this.emailService = emailService;
this.eventPublisher = eventPublisher;
}
@Override
public ServiceResult<CustomerResponse> createCustomer(CreateCustomerRequest request) {
try {
// Validate request
List<ValidationError> validationErrors = validateCreateRequest(request);
if (!validationErrors.isEmpty()) {
return ServiceResult.validationError(validationErrors);
}
// Check for duplicate email
if (customerRepository.existsByEmail(request.getEmail())) {
return ServiceResult.error("Customer with this email already exists");
}
// Create address value object
Address address = Address.of(
request.getStreet(),
request.getCity(), 
request.getState(),
request.getZipCode(),
request.getCountry()
);
// Create customer entity
Customer customer = new Customer(request.getEmail(), request.getName(), address);
// Save customer
Customer savedCustomer = customerRepository.save(customer);
// Send welcome email (fire and forget)
emailService.sendWelcomeEmail(savedCustomer.getEmail(), savedCustomer.getName());
// Publish domain event
eventPublisher.publish(new CustomerCreatedEvent(savedCustomer.getId(), savedCustomer.getEmail()));
// Return response
CustomerResponse response = mapToCustomerResponse(savedCustomer);
return ServiceResult.success(response);
} catch (Exception e) {
// Log error
System.err.println("Error creating customer: " + e.getMessage());
return ServiceResult.error("Failed to create customer: " + e.getMessage());
}
}
@Override
public ServiceResult<CustomerResponse> getCustomer(UUID customerId) {
try {
Customer customer = customerRepository.findById(customerId)
.orElse(null);
if (customer == null) {
return ServiceResult.error("Customer not found");
}
CustomerResponse response = mapToCustomerResponse(customer);
return ServiceResult.success(response);
} catch (Exception e) {
System.err.println("Error retrieving customer: " + e.getMessage());
return ServiceResult.error("Failed to retrieve customer");
}
}
@Override
public ServiceResult<CustomerResponse> updateCustomer(UUID customerId, UpdateCustomerRequest request) {
try {
Customer customer = customerRepository.findById(customerId)
.orElse(null);
if (customer == null) {
return ServiceResult.error("Customer not found");
}
// Validate request
List<ValidationError> validationErrors = validateUpdateRequest(request);
if (!validationErrors.isEmpty()) {
return ServiceResult.validationError(validationErrors);
}
// Update customer
Address newAddress = Address.of(
request.getStreet(),
request.getCity(),
request.getState(), 
request.getZipCode(),
request.getCountry()
);
customer.updateProfile(request.getName(), newAddress);
// Save changes
Customer updatedCustomer = customerRepository.save(customer);
// Publish event
eventPublisher.publish(new CustomerUpdatedEvent(customerId));
CustomerResponse response = mapToCustomerResponse(updatedCustomer);
return ServiceResult.success(response);
} catch (Exception e) {
System.err.println("Error updating customer: " + e.getMessage());
return ServiceResult.error("Failed to update customer");
}
}
@Override
public ServiceResult<Void> deactivateCustomer(UUID customerId) {
try {
Customer customer = customerRepository.findById(customerId)
.orElse(null);
if (customer == null) {
return ServiceResult.error("Customer not found");
}
customer.deactivate();
customerRepository.save(customer);
eventPublisher.publish(new CustomerDeactivatedEvent(customerId));
return ServiceResult.success(null);
} catch (Exception e) {
System.err.println("Error deactivating customer: " + e.getMessage());
return ServiceResult.error("Failed to deactivate customer");
}
}
@Override
public ServiceResult<PaginatedResult<CustomerResponse>> searchCustomers(CustomerSearchCriteria criteria) {
try {
// Convert criteria to domain specification
CustomerSpecification spec = new CustomerSpecification(criteria);
// Get paginated results
Page<Customer> customerPage = customerRepository.findAll(spec, 
PageRequest.of(criteria.getPage() - 1, criteria.getSize(), 
getSort(criteria.getSortBy(), criteria.getSortDirection())));
// Map to responses
List<CustomerResponse> responses = customerPage.getContent().stream()
.map(this::mapToCustomerResponse)
.collect(Collectors.toList());
PaginatedResult<CustomerResponse> result = new PaginatedResult<>(
responses,
customerPage.getTotalPages(),
customerPage.getTotalElements(),
criteria.getPage(),
criteria.getSize()
);
return ServiceResult.success(result);
} catch (Exception e) {
System.err.println("Error searching customers: " + e.getMessage());
return ServiceResult.error("Failed to search customers");
}
}
@Override
public ServiceResult<List<OrderResponse>> getCustomerOrders(UUID customerId) {
try {
if (!customerRepository.existsById(customerId)) {
return ServiceResult.error("Customer not found");
}
List<Order> orders = orderRepository.findByCustomerId(customerId);
List<OrderResponse> responses = orders.stream()
.map(this::mapToOrderResponse)
.collect(Collectors.toList());
return ServiceResult.success(responses);
} catch (Exception e) {
System.err.println("Error retrieving customer orders: " + e.getMessage());
return ServiceResult.error("Failed to retrieve customer orders");
}
}
// Helper methods
private List<ValidationError> validateCreateRequest(CreateCustomerRequest request) {
List<ValidationError> errors = new ArrayList<>();
if (request.getEmail() == null || request.getEmail().trim().isEmpty()) {
errors.add(new ValidationError("email", "Email is required", "REQUIRED"));
} else if (!isValidEmail(request.getEmail())) {
errors.add(new ValidationError("email", "Invalid email format", "INVALID_FORMAT"));
}
if (request.getName() == null || request.getName().trim().isEmpty()) {
errors.add(new ValidationError("name", "Name is required", "REQUIRED"));
} else if (request.getName().trim().length() < 2) {
errors.add(new ValidationError("name", "Name must be at least 2 characters", "MIN_LENGTH"));
}
// Add more validations as needed
return errors;
}
private List<ValidationError> validateUpdateRequest(UpdateCustomerRequest request) {
List<ValidationError> errors = new ArrayList<>();
if (request.getName() != null && request.getName().trim().length() < 2) {
errors.add(new ValidationError("name", "Name must be at least 2 characters", "MIN_LENGTH"));
}
return errors;
}
private boolean isValidEmail(String email) {
return email != null && email.matches("^[A-Za-z0-9+_.-]+@(.+)$");
}
private Sort getSort(String sortBy, String sortDirection) {
Sort.Direction direction = "DESC".equalsIgnoreCase(sortDirection) ? 
Sort.Direction.DESC : Sort.Direction.ASC;
return Sort.by(direction, sortBy);
}
private CustomerResponse mapToCustomerResponse(Customer customer) {
return new CustomerResponse(
customer.getId(),
customer.getEmail(),
customer.getName(),
customer.getStatus().name(),
customer.getAddress().getFormattedAddress(),
customer.getCreatedAt(),
customer.getTotalSpent()
);
}
private OrderResponse mapToOrderResponse(Order order) {
return new OrderResponse(
order.getId(),
order.getStatus().name(),
order.getTotalAmount().getAmount(),
order.getCreatedAt()
);
}
}

Order Management Service

4. Order Service Implementation

// Order DTOs
public class CreateOrderRequest {
private UUID customerId;
private List<OrderItemRequest> items;
private String shippingInstructions;
// Constructors, getters, setters
public CreateOrderRequest() {}
public CreateOrderRequest(UUID customerId, List<OrderItemRequest> items) {
this.customerId = customerId;
this.items = items;
}
public UUID getCustomerId() { return customerId; }
public void setCustomerId(UUID customerId) { this.customerId = customerId; }
public List<OrderItemRequest> getItems() { return items; }
public void setItems(List<OrderItemRequest> items) { this.items = items; }
public String getShippingInstructions() { return shippingInstructions; }
public void setShippingInstructions(String shippingInstructions) { this.shippingInstructions = shippingInstructions; }
}
public class OrderItemRequest {
private UUID productId;
private int quantity;
// Constructors, getters, setters
public OrderItemRequest() {}
public OrderItemRequest(UUID productId, int quantity) {
this.productId = productId;
this.quantity = quantity;
}
public UUID getProductId() { return productId; }
public void setProductId(UUID productId) { this.productId = productId; }
public int getQuantity() { return quantity; }
public void setQuantity(int quantity) { this.quantity = quantity; }
}
public class OrderResponse {
private final UUID id;
private final UUID customerId;
private final String status;
private final BigDecimal totalAmount;
private final LocalDateTime createdAt;
private final List<OrderItemResponse> items;
public OrderResponse(UUID id, UUID customerId, String status, BigDecimal totalAmount,
LocalDateTime createdAt, List<OrderItemResponse> items) {
this.id = id;
this.customerId = customerId;
this.status = status;
this.totalAmount = totalAmount;
this.createdAt = createdAt;
this.items = items;
}
// Getters
public UUID getId() { return id; }
public UUID getCustomerId() { return customerId; }
public String getStatus() { return status; }
public BigDecimal getTotalAmount() { return totalAmount; }
public LocalDateTime getCreatedAt() { return createdAt; }
public List<OrderItemResponse> getItems() { return items; }
}
// Order service interface
public interface OrderService extends ApplicationService {
ServiceResult<OrderResponse> createOrder(CreateOrderRequest request);
ServiceResult<OrderResponse> getOrder(UUID orderId);
ServiceResult<OrderResponse> confirmOrder(UUID orderId);
ServiceResult<OrderResponse> cancelOrder(UUID orderId);
ServiceResult<OrderResponse> completeOrder(UUID orderId);
ServiceResult<PaginatedResult<OrderResponse>> getOrders(OrderSearchCriteria criteria);
}
@Service
@Transactional
public class OrderServiceImpl implements OrderService {
private final OrderRepository orderRepository;
private final CustomerRepository customerRepository;
private final ProductRepository productRepository;
private final InventoryService inventoryService;
private final PaymentService paymentService;
private final EventPublisher eventPublisher;
private final DomainMapper domainMapper;
public OrderServiceImpl(OrderRepository orderRepository,
CustomerRepository customerRepository,
ProductRepository productRepository,
InventoryService inventoryService,
PaymentService paymentService,
EventPublisher eventPublisher,
DomainMapper domainMapper) {
this.orderRepository = orderRepository;
this.customerRepository = customerRepository;
this.productRepository = productRepository;
this.inventoryService = inventoryService;
this.paymentService = paymentService;
this.eventPublisher = eventPublisher;
this.domainMapper = domainMapper;
}
@Override
public ServiceResult<OrderResponse> createOrder(CreateOrderRequest request) {
try {
// Validate request
List<ValidationError> validationErrors = validateOrderRequest(request);
if (!validationErrors.isEmpty()) {
return ServiceResult.validationError(validationErrors);
}
// Find customer
Customer customer = customerRepository.findById(request.getCustomerId())
.orElse(null);
if (customer == null) {
return ServiceResult.error("Customer not found");
}
// Check if customer can place orders
if (!customer.canPlaceOrder()) {
return ServiceResult.error("Customer cannot place orders at this time");
}
// Process order items
Set<OrderItem> orderItems = processOrderItems(request.getItems());
if (orderItems.isEmpty()) {
return ServiceResult.error("No valid order items");
}
// Create order
Order order = new Order(customer, orderItems);
// Apply shipping instructions if provided
if (request.getShippingInstructions() != null) {
ShippingAddress shippingAddress = order.getShippingAddress()
.withInstructions(request.getShippingInstructions());
order.updateShippingAddress(shippingAddress);
}
// Save order
Order savedOrder = orderRepository.save(order);
// Reserve inventory
inventoryService.reserveInventory(savedOrder.getId(), request.getItems());
// Publish event
eventPublisher.publish(new OrderCreatedEvent(savedOrder.getId(), customer.getId()));
// Map to response
OrderResponse response = domainMapper.toOrderResponse(savedOrder);
return ServiceResult.success(response);
} catch (Exception e) {
System.err.println("Error creating order: " + e.getMessage());
return ServiceResult.error("Failed to create order: " + e.getMessage());
}
}
@Override
public ServiceResult<OrderResponse> confirmOrder(UUID orderId) {
try {
Order order = orderRepository.findById(orderId)
.orElse(null);
if (order == null) {
return ServiceResult.error("Order not found");
}
// Process payment
PaymentResult paymentResult = paymentService.processPayment(orderId, order.getTotalAmount());
if (!paymentResult.isSuccess()) {
return ServiceResult.error("Payment failed: " + paymentResult.getErrorMessage());
}
// Confirm order
order.confirm();
Order updatedOrder = orderRepository.save(order);
// Update inventory
inventoryService.allocateInventory(orderId);
// Publish event
eventPublisher.publish(new OrderConfirmedEvent(orderId));
OrderResponse response = domainMapper.toOrderResponse(updatedOrder);
return ServiceResult.success(response);
} catch (Exception e) {
System.err.println("Error confirming order: " + e.getMessage());
return ServiceResult.error("Failed to confirm order");
}
}
@Override
public ServiceResult<OrderResponse> cancelOrder(UUID orderId) {
try {
Order order = orderRepository.findById(orderId)
.orElse(null);
if (order == null) {
return ServiceResult.error("Order not found");
}
// Cancel order
order.cancel();
Order updatedOrder = orderRepository.save(order);
// Release inventory
inventoryService.releaseInventory(orderId);
// Refund payment if already processed
if (order.getStatus() == OrderStatus.CONFIRMED) {
paymentService.refundPayment(orderId);
}
// Publish event
eventPublisher.publish(new OrderCancelledEvent(orderId));
OrderResponse response = domainMapper.toOrderResponse(updatedOrder);
return ServiceResult.success(response);
} catch (Exception e) {
System.err.println("Error cancelling order: " + e.getMessage());
return ServiceResult.error("Failed to cancel order");
}
}
// Helper methods
private Set<OrderItem> processOrderItems(List<OrderItemRequest> itemRequests) {
Set<OrderItem> orderItems = new HashSet<>();
for (OrderItemRequest itemRequest : itemRequests) {
Product product = productRepository.findById(itemRequest.getProductId())
.orElse(null);
if (product == null || !product.isAvailable()) {
continue; // Skip unavailable products
}
if (!product.canFulfillOrder(itemRequest.getQuantity())) {
continue; // Skip if insufficient stock
}
OrderItem orderItem = new OrderItem(
product.getId(),
product.getName(),
product.getPrice(),
itemRequest.getQuantity()
);
orderItems.add(orderItem);
}
return orderItems;
}
private List<ValidationError> validateOrderRequest(CreateOrderRequest request) {
List<ValidationError> errors = new ArrayList<>();
if (request.getCustomerId() == null) {
errors.add(new ValidationError("customerId", "Customer ID is required", "REQUIRED"));
}
if (request.getItems() == null || request.getItems().isEmpty()) {
errors.add(new ValidationError("items", "At least one order item is required", "REQUIRED"));
} else {
for (int i = 0; i < request.getItems().size(); i++) {
OrderItemRequest item = request.getItems().get(i);
if (item.getProductId() == null) {
errors.add(new ValidationError("items[" + i + "].productId", "Product ID is required", "REQUIRED"));
}
if (item.getQuantity() <= 0) {
errors.add(new ValidationError("items[" + i + "].quantity", "Quantity must be positive", "INVALID"));
}
}
}
return errors;
}
}

Advanced Service Patterns

5. CQRS with Query Services

// Query service for read operations
public interface CustomerQueryService extends ApplicationService {
ServiceResult<CustomerDetailResponse> getCustomerDetail(UUID customerId);
ServiceResult<PaginatedResult<CustomerSummaryResponse>> getCustomerSummaries(CustomerSearchCriteria criteria);
ServiceResult<CustomerStatisticsResponse> getCustomerStatistics(UUID customerId);
}
@Service
@Transactional(readOnly = true)
public class CustomerQueryServiceImpl implements CustomerQueryService {
private final CustomerReadRepository customerReadRepository;
private final OrderReadRepository orderReadRepository;
public CustomerQueryServiceImpl(CustomerReadRepository customerReadRepository,
OrderReadRepository orderReadRepository) {
this.customerReadRepository = customerReadRepository;
this.orderReadRepository = orderReadRepository;
}
@Override
public ServiceResult<CustomerDetailResponse> getCustomerDetail(UUID customerId) {
try {
CustomerDetailProjection customerDetail = customerReadRepository.findDetailById(customerId);
if (customerDetail == null) {
return ServiceResult.error("Customer not found");
}
List<OrderSummaryProjection> recentOrders = orderReadRepository.findRecentOrdersByCustomerId(customerId, 10);
CustomerDetailResponse response = mapToDetailResponse(customerDetail, recentOrders);
return ServiceResult.success(response);
} catch (Exception e) {
System.err.println("Error retrieving customer detail: " + e.getMessage());
return ServiceResult.error("Failed to retrieve customer details");
}
}
@Override
public ServiceResult<PaginatedResult<CustomerSummaryResponse>> getCustomerSummaries(CustomerSearchCriteria criteria) {
try {
Page<CustomerSummaryProjection> summaryPage = customerReadRepository.findSummaries(
criteria.getEmail(),
criteria.getName(),
criteria.getStatus(),
PageRequest.of(criteria.getPage() - 1, criteria.getSize())
);
List<CustomerSummaryResponse> responses = summaryPage.getContent().stream()
.map(this::mapToSummaryResponse)
.collect(Collectors.toList());
PaginatedResult<CustomerSummaryResponse> result = new PaginatedResult<>(
responses,
summaryPage.getTotalPages(),
summaryPage.getTotalElements(),
criteria.getPage(),
criteria.getSize()
);
return ServiceResult.success(result);
} catch (Exception e) {
System.err.println("Error retrieving customer summaries: " + e.getMessage());
return ServiceResult.error("Failed to retrieve customer summaries");
}
}
@Override
public ServiceResult<CustomerStatisticsResponse> getCustomerStatistics(UUID customerId) {
try {
CustomerStatistics stats = customerReadRepository.findStatisticsById(customerId);
if (stats == null) {
return ServiceResult.error("Customer not found");
}
CustomerStatisticsResponse response = new CustomerStatisticsResponse(
stats.getTotalOrders(),
stats.getTotalSpent(),
stats.getAverageOrderValue(),
stats.getLastOrderDate(),
stats.getFavoriteCategory()
);
return ServiceResult.success(response);
} catch (Exception e) {
System.err.println("Error retrieving customer statistics: " + e.getMessage());
return ServiceResult.error("Failed to retrieve customer statistics");
}
}
// Mapping methods
private CustomerDetailResponse mapToDetailResponse(CustomerDetailProjection detail, 
List<OrderSummaryProjection> recentOrders) {
return new CustomerDetailResponse(
detail.getId(),
detail.getEmail(),
detail.getName(),
detail.getStatus(),
detail.getAddress(),
detail.getCreatedAt(),
detail.getTotalSpent(),
recentOrders.stream()
.map(this::mapToOrderSummaryResponse)
.collect(Collectors.toList())
);
}
private CustomerSummaryResponse mapToSummaryResponse(CustomerSummaryProjection summary) {
return new CustomerSummaryResponse(
summary.getId(),
summary.getEmail(),
summary.getName(),
summary.getStatus(),
summary.getTotalOrders(),
summary.getTotalSpent(),
summary.getLastOrderDate()
);
}
private OrderSummaryResponse mapToOrderSummaryResponse(OrderSummaryProjection order) {
return new OrderSummaryResponse(
order.getId(),
order.getStatus(),
order.getTotalAmount(),
order.getCreatedAt()
);
}
}

6. Service Decorators for Cross-Cutting Concerns

// Logging decorator
@Component
@Primary
public class LoggingCustomerServiceDecorator implements CustomerService {
private final CustomerService delegate;
private final Logger logger = LoggerFactory.getLogger(LoggingCustomerServiceDecorator.class);
public LoggingCustomerServiceDecorator(CustomerService delegate) {
this.delegate = delegate;
}
@Override
public ServiceResult<CustomerResponse> createCustomer(CreateCustomerRequest request) {
logger.info("Creating customer with email: {}", request.getEmail());
long startTime = System.currentTimeMillis();
try {
ServiceResult<CustomerResponse> result = delegate.createCustomer(request);
long duration = System.currentTimeMillis() - startTime;
if (result.isSuccess()) {
logger.info("Customer created successfully in {} ms", duration);
} else {
logger.warn("Customer creation failed in {} ms: {}", duration, result.getError());
}
return result;
} catch (Exception e) {
logger.error("Unexpected error creating customer", e);
throw e;
}
}
// Implement other methods with similar logging...
}
// Caching decorator
@Component
@Order(1)
public class CachingCustomerServiceDecorator implements CustomerService {
private final CustomerService delegate;
private final CacheManager cacheManager;
public CachingCustomerServiceDecorator(CustomerService delegate, CacheManager cacheManager) {
this.delegate = delegate;
this.cacheManager = cacheManager;
}
@Override
public ServiceResult<CustomerResponse> getCustomer(UUID customerId) {
String cacheKey = "customer:" + customerId;
Cache cache = cacheManager.getCache("customers");
// Try cache first
CustomerResponse cached = cache.get(cacheKey, CustomerResponse.class);
if (cached != null) {
return ServiceResult.success(cached);
}
// Delegate to actual service
ServiceResult<CustomerResponse> result = delegate.getCustomer(customerId);
// Cache successful results
if (result.isSuccess()) {
cache.put(cacheKey, result.getData());
}
return result;
}
@Override
public ServiceResult<CustomerResponse> updateCustomer(UUID customerId, UpdateCustomerRequest request) {
ServiceResult<CustomerResponse> result = delegate.updateCustomer(customerId, request);
// Evict cache on update
if (result.isSuccess()) {
Cache cache = cacheManager.getCache("customers");
cache.evict("customer:" + customerId);
}
return result;
}
// Implement other methods...
}
// Validation decorator
@Component
@Order(2)
public class ValidationCustomerServiceDecorator implements CustomerService {
private final CustomerService delegate;
private final Validator validator;
public ValidationCustomerServiceDecorator(CustomerService delegate, Validator validator) {
this.delegate = delegate;
this.validator = validator;
}
@Override
public ServiceResult<CustomerResponse> createCustomer(CreateCustomerRequest request) {
// Perform JSR-303 validation
Set<ConstraintViolation<CreateCustomerRequest>> violations = validator.validate(request);
if (!violations.isEmpty()) {
List<ValidationError> errors = violations.stream()
.map(v -> new ValidationError(
v.getPropertyPath().toString(),
v.getMessage(),
v.getConstraintDescriptor().getAnnotation().annotationType().getSimpleName()
))
.collect(Collectors.toList());
return ServiceResult.validationError(errors);
}
return delegate.createCustomer(request);
}
// Implement other methods...
}

Service Configuration and Testing

7. Service Configuration

@Configuration
public class ServiceConfiguration {
@Bean
@Primary
public CustomerService customerService(CustomerRepository customerRepository,
OrderRepository orderRepository,
EmailService emailService,
EventPublisher eventPublisher) {
CustomerService coreService = new CustomerServiceImpl(
customerRepository, orderRepository, emailService, eventPublisher);
// Wrap with decorators
return new ValidationCustomerServiceDecorator(
new CachingCustomerServiceDecorator(
new LoggingCustomerServiceDecorator(coreService),
cacheManager()
),
validator()
);
}
@Bean
public CacheManager cacheManager() {
return new ConcurrentMapCacheManager("customers", "orders");
}
@Bean
public Validator validator() {
return Validation.buildDefaultValidatorFactory().getValidator();
}
}

8. Service Testing

@ExtendWith(MockitoExtension.class)
class CustomerServiceImplTest {
@Mock
private CustomerRepository customerRepository;
@Mock
private OrderRepository orderRepository;
@Mock
private EmailService emailService;
@Mock
private EventPublisher eventPublisher;
@InjectMocks
private CustomerServiceImpl customerService;
@Test
void createCustomer_WithValidRequest_ShouldReturnSuccess() {
// Arrange
CreateCustomerRequest request = new CreateCustomerRequest(
"[email protected]", 
"John Doe",
"123 Main St", "Springfield", "IL", "62701", "US"
);
when(customerRepository.existsByEmail("[email protected]")).thenReturn(false);
when(customerRepository.save(any(Customer.class))).thenAnswer(invocation -> {
Customer customer = invocation.getArgument(0);
return customer; // Simulate saved entity
});
// Act
ServiceResult<CustomerResponse> result = customerService.createCustomer(request);
// Assert
assertTrue(result.isSuccess());
assertNotNull(result.getData());
assertEquals("[email protected]", result.getData().getEmail());
verify(customerRepository).save(any(Customer.class));
verify(emailService).sendWelcomeEmail(eq("[email protected]"), anyString());
verify(eventPublisher).publish(any(CustomerCreatedEvent.class));
}
@Test
void createCustomer_WithDuplicateEmail_ShouldReturnError() {
// Arrange
CreateCustomerRequest request = new CreateCustomerRequest(
"[email protected]", "John Doe", 
"123 Main St", "Springfield", "IL", "62701", "US"
);
when(customerRepository.existsByEmail("[email protected]")).thenReturn(true);
// Act
ServiceResult<CustomerResponse> result = customerService.createCustomer(request);
// Assert
assertFalse(result.isSuccess());
assertEquals("Customer with this email already exists", result.getError());
verify(customerRepository, never()).save(any(Customer.class));
}
@Test
void getCustomer_WithExistingId_ShouldReturnCustomer() {
// Arrange
UUID customerId = UUID.randomUUID();
Customer customer = createTestCustomer(customerId);
when(customerRepository.findById(customerId)).thenReturn(Optional.of(customer));
// Act
ServiceResult<CustomerResponse> result = customerService.getCustomer(customerId);
// Assert
assertTrue(result.isSuccess());
assertEquals(customerId, result.getData().getId());
assertEquals("[email protected]", result.getData().getEmail());
}
@Test
void getCustomer_WithNonExistingId_ShouldReturnError() {
// Arrange
UUID customerId = UUID.randomUUID();
when(customerRepository.findById(customerId)).thenReturn(Optional.empty());
// Act
ServiceResult<CustomerResponse> result = customerService.getCustomer(customerId);
// Assert
assertFalse(result.isSuccess());
assertEquals("Customer not found", result.getError());
}
private Customer createTestCustomer(UUID id) {
Address address = Address.of("123 Main St", "Springfield", "IL", "62701", "US");
return new Customer(id, "[email protected]", "John Doe", address, 
CustomerStatus.ACTIVE, new HashSet<>(), 
LocalDateTime.now(), LocalDateTime.now());
}
}

Key Benefits of Application Service Layer

  1. Use Case Orchestration: Coordinates multiple domain objects to fulfill business use cases
  2. Transaction Management: Handles transaction boundaries appropriately
  3. Cross-Cutting Concerns: Centralizes security, logging, validation, and caching
  4. Presentation Layer Abstraction: Shields presentation layer from domain complexity
  5. Testability: Services can be easily unit tested with mocked dependencies
  6. Command-Query Separation: Separate services for commands and queries
  7. Error Handling: Consistent error handling and response patterns

The Application Service Layer provides a clean, maintainable way to implement business use cases while keeping the domain model focused on business logic and rules.

Category : JAVA

Leave a Reply

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


Macro Nepal Helper