[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":88,"_72":89,"_35":90},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":16,"_62":63,"_64":65,"_66":67,"_68":69,"_70":71},"id",25,"title","Clean Code in Spring Boot","slug","clean-code-part-24-spring-boot","excerpt","Apply clean architecture patterns to Spring Boot: layered architecture, dependency injection best practices, and avoiding common Spring anti-patterns.","# Advanced Clean Code Patterns Part 24: Clean Code in Spring Boot\n\nSpring Boot enables rapid development but can lead to messy code if not used thoughtfully. This article covers clean architecture patterns specifically for Spring Boot applications: layered architecture, dependency injection best practices, and avoiding common Spring anti-patterns.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Focus | Spring Boot 3.x clean code patterns |\n| Architecture | Layered (Controller → Service → Repository) |\n| Key Principles | Constructor injection, thin controllers, rich domain |\n| Common Issues | God services, anemic domain, circular dependencies |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Clean layered architecture** in Spring Boot\n- **Dependency injection** best practices\n- **Configuration** patterns\n- **Common anti-patterns** and fixes\n- **Testing** strategies for Spring applications\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Clean Controller Layer\n\n```java\n// ❌ Fat controller - business logic in controller\n@RestController\n@RequestMapping(\"/api/orders\")\npublic class BadOrderController {\n\n @Autowired\n private OrderRepository orderRepository;\n @Autowired\n private CustomerRepository customerRepository;\n @Autowired\n private InventoryService inventoryService;\n @Autowired\n private PaymentService paymentService;\n @Autowired\n private EmailService emailService;\n\n @PostMapping\n public ResponseEntity createOrder(@RequestBody Map request) {\n // 100 lines of business logic in controller!\n Long customerId = (Long) request.get(\"customerId\");\n Customer customer = customerRepository.findById(customerId).orElseThrow();\n\n // Validation\n if (customer.getStatus() != Status.ACTIVE) {\n return ResponseEntity.badRequest().body(\"Customer inactive\");\n }\n\n // Business logic\n List> items = (List) request.get(\"items\");\n BigDecimal total = BigDecimal.ZERO;\n for (Map item : items) {\n // ... lots more code\n }\n\n // This is a mess!\n }\n}\n\n// ✅ Thin controller - delegates to service\n@RestController\n@RequestMapping(\"/api/orders\")\n@RequiredArgsConstructor\npublic class OrderController {\n\n private final OrderService orderService;\n\n @PostMapping\n public ResponseEntity createOrder(\n @Valid @RequestBody CreateOrderRequest request) {\n Order order = orderService.createOrder(request);\n return ResponseEntity\n .status(HttpStatus.CREATED)\n .body(OrderResponse.from(order));\n }\n\n @GetMapping(\"/{id}\")\n public ResponseEntity getOrder(@PathVariable Long id) {\n return orderService.findById(id)\n .map(OrderResponse::from)\n .map(ResponseEntity::ok)\n .orElse(ResponseEntity.notFound().build());\n }\n\n @GetMapping\n public Page listOrders(\n @RequestParam(defaultValue = \"0\") int page,\n @RequestParam(defaultValue = \"20\") int size,\n @RequestParam(required = false) OrderStatus status) {\n return orderService.findAll(PageRequest.of(page, size), status)\n .map(OrderResponse::from);\n }\n}\n```\n\n---\n\n### Pattern 2: Clean Service Layer\n\n```java\n// ✅ Service with single responsibility\n\n@Service\n@RequiredArgsConstructor\n@Transactional(readOnly = true)\npublic class OrderService {\n\n private final OrderRepository orderRepository;\n private final OrderValidator orderValidator;\n private final OrderPricingService pricingService;\n private final InventoryService inventoryService;\n private final OrderEventPublisher eventPublisher;\n\n @Transactional\n public Order createOrder(CreateOrderRequest request) {\n // Validate\n orderValidator.validate(request);\n\n // Reserve inventory\n ReservationResult reservation = inventoryService.reserve(request.items());\n\n // Calculate pricing\n OrderPricing pricing = pricingService.calculate(request, reservation);\n\n // Create order\n Order order = Order.builder()\n .customerId(request.customerId())\n .items(mapItems(request.items(), reservation))\n .subtotal(pricing.subtotal())\n .tax(pricing.tax())\n .total(pricing.total())\n .status(OrderStatus.PENDING)\n .build();\n\n Order saved = orderRepository.save(order);\n\n // Publish event\n eventPublisher.publish(new OrderCreatedEvent(saved));\n\n return saved;\n }\n\n public Optional findById(Long id) {\n return orderRepository.findById(id);\n }\n\n public Page findAll(Pageable pageable, OrderStatus status) {\n if (status != null) {\n return orderRepository.findByStatus(status, pageable);\n }\n return orderRepository.findAll(pageable);\n }\n}\n\n// Separate services for separate concerns\n@Service\n@RequiredArgsConstructor\npublic class OrderPricingService {\n\n private final TaxService taxService;\n private final DiscountService discountService;\n\n public OrderPricing calculate(CreateOrderRequest request, ReservationResult reservation) {\n BigDecimal subtotal = calculateSubtotal(reservation);\n BigDecimal discount = discountService.calculateDiscount(request, subtotal);\n BigDecimal taxableAmount = subtotal.subtract(discount);\n BigDecimal tax = taxService.calculateTax(taxableAmount, request.shippingAddress());\n BigDecimal total = taxableAmount.add(tax);\n\n return new OrderPricing(subtotal, discount, tax, total);\n }\n}\n```\n\n---\n\n### Pattern 3: Constructor Injection\n\n```java\n// ❌ Field injection - hidden dependencies, harder to test\n@Service\npublic class BadService {\n @Autowired\n private OrderRepository orderRepository;\n @Autowired\n private CustomerRepository customerRepository;\n @Autowired\n private EmailService emailService;\n}\n\n// ✅ Constructor injection - explicit dependencies\n@Service\npublic class GoodService {\n\n private final OrderRepository orderRepository;\n private final CustomerRepository customerRepository;\n private final EmailService emailService;\n\n // @Autowired not needed for single constructor (Spring 4.3+)\n public GoodService(OrderRepository orderRepository,\n CustomerRepository customerRepository,\n EmailService emailService) {\n this.orderRepository = orderRepository;\n this.customerRepository = customerRepository;\n this.emailService = emailService;\n }\n}\n\n// ✅ Even cleaner with Lombok\n@Service\n@RequiredArgsConstructor // Generates constructor for final fields\npublic class CleanService {\n\n private final OrderRepository orderRepository;\n private final CustomerRepository customerRepository;\n private final EmailService emailService;\n}\n\n// Benefits:\n// 1. Dependencies are explicit\n// 2. Fields can be final (immutable)\n// 3. Easy to test (just pass mocks to constructor)\n// 4. Reveals design problems (too many dependencies = too many responsibilities)\n```\n\n---\n\n### Pattern 4: Configuration Classes\n\n```java\n// ✅ Type-safe configuration with @ConfigurationProperties\n\n@ConfigurationProperties(prefix = \"app.payment\")\n@Validated\npublic record PaymentConfig(\n @NotBlank String apiKey,\n @NotBlank String apiSecret,\n @NotNull URI baseUrl,\n @Min(1) @Max(10) int maxRetries,\n @NotNull Duration timeout,\n @NotNull RateLimitConfig rateLimit\n) {\n public record RateLimitConfig(\n @Min(1) int requestsPerSecond,\n @Min(1) int burstSize\n ) {}\n}\n\n// application.yml\n// app:\n// payment:\n// api-key: ${PAYMENT_API_KEY}\n// api-secret: ${PAYMENT_API_SECRET}\n// base-url: https://api.payment.com\n// max-retries: 3\n// timeout: 30s\n// rate-limit:\n// requests-per-second: 100\n// burst-size: 150\n\n// Enable configuration properties\n@Configuration\n@EnableConfigurationProperties(PaymentConfig.class)\npublic class PaymentConfiguration {\n\n @Bean\n public PaymentClient paymentClient(PaymentConfig config) {\n return PaymentClient.builder()\n .apiKey(config.apiKey())\n .apiSecret(config.apiSecret())\n .baseUrl(config.baseUrl())\n .timeout(config.timeout())\n .maxRetries(config.maxRetries())\n .build();\n }\n\n @Bean\n public RateLimiter paymentRateLimiter(PaymentConfig config) {\n return RateLimiter.builder()\n .requestsPerSecond(config.rateLimit().requestsPerSecond())\n .burstSize(config.rateLimit().burstSize())\n .build();\n }\n}\n\n// Usage - inject config where needed\n@Service\n@RequiredArgsConstructor\npublic class PaymentService {\n\n private final PaymentClient client;\n private final PaymentConfig config; // Inject config if needed\n\n public PaymentResult process(Payment payment) {\n // Use client configured with correct settings\n return client.charge(payment);\n }\n}\n```\n\n---\n\n### Pattern 5: Repository Pattern\n\n```java\n// ✅ Clean repository with custom queries\n\npublic interface OrderRepository extends JpaRepository {\n\n // Spring Data query derivation\n List findByCustomerIdOrderByCreatedAtDesc(Long customerId);\n\n Page findByStatus(OrderStatus status, Pageable pageable);\n\n Optional findByIdAndCustomerId(Long id, Long customerId);\n\n // Custom JPQL\n @Query(\"SELECT o FROM Order o WHERE o.createdAt >= :since AND o.status = :status\")\n List findRecentByStatus(\n @Param(\"since\") LocalDateTime since,\n @Param(\"status\") OrderStatus status);\n\n // Native SQL for complex queries\n @Query(value = \"\"\"\n SELECT o.* FROM orders o\n JOIN customers c ON o.customer_id = c.id\n WHERE c.tier = :tier\n AND o.total > :minTotal\n AND o.created_at >= :since\n ORDER BY o.total DESC\n \"\"\", nativeQuery = true)\n List findHighValueOrdersByCustomerTier(\n @Param(\"tier\") String tier,\n @Param(\"minTotal\") BigDecimal minTotal,\n @Param(\"since\") LocalDateTime since);\n\n // Projections for read-only data\n @Query(\"SELECT new com.example.dto.OrderSummary(o.id, o.status, o.total) FROM Order o WHERE o.customerId = :customerId\")\n List findSummariesByCustomerId(@Param(\"customerId\") Long customerId);\n\n // Modifying queries\n @Modifying\n @Query(\"UPDATE Order o SET o.status = :status WHERE o.id = :id\")\n int updateStatus(@Param(\"id\") Long id, @Param(\"status\") OrderStatus status);\n}\n\n// Custom repository implementation for complex logic\npublic interface OrderRepositoryCustom {\n List searchOrders(OrderSearchCriteria criteria);\n}\n\n@Repository\n@RequiredArgsConstructor\npublic class OrderRepositoryCustomImpl implements OrderRepositoryCustom {\n\n private final EntityManager entityManager;\n\n @Override\n public List searchOrders(OrderSearchCriteria criteria) {\n CriteriaBuilder cb = entityManager.getCriteriaBuilder();\n CriteriaQuery query = cb.createQuery(Order.class);\n Root order = query.from(Order.class);\n\n List predicates = new ArrayList<>();\n\n if (criteria.customerId() != null) {\n predicates.add(cb.equal(order.get(\"customerId\"), criteria.customerId()));\n }\n if (criteria.status() != null) {\n predicates.add(cb.equal(order.get(\"status\"), criteria.status()));\n }\n if (criteria.minTotal() != null) {\n predicates.add(cb.greaterThanOrEqualTo(order.get(\"total\"), criteria.minTotal()));\n }\n\n query.where(predicates.toArray(new Predicate[0]));\n query.orderBy(cb.desc(order.get(\"createdAt\")));\n\n return entityManager.createQuery(query)\n .setMaxResults(criteria.limit())\n .getResultList();\n }\n}\n```\n\n---\n\n### Pattern 6: Event-Driven Communication\n\n```java\n// ✅ Decouple services with events\n\n// Event\npublic record OrderCreatedEvent(\n Long orderId,\n Long customerId,\n BigDecimal total,\n Instant createdAt\n) {}\n\n// Publisher\n@Component\n@RequiredArgsConstructor\npublic class OrderEventPublisher {\n\n private final ApplicationEventPublisher eventPublisher;\n\n public void publish(OrderCreatedEvent event) {\n eventPublisher.publishEvent(event);\n }\n}\n\n// Listeners - decoupled from order creation\n@Component\n@RequiredArgsConstructor\npublic class OrderEmailListener {\n\n private final EmailService emailService;\n private final CustomerRepository customerRepository;\n\n @EventListener\n @Async\n public void handleOrderCreated(OrderCreatedEvent event) {\n Customer customer = customerRepository.findById(event.customerId())\n .orElseThrow();\n emailService.sendOrderConfirmation(customer.getEmail(), event);\n }\n}\n\n@Component\n@RequiredArgsConstructor\npublic class OrderAnalyticsListener {\n\n private final AnalyticsService analyticsService;\n\n @EventListener\n @Async\n public void handleOrderCreated(OrderCreatedEvent event) {\n analyticsService.trackOrder(event);\n }\n}\n\n@Component\n@RequiredArgsConstructor\npublic class InventoryListener {\n\n private final InventoryService inventoryService;\n\n @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)\n public void handleOrderCreated(OrderCreatedEvent event) {\n // Only commit inventory after order transaction commits\n inventoryService.confirmReservation(event.orderId());\n }\n}\n```\n\n---\n\n### Pattern 7: Clean Exception Handling\n\n```java\n// ✅ Centralized exception handling\n\n@RestControllerAdvice\n@Slf4j\npublic class GlobalExceptionHandler {\n\n @ExceptionHandler(EntityNotFoundException.class)\n public ProblemDetail handleNotFound(EntityNotFoundException ex) {\n log.warn(\"Entity not found: {}\", ex.getMessage());\n return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());\n }\n\n @ExceptionHandler(BusinessException.class)\n public ProblemDetail handleBusinessException(BusinessException ex) {\n log.warn(\"Business rule violation: {}\", ex.getMessage());\n ProblemDetail problem = ProblemDetail.forStatusAndDetail(\n ex.getHttpStatus(), ex.getMessage());\n problem.setProperty(\"errorCode\", ex.getErrorCode());\n return problem;\n }\n\n @ExceptionHandler(MethodArgumentNotValidException.class)\n public ProblemDetail handleValidation(MethodArgumentNotValidException ex) {\n List> errors = ex.getBindingResult()\n .getFieldErrors()\n .stream()\n .map(e -> Map.of(\"field\", e.getField(), \"message\", e.getDefaultMessage()))\n .toList();\n\n ProblemDetail problem = ProblemDetail.forStatusAndDetail(\n HttpStatus.BAD_REQUEST, \"Validation failed\");\n problem.setProperty(\"errors\", errors);\n return problem;\n }\n\n @ExceptionHandler(Exception.class)\n public ProblemDetail handleUnexpected(Exception ex) {\n log.error(\"Unexpected error\", ex);\n return ProblemDetail.forStatusAndDetail(\n HttpStatus.INTERNAL_SERVER_ERROR,\n \"An unexpected error occurred\");\n }\n}\n\n// Custom business exceptions\npublic abstract class BusinessException extends RuntimeException {\n public abstract String getErrorCode();\n public abstract HttpStatus getHttpStatus();\n\n protected BusinessException(String message) {\n super(message);\n }\n}\n\npublic class OrderNotFoundException extends BusinessException {\n public OrderNotFoundException(Long id) {\n super(\"Order not found: \" + id);\n }\n\n @Override\n public String getErrorCode() { return \"ORDER_NOT_FOUND\"; }\n\n @Override\n public HttpStatus getHttpStatus() { return HttpStatus.NOT_FOUND; }\n}\n```\n\n---\n\n### Pattern 8: Testing Spring Applications\n\n```java\n// ✅ Unit tests - no Spring context\n@ExtendWith(MockitoExtension.class)\nclass OrderServiceTest {\n\n @Mock\n private OrderRepository orderRepository;\n @Mock\n private OrderValidator orderValidator;\n @Mock\n private InventoryService inventoryService;\n\n @InjectMocks\n private OrderService orderService;\n\n @Test\n void createOrder_savesOrder() {\n CreateOrderRequest request = createValidRequest();\n when(inventoryService.reserve(any())).thenReturn(reservationResult());\n when(orderRepository.save(any())).thenAnswer(inv -> {\n Order order = inv.getArgument(0);\n return order.toBuilder().id(1L).build();\n });\n\n Order result = orderService.createOrder(request);\n\n assertNotNull(result.getId());\n verify(orderRepository).save(any());\n }\n}\n\n// ✅ Integration tests - with Spring context\n@SpringBootTest\n@Transactional\nclass OrderServiceIntegrationTest {\n\n @Autowired\n private OrderService orderService;\n\n @Autowired\n private OrderRepository orderRepository;\n\n @Test\n void createOrder_persistsToDatabase() {\n CreateOrderRequest request = createValidRequest();\n\n Order result = orderService.createOrder(request);\n\n Order found = orderRepository.findById(result.getId()).orElseThrow();\n assertEquals(result.getTotal(), found.getTotal());\n }\n}\n\n// ✅ Web layer tests\n@WebMvcTest(OrderController.class)\nclass OrderControllerTest {\n\n @Autowired\n private MockMvc mockMvc;\n\n @MockBean\n private OrderService orderService;\n\n @Test\n void createOrder_returns201() throws Exception {\n Order order = Order.builder().id(1L).status(OrderStatus.PENDING).build();\n when(orderService.createOrder(any())).thenReturn(order);\n\n mockMvc.perform(post(\"/api/orders\")\n .contentType(MediaType.APPLICATION_JSON)\n .content(\"\"\"\n {\n \"customerId\": 1,\n \"items\": [{\"productId\": 1, \"quantity\": 2}]\n }\n \"\"\"))\n .andExpect(status().isCreated())\n .andExpect(jsonPath(\"$.id\").value(1))\n .andExpect(jsonPath(\"$.status\").value(\"PENDING\"));\n }\n}\n```\n\n---\n\n## Common Anti-Patterns\n\n| Anti-Pattern | Problem | Solution |\n|--------------|---------|----------|\n| God Service | One service does everything | Split by domain |\n| Anemic Domain | Entities are just data holders | Rich domain model |\n| Field Injection | Hidden dependencies | Constructor injection |\n| Fat Controller | Business logic in controller | Delegate to service |\n| Circular Dependencies | A→B→A | Introduce interface or event |\n\n---\n\n## 🐛 Debug This: The Transaction That Never Was\n\nA developer reports: \"My order processing fails intermittently. Sometimes items get reserved in inventory but the order isn't created. I have @Transactional on my method - why isn't everything rolling back?\"\n\n```java\n@Service\n@RequiredArgsConstructor\npublic class OrderService {\n\n private final OrderRepository orderRepository;\n private final InventoryService inventoryService;\n private final PaymentService paymentService;\n\n public Order processOrder(CreateOrderRequest request) {\n // Reserve inventory\n inventoryService.reserve(request.items());\n\n // Process payment\n paymentService.charge(request.customerId(), request.total());\n\n // Create the order (this is the transactional part!)\n return createOrderInternal(request);\n }\n\n @Transactional\n public Order createOrderInternal(CreateOrderRequest request) {\n Order order = Order.builder()\n .customerId(request.customerId())\n .items(mapItems(request.items()))\n .total(request.total())\n .status(OrderStatus.PENDING)\n .build();\n\n Order saved = orderRepository.save(order);\n\n // Simulate something that might fail\n if (request.total().compareTo(BigDecimal.valueOf(10000)) > 0) {\n throw new BusinessException(\"High-value orders require manual approval\");\n }\n\n return saved;\n }\n}\n\n// Usage\n@RestController\n@RequiredArgsConstructor\npublic class OrderController {\n\n private final OrderService orderService;\n\n @PostMapping(\"/api/orders\")\n public ResponseEntity createOrder(@RequestBody CreateOrderRequest request) {\n Order order = orderService.processOrder(request);\n return ResponseEntity.ok(order);\n }\n}\n```\n\n**When `createOrderInternal` throws an exception, the inventory is still reserved but no order exists. Why doesn't @Transactional roll back?**\n\n---\n\n**✅ Solution:**\n\n**Problem: Self-invocation bypasses the proxy**\n\n```java\npublic Order processOrder(CreateOrderRequest request) {\n // ...\n return createOrderInternal(request); // DIRECT CALL - no proxy!\n}\n```\n\nSpring AOP creates a proxy around your bean. When you call `createOrderInternal` from *within the same class*, you bypass the proxy - the `@Transactional` annotation is never intercepted!\n\n```\nExternal call: Controller → Proxy → OrderService.processOrder()\nInternal call: OrderService.processOrder() → OrderService.createOrderInternal()\n ↑ Direct call, no proxy!\n```\n\n**Additional problems:**\n\n1. **Inventory reservation is outside any transaction** - if payment or order creation fails, inventory stays reserved\n2. **Payment is not in a transaction** - if order creation fails, customer is charged but has no order\n\n**Solutions:**\n\n**Solution 1: Move @Transactional to the public method**\n\n```java\n@Service\n@RequiredArgsConstructor\npublic class OrderService {\n\n @Transactional // On the entry point method\n public Order processOrder(CreateOrderRequest request) {\n inventoryService.reserve(request.items());\n paymentService.charge(request.customerId(), request.total());\n return createOrderInternal(request);\n }\n\n // No @Transactional needed - runs in caller's transaction\n private Order createOrderInternal(CreateOrderRequest request) {\n Order order = Order.builder()\n .customerId(request.customerId())\n .items(mapItems(request.items()))\n .total(request.total())\n .status(OrderStatus.PENDING)\n .build();\n\n return orderRepository.save(order);\n }\n}\n```\n\n**Solution 2: Separate services (better for SRP)**\n\n```java\n@Service\n@RequiredArgsConstructor\npublic class OrderOrchestrator {\n\n private final OrderService orderService;\n private final InventoryService inventoryService;\n private final PaymentService paymentService;\n\n @Transactional\n public Order processOrder(CreateOrderRequest request) {\n inventoryService.reserve(request.items());\n paymentService.charge(request.customerId(), request.total());\n return orderService.createOrder(request); // Calls through proxy\n }\n}\n\n@Service\n@RequiredArgsConstructor\npublic class OrderService {\n\n private final OrderRepository orderRepository;\n\n @Transactional(propagation = Propagation.REQUIRED)\n public Order createOrder(CreateOrderRequest request) {\n // Now properly transactional\n return orderRepository.save(Order.builder()...build());\n }\n}\n```\n\n**Solution 3: Self-injection (use sparingly)**\n\n```java\n@Service\npublic class OrderService {\n\n private final OrderRepository orderRepository;\n private OrderService self; // Self reference\n\n @Autowired\n public void setSelf(@Lazy OrderService self) {\n this.self = self;\n }\n\n public Order processOrder(CreateOrderRequest request) {\n // Call through proxy via self reference\n return self.createOrderTransactional(request);\n }\n\n @Transactional\n public Order createOrderTransactional(CreateOrderRequest request) {\n // Now called through proxy\n }\n}\n```\n\n**The lesson:** `@Transactional` only works when called from *outside* the class. Self-invocation bypasses the proxy. Put `@Transactional` on public entry points, or use separate services.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Thin Controller Refactoring\n⭐ Difficulty: Easy | ⏱️ Time: 10 minutes\n\n**Task:** Refactor this fat controller to follow the thin controller pattern.\n\n```java\n@RestController\n@RequestMapping(\"/api/products\")\npublic class ProductController {\n\n @Autowired\n private ProductRepository productRepository;\n @Autowired\n private CategoryRepository categoryRepository;\n @Autowired\n private PriceCalculator priceCalculator;\n\n @PostMapping\n public ResponseEntity createProduct(@RequestBody Map body) {\n String name = (String) body.get(\"name\");\n Long categoryId = ((Number) body.get(\"categoryId\")).longValue();\n BigDecimal basePrice = new BigDecimal(body.get(\"basePrice\").toString());\n\n // Validation\n if (name == null || name.length() < 3) {\n return ResponseEntity.badRequest().body(\"Name must be at least 3 characters\");\n }\n\n Category category = categoryRepository.findById(categoryId).orElse(null);\n if (category == null) {\n return ResponseEntity.badRequest().body(\"Category not found\");\n }\n\n // Business logic\n BigDecimal finalPrice = priceCalculator.calculateWithMarkup(basePrice, category);\n\n Product product = new Product();\n product.setName(name);\n product.setCategory(category);\n product.setBasePrice(basePrice);\n product.setFinalPrice(finalPrice);\n product.setCreatedAt(LocalDateTime.now());\n\n Product saved = productRepository.save(product);\n\n Map response = new HashMap<>();\n response.put(\"id\", saved.getId());\n response.put(\"name\", saved.getName());\n response.put(\"price\", saved.getFinalPrice());\n\n return ResponseEntity.status(201).body(response);\n }\n}\n```\n\n**✅ Solution:**\n\n```java\n// Request DTO with validation\npublic record CreateProductRequest(\n @NotBlank @Size(min = 3) String name,\n @NotNull Long categoryId,\n @NotNull @Positive BigDecimal basePrice\n) {}\n\n// Response DTO\npublic record ProductResponse(Long id, String name, BigDecimal price, String category) {\n public static ProductResponse from(Product product) {\n return new ProductResponse(\n product.getId(),\n product.getName(),\n product.getFinalPrice(),\n product.getCategory().getName()\n );\n }\n}\n\n// Thin controller\n@RestController\n@RequestMapping(\"/api/products\")\n@RequiredArgsConstructor\npublic class ProductController {\n\n private final ProductService productService;\n\n @PostMapping\n public ResponseEntity createProduct(\n @Valid @RequestBody CreateProductRequest request) {\n Product product = productService.createProduct(request);\n return ResponseEntity\n .status(HttpStatus.CREATED)\n .body(ProductResponse.from(product));\n }\n}\n\n// Service with business logic\n@Service\n@RequiredArgsConstructor\n@Transactional(readOnly = true)\npublic class ProductService {\n\n private final ProductRepository productRepository;\n private final CategoryRepository categoryRepository;\n private final PriceCalculator priceCalculator;\n\n @Transactional\n public Product createProduct(CreateProductRequest request) {\n Category category = categoryRepository.findById(request.categoryId())\n .orElseThrow(() -> new CategoryNotFoundException(request.categoryId()));\n\n BigDecimal finalPrice = priceCalculator.calculateWithMarkup(\n request.basePrice(), category);\n\n Product product = Product.builder()\n .name(request.name())\n .category(category)\n .basePrice(request.basePrice())\n .finalPrice(finalPrice)\n .createdAt(LocalDateTime.now())\n .build();\n\n return productRepository.save(product);\n }\n}\n```\n\n---\n\n### Exercise 2: Configuration Properties\n⭐⭐ Difficulty: Medium | ⏱️ Time: 15 minutes\n\n**Task:** Convert these scattered configurations to a type-safe configuration class.\n\n```java\n// Current: Values scattered across application\n@Service\npublic class EmailService {\n\n @Value(\"${email.smtp.host}\")\n private String smtpHost;\n\n @Value(\"${email.smtp.port:587}\")\n private int smtpPort;\n\n @Value(\"${email.from}\")\n private String fromAddress;\n\n @Value(\"${email.username}\")\n private String username;\n\n @Value(\"${email.password}\")\n private String password;\n\n @Value(\"${email.templates.path:/templates/email}\")\n private String templatesPath;\n\n @Value(\"${email.retry.max-attempts:3}\")\n private int maxRetryAttempts;\n\n @Value(\"${email.retry.delay-ms:1000}\")\n private long retryDelayMs;\n}\n```\n\n**✅ Solution:**\n\n```java\n// Type-safe configuration with records\n@ConfigurationProperties(prefix = \"email\")\n@Validated\npublic record EmailConfig(\n @Valid @NotNull SmtpConfig smtp,\n @NotBlank @Email String from,\n @NotBlank String username,\n @NotBlank String password,\n @Valid TemplatesConfig templates,\n @Valid RetryConfig retry\n) {\n public record SmtpConfig(\n @NotBlank String host,\n @Min(1) @Max(65535) int port\n ) {\n public SmtpConfig {\n if (port == 0) port = 587; // Default\n }\n }\n\n public record TemplatesConfig(\n String path\n ) {\n public TemplatesConfig {\n if (path == null || path.isBlank()) {\n path = \"/templates/email\";\n }\n }\n }\n\n public record RetryConfig(\n @Min(1) int maxAttempts,\n @NotNull Duration delay\n ) {\n public RetryConfig {\n if (maxAttempts == 0) maxAttempts = 3;\n if (delay == null) delay = Duration.ofSeconds(1);\n }\n }\n}\n\n// Configuration class to enable and use\n@Configuration\n@EnableConfigurationProperties(EmailConfig.class)\npublic class EmailConfiguration {\n\n @Bean\n public JavaMailSender mailSender(EmailConfig config) {\n JavaMailSenderImpl sender = new JavaMailSenderImpl();\n sender.setHost(config.smtp().host());\n sender.setPort(config.smtp().port());\n sender.setUsername(config.username());\n sender.setPassword(config.password());\n\n Properties props = sender.getJavaMailProperties();\n props.put(\"mail.transport.protocol\", \"smtp\");\n props.put(\"mail.smtp.auth\", \"true\");\n props.put(\"mail.smtp.starttls.enable\", \"true\");\n\n return sender;\n }\n\n @Bean\n public RetryTemplate emailRetryTemplate(EmailConfig config) {\n return RetryTemplate.builder()\n .maxAttempts(config.retry().maxAttempts())\n .fixedBackoff(config.retry().delay().toMillis())\n .build();\n }\n}\n\n// Clean service using injected config\n@Service\n@RequiredArgsConstructor\npublic class EmailService {\n\n private final JavaMailSender mailSender;\n private final EmailConfig config;\n private final RetryTemplate retryTemplate;\n\n public void send(String to, String subject, String body) {\n retryTemplate.execute(ctx -> {\n SimpleMailMessage message = new SimpleMailMessage();\n message.setFrom(config.from());\n message.setTo(to);\n message.setSubject(subject);\n message.setText(body);\n mailSender.send(message);\n return null;\n });\n }\n}\n\n// application.yml\n/*\nemail:\n smtp:\n host: smtp.example.com\n port: 587\n from: noreply@example.com\n username: ${EMAIL_USERNAME}\n password: ${EMAIL_PASSWORD}\n templates:\n path: /templates/email\n retry:\n max-attempts: 3\n delay: 2s\n*/\n```\n\n---\n\n### Exercise 3: Event-Driven Decoupling\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Refactor this tightly coupled service to use events.\n\n```java\n// Current: Tightly coupled - UserService knows about all downstream systems\n@Service\n@RequiredArgsConstructor\npublic class UserService {\n\n private final UserRepository userRepository;\n private final EmailService emailService;\n private final AnalyticsService analyticsService;\n private final BillingService billingService;\n private final AuditService auditService;\n private final NotificationService notificationService;\n\n @Transactional\n public User registerUser(RegisterRequest request) {\n User user = User.builder()\n .email(request.email())\n .name(request.name())\n .build();\n\n User saved = userRepository.save(user);\n\n // All these are called synchronously!\n emailService.sendWelcomeEmail(saved);\n analyticsService.trackRegistration(saved);\n billingService.createCustomer(saved);\n auditService.logUserCreated(saved);\n notificationService.notifyAdmins(\"New user: \" + saved.getEmail());\n\n return saved;\n }\n}\n```\n\n**✅ Solution:**\n\n```java\n// Event record\npublic record UserRegisteredEvent(\n Long userId,\n String email,\n String name,\n Instant registeredAt\n) {\n public static UserRegisteredEvent from(User user) {\n return new UserRegisteredEvent(\n user.getId(),\n user.getEmail(),\n user.getName(),\n Instant.now()\n );\n }\n}\n\n// Clean service - only handles core user logic\n@Service\n@RequiredArgsConstructor\npublic class UserService {\n\n private final UserRepository userRepository;\n private final ApplicationEventPublisher eventPublisher;\n\n @Transactional\n public User registerUser(RegisterRequest request) {\n User user = User.builder()\n .email(request.email())\n .name(request.name())\n .status(UserStatus.PENDING)\n .build();\n\n User saved = userRepository.save(user);\n\n // Single event - listeners handle the rest\n eventPublisher.publishEvent(UserRegisteredEvent.from(saved));\n\n return saved;\n }\n}\n\n// Decoupled listeners\n@Component\n@RequiredArgsConstructor\n@Slf4j\npublic class WelcomeEmailListener {\n\n private final EmailService emailService;\n\n @EventListener\n @Async\n public void onUserRegistered(UserRegisteredEvent event) {\n log.info(\"Sending welcome email to {}\", event.email());\n emailService.sendWelcomeEmail(event.email(), event.name());\n }\n}\n\n@Component\n@RequiredArgsConstructor\npublic class RegistrationAnalyticsListener {\n\n private final AnalyticsService analyticsService;\n\n @EventListener\n @Async\n public void onUserRegistered(UserRegisteredEvent event) {\n analyticsService.track(\"user_registered\", Map.of(\n \"userId\", event.userId(),\n \"email\", event.email()\n ));\n }\n}\n\n@Component\n@RequiredArgsConstructor\npublic class BillingSetupListener {\n\n private final BillingService billingService;\n\n @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)\n @Async\n public void onUserRegistered(UserRegisteredEvent event) {\n // Only create billing customer after user is committed\n billingService.createCustomer(event.userId(), event.email());\n }\n}\n\n@Component\n@RequiredArgsConstructor\npublic class AuditListener {\n\n private final AuditService auditService;\n\n @EventListener\n public void onUserRegistered(UserRegisteredEvent event) {\n // Audit is synchronous - must complete\n auditService.log(AuditAction.USER_CREATED, Map.of(\n \"userId\", event.userId(),\n \"email\", event.email()\n ));\n }\n}\n\n@Component\n@RequiredArgsConstructor\npublic class AdminNotificationListener {\n\n private final NotificationService notificationService;\n\n @EventListener\n @Async\n public void onUserRegistered(UserRegisteredEvent event) {\n notificationService.notifyAdmins(\n \"New user registered: \" + event.email());\n }\n}\n\n// Enable async processing\n@Configuration\n@EnableAsync\npublic class AsyncConfig {\n\n @Bean\n public Executor taskExecutor() {\n ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();\n executor.setCorePoolSize(5);\n executor.setMaxPoolSize(10);\n executor.setQueueCapacity(100);\n executor.setThreadNamePrefix(\"async-\");\n executor.initialize();\n return executor;\n }\n}\n```\n\n---\n\n### Exercise 4: Repository with Custom Queries\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 20 minutes\n\n**Task:** Create a clean repository with dynamic search capabilities.\n\n```java\n// Requirements:\n// - Search orders by multiple optional criteria\n// - Support: customerId, status, date range, min/max total\n// - Pagination and sorting\n// - Type-safe criteria builder\n```\n\n**✅ Solution:**\n\n```java\n// Search criteria record\npublic record OrderSearchCriteria(\n Long customerId,\n Set statuses,\n LocalDateTime createdAfter,\n LocalDateTime createdBefore,\n BigDecimal minTotal,\n BigDecimal maxTotal,\n String sortBy,\n Sort.Direction sortDirection\n) {\n public OrderSearchCriteria {\n if (statuses == null) statuses = Set.of();\n if (sortBy == null) sortBy = \"createdAt\";\n if (sortDirection == null) sortDirection = Sort.Direction.DESC;\n }\n\n public static Builder builder() {\n return new Builder();\n }\n\n public static class Builder {\n private Long customerId;\n private Set statuses;\n private LocalDateTime createdAfter;\n private LocalDateTime createdBefore;\n private BigDecimal minTotal;\n private BigDecimal maxTotal;\n private String sortBy;\n private Sort.Direction sortDirection;\n\n public Builder customerId(Long id) { this.customerId = id; return this; }\n public Builder statuses(OrderStatus... s) { this.statuses = Set.of(s); return this; }\n public Builder createdBetween(LocalDateTime after, LocalDateTime before) {\n this.createdAfter = after;\n this.createdBefore = before;\n return this;\n }\n public Builder totalBetween(BigDecimal min, BigDecimal max) {\n this.minTotal = min;\n this.maxTotal = max;\n return this;\n }\n public Builder sortBy(String field, Sort.Direction dir) {\n this.sortBy = field;\n this.sortDirection = dir;\n return this;\n }\n\n public OrderSearchCriteria build() {\n return new OrderSearchCriteria(\n customerId, statuses, createdAfter, createdBefore,\n minTotal, maxTotal, sortBy, sortDirection\n );\n }\n }\n}\n\n// Repository interface\npublic interface OrderRepository extends JpaRepository, OrderRepositoryCustom {\n // Standard derived queries\n List findByCustomerId(Long customerId);\n Page findByStatus(OrderStatus status, Pageable pageable);\n}\n\n// Custom repository interface\npublic interface OrderRepositoryCustom {\n Page search(OrderSearchCriteria criteria, Pageable pageable);\n OrderStatistics getStatistics(Long customerId);\n}\n\n// Custom repository implementation\n@Repository\n@RequiredArgsConstructor\npublic class OrderRepositoryCustomImpl implements OrderRepositoryCustom {\n\n private final EntityManager em;\n\n @Override\n public Page search(OrderSearchCriteria criteria, Pageable pageable) {\n CriteriaBuilder cb = em.getCriteriaBuilder();\n\n // Count query\n CriteriaQuery countQuery = cb.createQuery(Long.class);\n Root countRoot = countQuery.from(Order.class);\n countQuery.select(cb.count(countRoot));\n countQuery.where(buildPredicates(cb, countRoot, criteria).toArray(new Predicate[0]));\n Long total = em.createQuery(countQuery).getSingleResult();\n\n // Data query\n CriteriaQuery dataQuery = cb.createQuery(Order.class);\n Root dataRoot = dataQuery.from(Order.class);\n dataQuery.where(buildPredicates(cb, dataRoot, criteria).toArray(new Predicate[0]));\n\n // Sorting\n if (criteria.sortDirection() == Sort.Direction.ASC) {\n dataQuery.orderBy(cb.asc(dataRoot.get(criteria.sortBy())));\n } else {\n dataQuery.orderBy(cb.desc(dataRoot.get(criteria.sortBy())));\n }\n\n List orders = em.createQuery(dataQuery)\n .setFirstResult((int) pageable.getOffset())\n .setMaxResults(pageable.getPageSize())\n .getResultList();\n\n return new PageImpl<>(orders, pageable, total);\n }\n\n private List buildPredicates(CriteriaBuilder cb, Root root,\n OrderSearchCriteria criteria) {\n List predicates = new ArrayList<>();\n\n if (criteria.customerId() != null) {\n predicates.add(cb.equal(root.get(\"customerId\"), criteria.customerId()));\n }\n\n if (!criteria.statuses().isEmpty()) {\n predicates.add(root.get(\"status\").in(criteria.statuses()));\n }\n\n if (criteria.createdAfter() != null) {\n predicates.add(cb.greaterThanOrEqualTo(\n root.get(\"createdAt\"), criteria.createdAfter()));\n }\n\n if (criteria.createdBefore() != null) {\n predicates.add(cb.lessThanOrEqualTo(\n root.get(\"createdAt\"), criteria.createdBefore()));\n }\n\n if (criteria.minTotal() != null) {\n predicates.add(cb.greaterThanOrEqualTo(root.get(\"total\"), criteria.minTotal()));\n }\n\n if (criteria.maxTotal() != null) {\n predicates.add(cb.lessThanOrEqualTo(root.get(\"total\"), criteria.maxTotal()));\n }\n\n return predicates;\n }\n\n @Override\n public OrderStatistics getStatistics(Long customerId) {\n return em.createQuery(\"\"\"\n SELECT new com.example.dto.OrderStatistics(\n COUNT(o),\n COALESCE(SUM(o.total), 0),\n COALESCE(AVG(o.total), 0),\n MAX(o.createdAt)\n )\n FROM Order o\n WHERE o.customerId = :customerId\n \"\"\", OrderStatistics.class)\n .setParameter(\"customerId\", customerId)\n .getSingleResult();\n }\n}\n\n// Statistics DTO\npublic record OrderStatistics(\n long orderCount,\n BigDecimal totalSpent,\n BigDecimal averageOrderValue,\n LocalDateTime lastOrderDate\n) {}\n\n// Usage\nvar criteria = OrderSearchCriteria.builder()\n .customerId(123L)\n .statuses(OrderStatus.COMPLETED, OrderStatus.SHIPPED)\n .createdBetween(LocalDateTime.now().minusMonths(3), LocalDateTime.now())\n .totalBetween(new BigDecimal(\"100\"), new BigDecimal(\"1000\"))\n .sortBy(\"total\", Sort.Direction.DESC)\n .build();\n\nPage results = orderRepository.search(criteria, PageRequest.of(0, 20));\n```\n\n---\n\n### Exercise 5: Full Integration Test Suite\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 30 minutes\n\n**Task:** Write a comprehensive integration test for an order creation flow.\n\n```java\n// Requirements:\n// - Test full flow: controller → service → repository → database\n// - Test validation errors\n// - Test business rule violations\n// - Test successful creation with all side effects\n// - Use TestContainers for real database\n```\n\n**✅ Solution:**\n\n```java\n@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)\n@AutoConfigureMockMvc\n@Testcontainers\n@Transactional\nclass OrderIntegrationTest {\n\n @Container\n static PostgreSQLContainer postgres = new PostgreSQLContainer<>(\"postgres:15\")\n .withDatabaseName(\"test\")\n .withUsername(\"test\")\n .withPassword(\"test\");\n\n @DynamicPropertySource\n static void configureProperties(DynamicPropertyRegistry registry) {\n registry.add(\"spring.datasource.url\", postgres::getJdbcUrl);\n registry.add(\"spring.datasource.username\", postgres::getUsername);\n registry.add(\"spring.datasource.password\", postgres::getPassword);\n }\n\n @Autowired\n private MockMvc mockMvc;\n\n @Autowired\n private OrderRepository orderRepository;\n\n @Autowired\n private CustomerRepository customerRepository;\n\n @Autowired\n private ProductRepository productRepository;\n\n @MockBean\n private PaymentService paymentService; // Mock external service\n\n @Captor\n private ArgumentCaptor paymentCaptor;\n\n private Customer testCustomer;\n private Product testProduct;\n\n @BeforeEach\n void setUp() {\n testCustomer = customerRepository.save(Customer.builder()\n .email(\"test@example.com\")\n .name(\"Test Customer\")\n .status(CustomerStatus.ACTIVE)\n .build());\n\n testProduct = productRepository.save(Product.builder()\n .name(\"Test Product\")\n .price(new BigDecimal(\"49.99\"))\n .stock(100)\n .build());\n\n when(paymentService.charge(any())).thenReturn(\n PaymentResult.success(\"txn_123\"));\n }\n\n @Test\n void createOrder_withValidRequest_returnsCreatedOrder() throws Exception {\n String requestBody = \"\"\"\n {\n \"customerId\": %d,\n \"items\": [\n {\"productId\": %d, \"quantity\": 2}\n ]\n }\n \"\"\".formatted(testCustomer.getId(), testProduct.getId());\n\n mockMvc.perform(post(\"/api/orders\")\n .contentType(MediaType.APPLICATION_JSON)\n .content(requestBody))\n .andExpect(status().isCreated())\n .andExpect(jsonPath(\"$.id\").exists())\n .andExpect(jsonPath(\"$.status\").value(\"PENDING\"))\n .andExpect(jsonPath(\"$.total\").value(99.98)) // 49.99 * 2\n .andExpect(jsonPath(\"$.items.length()\").value(1))\n .andExpect(jsonPath(\"$.items[0].quantity\").value(2));\n\n // Verify database state\n List orders = orderRepository.findByCustomerId(testCustomer.getId());\n assertThat(orders).hasSize(1);\n assertThat(orders.get(0).getTotal()).isEqualByComparingTo(\"99.98\");\n\n // Verify payment was called\n verify(paymentService).charge(paymentCaptor.capture());\n PaymentRequest paymentRequest = paymentCaptor.getValue();\n assertThat(paymentRequest.amount()).isEqualByComparingTo(\"99.98\");\n assertThat(paymentRequest.customerId()).isEqualTo(testCustomer.getId());\n }\n\n @Test\n void createOrder_withInvalidRequest_returns400() throws Exception {\n String requestBody = \"\"\"\n {\n \"customerId\": null,\n \"items\": []\n }\n \"\"\";\n\n mockMvc.perform(post(\"/api/orders\")\n .contentType(MediaType.APPLICATION_JSON)\n .content(requestBody))\n .andExpect(status().isBadRequest())\n .andExpect(jsonPath(\"$.errors\").isArray())\n .andExpect(jsonPath(\"$.errors[?(@.field=='customerId')]\").exists())\n .andExpect(jsonPath(\"$.errors[?(@.field=='items')]\").exists());\n\n // Verify no order created\n assertThat(orderRepository.count()).isZero();\n verifyNoInteractions(paymentService);\n }\n\n @Test\n void createOrder_withNonExistentCustomer_returns404() throws Exception {\n String requestBody = \"\"\"\n {\n \"customerId\": 99999,\n \"items\": [{\"productId\": %d, \"quantity\": 1}]\n }\n \"\"\".formatted(testProduct.getId());\n\n mockMvc.perform(post(\"/api/orders\")\n .contentType(MediaType.APPLICATION_JSON)\n .content(requestBody))\n .andExpect(status().isNotFound())\n .andExpect(jsonPath(\"$.detail\").value(containsString(\"Customer not found\")));\n }\n\n @Test\n void createOrder_withInsufficientStock_returns409() throws Exception {\n testProduct.setStock(1);\n productRepository.save(testProduct);\n\n String requestBody = \"\"\"\n {\n \"customerId\": %d,\n \"items\": [{\"productId\": %d, \"quantity\": 10}]\n }\n \"\"\".formatted(testCustomer.getId(), testProduct.getId());\n\n mockMvc.perform(post(\"/api/orders\")\n .contentType(MediaType.APPLICATION_JSON)\n .content(requestBody))\n .andExpect(status().isConflict())\n .andExpect(jsonPath(\"$.detail\").value(containsString(\"Insufficient stock\")));\n\n // Stock should not be reduced\n Product updated = productRepository.findById(testProduct.getId()).orElseThrow();\n assertThat(updated.getStock()).isEqualTo(1);\n }\n\n @Test\n void createOrder_withPaymentFailure_rollsBackTransaction() throws Exception {\n when(paymentService.charge(any())).thenReturn(\n PaymentResult.failed(\"Card declined\"));\n\n String requestBody = \"\"\"\n {\n \"customerId\": %d,\n \"items\": [{\"productId\": %d, \"quantity\": 1}]\n }\n \"\"\".formatted(testCustomer.getId(), testProduct.getId());\n\n mockMvc.perform(post(\"/api/orders\")\n .contentType(MediaType.APPLICATION_JSON)\n .content(requestBody))\n .andExpect(status().isPaymentRequired())\n .andExpect(jsonPath(\"$.detail\").value(containsString(\"Card declined\")));\n\n // Order should not exist\n assertThat(orderRepository.findByCustomerId(testCustomer.getId())).isEmpty();\n\n // Stock should not be reduced\n Product updated = productRepository.findById(testProduct.getId()).orElseThrow();\n assertThat(updated.getStock()).isEqualTo(100);\n }\n\n @Test\n void createOrder_withInactiveCustomer_returns403() throws Exception {\n testCustomer.setStatus(CustomerStatus.SUSPENDED);\n customerRepository.save(testCustomer);\n\n String requestBody = \"\"\"\n {\n \"customerId\": %d,\n \"items\": [{\"productId\": %d, \"quantity\": 1}]\n }\n \"\"\".formatted(testCustomer.getId(), testProduct.getId());\n\n mockMvc.perform(post(\"/api/orders\")\n .contentType(MediaType.APPLICATION_JSON)\n .content(requestBody))\n .andExpect(status().isForbidden())\n .andExpect(jsonPath(\"$.detail\").value(containsString(\"Customer is not active\")));\n }\n\n @Test\n void createOrder_reducesProductStock() throws Exception {\n String requestBody = \"\"\"\n {\n \"customerId\": %d,\n \"items\": [{\"productId\": %d, \"quantity\": 5}]\n }\n \"\"\".formatted(testCustomer.getId(), testProduct.getId());\n\n mockMvc.perform(post(\"/api/orders\")\n .contentType(MediaType.APPLICATION_JSON)\n .content(requestBody))\n .andExpect(status().isCreated());\n\n // Verify stock was reduced\n Product updated = productRepository.findById(testProduct.getId()).orElseThrow();\n assertThat(updated.getStock()).isEqualTo(95); // 100 - 5\n }\n}\n```\n\n---\n\n## 📝 Summary\n\n| Layer | Responsibility |\n|-------|---------------|\n| Controller | HTTP handling, request/response mapping |\n| Service | Business logic, transaction boundaries |\n| Repository | Data access, queries |\n| Domain | Business rules, validation |\n| Configuration | External config, bean definitions |\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review the Layered Architecture responsibilities | 5 min |\n| Day 3 | Redo Exercise 1 (Thin Controller Refactoring) | 10 min |\n| Day 7 | Audit one controller in your codebase for business logic | 15 min |\n| Day 14 | Redo Debug This (The Transaction That Never Was) | 10 min |\n| Day 30 | Implement event-driven decoupling in a real service | 25 min |\n\n---\n\n*Next: [Part 25: Decision Guide & Cheatsheet]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.956061Z","createdAt","2026-06-10T07:19:24.956943Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",18,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder",24,"author",{"_31":55,"_98":57,"_99":100,"_101":102,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5},"category",{"_31":94,"_72":59,"_35":95,"_75":96,"_97":-5},"tags",[78,79,80,81],"series",{"_31":16,"_72":73,"_35":74,"_75":76,"_77":23},"name","Advanced Clean Code Patterns: From Principles to Production Mastery","advanced-clean-code-patterns","description","A comprehensive 26-part series covering enterprise-grade clean code patterns for Java developers. From SOLID principles and code smells through refactoring patterns, error handling, validation, to legacy modernization and modern Java 21+ features. Includes real production stories, mental models, exercises, and 150+ interview questions.","isActive",{"_31":91,"_72":92,"_35":93},{"_31":88,"_72":89,"_35":90},{"_31":85,"_72":86,"_35":87},{"_31":82,"_72":83,"_35":84},78,"Spring Boot","spring-boot",108,"Spring Best Practices","spring-best-practices",110,"Dependency Injection","dependency-injection",109,"Configuration","configuration",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]