What is a 3-tier architecture, and why is it commonly used in Java web applications?

Direct Answer

A 3-tier architecture separates presentation concerns, application or business rules, and data access. In a Spring Boot application these often map to controllers, services, and repositories. The separation makes responsibilities easier to understand and test, but it does not mean every tier needs a separate server or that every small endpoint requires a pass-through class.

Code Example

// PRESENTATION TIER: Handles HTTP requests and responses
@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final OrderService orderService;
    
    @PostMapping
    public ResponseEntity<OrderDTO> createOrder(@RequestBody OrderRequest request) {
        var order = orderService.placeOrder(request); // Delegates to application tier
        return ResponseEntity.status(HttpStatus.CREATED).body(order);
    }
}

// APPLICATION TIER: Contains business logic and rules
@Service
public class OrderService {
    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;
    
    @Transactional
    public OrderDTO placeOrder(OrderRequest request) {
        // Business rule: check inventory before placing order
        if (!inventoryService.isAvailable(request.productId(), request.quantity())) {
            throw new OutOfStockException("Product not available");
        }
        var order = new Order(request.productId(), request.quantity(), LocalDateTime.now());
        var savedOrder = orderRepository.save(order); // Delegates to data tier
        inventoryService.reduceStock(request.productId(), request.quantity());
        return toDTO(savedOrder);
    }
}

// DATA TIER: Handles database operations
@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    List<Order> findByCustomerId(Long customerId);
}

Common Mistakes & Pitfalls

• Putting Business Logic in Controllers: The most common mistake is writing if-else conditions, calculations, or validation logic directly in controller methods instead of delegating to service classes. Controllers should only handle HTTP concerns like parsing request bodies and setting response status codes, nothing more.
• Skipping the Service Layer: Some freshers call repositories directly from controllers because it's fewer lines of code, but this can mix HTTP and business concerns and make isolated testing harder and duplicates business logic across multiple controllers. Use a service layer when it owns business rules, transactions, reuse, or a stable application boundary; a trivial pass-through should not be added only for ceremony.
• Confusing Layers with Physical Deployment: Freshers often think 3-tier means three separate servers (web server, app server, database server), but it's actually about logical code organization. Your Spring Boot JAR contains presentation and application tiers in one deployable unit.
• Letting Data Entities Leak Upward: Returning JPA entity objects all the way from repositories through services to controllers couples your API design to your database schema, making changes fragile. Use DTOs to translate between layers.