Layered Architecture

Layered architecture separates concerns into distinct layers. Each layer only communicates with the layer directly below it.

The Three Core Layers

┌─────────────────────────┐
│      Controller         │  -- HTTP requests/responses
├─────────────────────────┤
│       Service           │  -- Business logic
├─────────────────────────┤
│      Repository         │  -- Database access
├─────────────────────────┤
│       Database          │  -- Data storage
└─────────────────────────┘

Layer Responsibilities

Layer	Responsibility	Knows About
Controller	Handle HTTP, validate input, return responses	Service layer
Service	Business logic, transactions, orchestration	Repository layer
Repository	CRUD operations, query database	Database/Entities
Model	Data structures, entities, DTOs	Nothing (pure data)

Code Example — Layer by Layer

Controller Layer:

@RestController
@RequestMapping("/api/products")
public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    @GetMapping("/{id}")
    public ResponseEntity<ProductDto> getProduct(@PathVariable Long id) {
        ProductDto product = productService.getProduct(id);
        return ResponseEntity.ok(product);
    }

    @PostMapping
    public ResponseEntity<ProductDto> createProduct(@RequestBody CreateProductRequest request) {
        ProductDto created = productService.createProduct(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(created);
    }
}

Service Layer:

@Service
public class ProductService {

    private final ProductRepository productRepository;
    private final ProductMapper productMapper;

    public ProductService(ProductRepository productRepository, ProductMapper productMapper) {
        this.productRepository = productRepository;
        this.productMapper = productMapper;
    }

    public ProductDto getProduct(Long id) {
        Product product = productRepository.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException("Product not found"));
        return productMapper.toDto(product);
    }

    @Transactional
    public ProductDto createProduct(CreateProductRequest request) {
        Product product = productMapper.toEntity(request);
        Product saved = productRepository.save(product);
        return productMapper.toDto(saved);
    }
}

Repository Layer:

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    List<Product> findByCategoryId(Long categoryId);
    List<Product> findByNameContainingIgnoreCase(String name);
}

Benefits of Layered Architecture

1. Separation of concerns — each layer has one job
2. Testability — mock individual layers in tests
3. Maintainability — changes in one layer don't ripple
4. Team collaboration — different developers work on different layers

Common Anti-Patterns

• Fat Controller — business logic in controller
• Service calling Service — circular dependencies
• Repository with logic — business rules in repository
• Skipping layers — controller directly calling repository

Interview Questions

Q: What happens if you put business logic in a controller?

• Controller becomes hard to test
• Logic can't be reused by other entry points (CLI, message consumers)
• Violates Single Responsibility Principle

Q: Can services call other services?

• Yes, but keep it minimal to avoid circular dependencies
• Better to extract shared logic into a dedicated service

Q: When would you skip the repository layer?

• For read-only queries that don't need JPA entities
• When calling external APIs (use a client/service instead)
• For simple lookups from cache

Practical Example — Amazon Order Flow

OrderController
    └── orderService.createOrder(request)
            ├── userService.validateUser(userId)
            ├── inventoryService.checkStock(items)
            ├── pricingService.calculateTotal(items)
            ├── orderRepository.save(order)
            └── messageService.sendOrderConfirmation(order)

Each service handles its own concern. The OrderService orchestrates the flow.