Kiến Trúc Phân Lớp (N-Tier): Tách Biệt Mối Quan Tâm Trong Thực Tế

// Spring Boot — Tầng Trình Bày
@RestController
@RequestMapping("/api/orders")
public class OrderController {
 
    private final OrderService orderService;
 
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }
 
    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(
            @Valid @RequestBody CreateOrderRequest request) {
 
        // 1. Validate input (xử lý bởi @Valid)
        // 2. Ủy quyền cho service — KHÔNG có logic nghiệp vụ ở đây
        Order order = orderService.createOrder(request.toCommand());
 
        // 3. Định dạng response
        return ResponseEntity.status(HttpStatus.CREATED)
                .body(OrderResponse.from(order));
    }
 
    @GetMapping("/{id}")
    public ResponseEntity<OrderResponse> getOrder(@PathVariable Long id) {
        return orderService.findById(id)
                .map(order -> ResponseEntity.ok(OrderResponse.from(order)))
                .orElse(ResponseEntity.notFound().build());
    }
}

// Express.js — Tầng Trình Bày
const orderRouter = Router();
 
orderRouter.post('/', validateRequest(createOrderSchema), async (req, res) => {
  // Ủy quyền cho service — không có logic nghiệp vụ
  const order = await orderService.createOrder(req.body);
  res.status(201).json(OrderResponse.from(order));
});
 
orderRouter.get('/:id', async (req, res) => {
  const order = await orderService.findById(req.params.id);
  if (!order) return res.status(404).json({ error: 'Order not found' });
  res.json(OrderResponse.from(order));
});

// Spring Boot — Tầng Logic Nghiệp Vụ
@Service
@Transactional
public class OrderService {
 
    private final OrderRepository orderRepository;
    private final ProductRepository productRepository;
    private final UserRepository userRepository;
    private final EventPublisher eventPublisher;
 
    public Order createOrder(CreateOrderCommand command) {
        // Quy tắc nghiệp vụ: user phải tồn tại
        User user = userRepository.findById(command.getUserId())
                .orElseThrow(() -> new UserNotFoundException(command.getUserId()));
 
        // Quy tắc nghiệp vụ: validate tất cả sản phẩm tồn tại và còn hàng
        List<OrderItem> items = command.getItems().stream()
                .map(item -> {
                    Product product = productRepository.findById(item.getProductId())
                            .orElseThrow(() -> new ProductNotFoundException(item.getProductId()));
 
                    if (product.getStock() < item.getQuantity()) {
                        throw new InsufficientStockException(product.getId());
                    }
 
                    return new OrderItem(product, item.getQuantity());
                })
                .collect(toList());
 
        // Tạo và lưu order
        Order order = Order.create(user, items);
        Order savedOrder = orderRepository.save(order);
 
        // Publish domain event (thông báo các phần khác của hệ thống)
        eventPublisher.publish(new OrderCreatedEvent(savedOrder));
 
        return savedOrder;
    }
}

// Express.js — Tầng Logic Nghiệp Vụ
export class OrderService {
  constructor(
    private readonly orderRepository: OrderRepository,
    private readonly productRepository: ProductRepository,
    private readonly userRepository: UserRepository,
  ) {}
 
  async createOrder(command: CreateOrderCommand): Promise<Order> {
    const user = await this.userRepository.findById(command.userId);
    if (!user) throw new UserNotFoundException(command.userId);
 
    const items = await Promise.all(
      command.items.map(async (item) => {
        const product = await this.productRepository.findById(item.productId);
        if (!product) throw new ProductNotFoundException(item.productId);
        if (product.stock < item.quantity) throw new InsufficientStockException(item.productId);
        return new OrderItem(product, item.quantity);
      }),
    );
 
    const order = Order.create(user, items);
    return this.orderRepository.save(order);
  }
}

// Spring Boot — Tầng Truy Cập Dữ Liệu
@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
 
    // Spring Data JPA tạo query từ tên method
    List<Order> findByUserIdOrderByCreatedAtDesc(Long userId);
 
    // Custom JPQL query
    @Query("SELECT o FROM Order o WHERE o.status = :status AND o.createdAt > :since")
    List<Order> findRecentByStatus(
            @Param("status") OrderStatus status,
            @Param("since") LocalDateTime since);
}

// Express.js — Tầng Truy Cập Dữ Liệu (dùng TypeORM)
@Injectable()
export class OrderRepository {
  constructor(
    @InjectRepository(OrderEntity)
    private readonly repo: Repository<OrderEntity>,
  ) {}
 
  async findByUserId(userId: string): Promise<Order[]> {
    const entities = await this.repo.find({
      where: { userId },
      order: { createdAt: 'DESC' },
      relations: ['items', 'items.product'],
    });
    return entities.map(Order.fromEntity);
  }
 
  async save(order: Order): Promise<Order> {
    const entity = order.toEntity();
    const saved = await this.repo.save(entity);
    return Order.fromEntity(saved);
  }
}

// ✅ Tầng nghiệp vụ phụ thuộc vào interface (abstraction)
@Service
public class OrderService {
    private final OrderRepository orderRepository;  // Interface, không phải concrete class
 
    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }
}
 
// Tầng truy cập dữ liệu cung cấp concrete implementation
@Repository
public class JpaOrderRepository implements OrderRepository {
    // ... JPA-specific implementation
}
 
// Để testing, inject mock implementation
@Mock
OrderRepository mockOrderRepository;

src/main/java/com/example/store/
├── presentation/
│   ├── controller/
│   │   ├── OrderController.java
│   │   └── ProductController.java
│   └── dto/
│       ├── CreateOrderRequest.java
│       ├── OrderResponse.java
│       └── ProductResponse.java
├── business/
│   ├── service/
│   │   ├── OrderService.java
│   │   └── ProductService.java
│   └── domain/
│       ├── Order.java
│       ├── OrderItem.java
│       └── Product.java
├── data/
│   ├── repository/
│   │   ├── OrderRepository.java        # Interface
│   │   └── ProductRepository.java      # Interface
│   └── jpa/
│       ├── JpaOrderRepository.java     # Spring Data implementation
│       ├── JpaProductRepository.java
│       ├── OrderEntity.java
│       └── ProductEntity.java
└── StoreApplication.java

src/
├── modules/
│   └── orders/
│       ├── presentation/
│       │   ├── orders.controller.ts
│       │   ├── dto/
│       │   │   ├── create-order.dto.ts
│       │   │   └── order-response.dto.ts
│       │   └── orders.module.ts
│       ├── business/
│       │   ├── orders.service.ts
│       │   ├── order.entity.ts          # Domain entity
│       │   └── order-repository.interface.ts  # Repository interface
│       └── data/
│           ├── typeorm-order.repository.ts   # TypeORM implementation
│           └── order.orm-entity.ts            # TypeORM entity
└── app.module.ts

// business/order-repository.interface.ts — interface trong tầng nghiệp vụ
export interface IOrderRepository {
  findById(id: string): Promise<Order | null>;
  findByUserId(userId: string): Promise<Order[]>;
  save(order: Order): Promise<Order>;
  delete(id: string): Promise<void>;
}
 
// data/typeorm-order.repository.ts — implementation trong tầng dữ liệu
@Injectable()
export class TypeOrmOrderRepository implements IOrderRepository {
  constructor(
    @InjectRepository(OrderOrmEntity)
    private readonly ormRepo: Repository<OrderOrmEntity>,
  ) {}
 
  async findById(id: string): Promise<Order | null> {
    const entity = await this.ormRepo.findOne({ where: { id }, relations: ['items'] });
    return entity ? Order.fromOrmEntity(entity) : null;
  }
 
  async save(order: Order): Promise<Order> {
    const entity = await this.ormRepo.save(order.toOrmEntity());
    return Order.fromOrmEntity(entity);
  }
}

// ❌ Anti-pattern: Anemic domain model
public class Order {
    private Long id;
    private OrderStatus status;
    private List<OrderItem> items;
    private BigDecimal total;
 
    // Chỉ getters và setters. Không có hành vi.
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public OrderStatus getStatus() { return status; }
    public void setStatus(OrderStatus status) { this.status = status; }
    // ... 20 getters/setters nữa
}
 
// Tất cả logic trong service (thủ tục, không phải OOP)
@Service
public class OrderService {
    public void cancelOrder(Long orderId) {
        Order order = orderRepository.findById(orderId).orElseThrow();
 
        // Business rules rải rác trong service
        if (order.getStatus() == OrderStatus.DELIVERED) {
            throw new IllegalStateException("Không thể hủy order đã giao");
        }
        if (order.getStatus() == OrderStatus.CANCELLED) {
            throw new IllegalStateException("Order đã bị hủy rồi");
        }
 
        order.setStatus(OrderStatus.CANCELLED);  // Mutate state trực tiếp
        orderRepository.save(order);
    }
}

// ✅ Rich domain model — hành vi nằm cùng với dữ liệu
public class Order {
    private Long id;
    private OrderStatus status;
    private List<OrderItem> items;
 
    // Logic nghiệp vụ thuộc về domain object
    public void cancel() {
        if (this.status == OrderStatus.DELIVERED) {
            throw new IllegalStateException("Không thể hủy order đã giao");
        }
        if (this.status == OrderStatus.CANCELLED) {
            throw new IllegalStateException("Order đã bị hủy rồi");
        }
        this.status = OrderStatus.CANCELLED;
    }
 
    public BigDecimal calculateTotal() {
        return items.stream()
                .map(OrderItem::getSubtotal)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}
 
// Service giờ gọn gàng — điều phối, không trùng lặp logic
@Service
public class OrderService {
    public void cancelOrder(Long orderId) {
        Order order = orderRepository.findById(orderId).orElseThrow();
        order.cancel();  // Logic domain được đóng gói
        orderRepository.save(order);
    }
}

// ❌ Anti-pattern: Service layer rò rỉ HTTP concerns
@Service
public class OrderService {
    public ResponseEntity<OrderResponse> createOrder(CreateOrderRequest request) {
        // Service KHÔNG nên trả về ResponseEntity — đó là HTTP-specific
        // ...
        return ResponseEntity.status(201).body(new OrderResponse(order));
    }
}
 
// ❌ Anti-pattern: Presentation layer gọi repository trực tiếp
@RestController
public class OrderController {
    private final OrderRepository orderRepository;  // Bypass tầng nghiệp vụ
 
    @GetMapping("/{id}")
    public Order getOrder(@PathVariable Long id) {
        return orderRepository.findById(id).orElseThrow();  // Không áp dụng logic nghiệp vụ
    }
}

// ✅ Lớp sạch — mỗi lớp nói ngôn ngữ riêng của mình
@Service
public class OrderService {
    // Trả về domain objects, không phải HTTP responses
    public Order createOrder(CreateOrderCommand command) {
        // ...
        return savedOrder;  // Domain object, không phải HTTP response
    }
}
 
@RestController
public class OrderController {
    private final OrderService orderService;  // Chỉ nói chuyện với service
 
    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(@RequestBody CreateOrderRequest request) {
        Order order = orderService.createOrder(request.toCommand());
        return ResponseEntity.status(201).body(OrderResponse.from(order));
        // HTTP concerns được xử lý ở đây trong tầng trình bày
    }
}

// ❌ Anti-pattern: Logic nghiệp vụ trong controller
router.post('/orders', async (req, res) => {
  const { userId, items } = req.body;
 
  // Logic nghiệp vụ này thuộc về service
  for (const item of items) {
    const product = await productRepo.findById(item.productId);
    if (product.stock < item.quantity) {
      return res.status(400).json({ error: `Không đủ hàng cho ${product.name}` });
    }
  }
 
  const total = items.reduce((sum, item) => sum + item.price * item.quantity, 0);
  if (total < 10) {
    return res.status(400).json({ error: 'Giá trị đơn hàng tối thiểu là $10' });
  }
 
  // ...
});
 
// ✅ Controller ủy quyền, service xử lý logic
router.post('/orders', async (req, res) => {
  try {
    const order = await orderService.createOrder(req.body);
    res.status(201).json(OrderResponse.from(order));
  } catch (error) {
    if (error instanceof InsufficientStockError) {
      return res.status(400).json({ error: error.message });
    }
    if (error instanceof MinimumOrderValueError) {
      return res.status(400).json({ error: error.message });
    }
    throw error;
  }
});

// ❌ Anti-pattern: Logic nghiệp vụ trong repository
@Repository
public class OrderRepository {
    // Repository quyết định "gần đây" nghĩa là gì và cái gì là "quan trọng"
    // Đây là logic nghiệp vụ, không phải logic truy cập dữ liệu
    public List<Order> findImportantRecentOrders() {
        return entityManager.createQuery(
            "SELECT o FROM Order o " +
            "WHERE o.total > 500 " +           // Business rule: "quan trọng" là gì?
            "AND o.createdAt > :lastWeek " +   // Business rule: "gần đây" là gì?
            "AND o.status != 'CANCELLED'"      // Business rule: loại trừ đã hủy
        ).setParameter("lastWeek", LocalDateTime.now().minusWeeks(1))
         .getResultList();
    }
}
 
// ✅ Repository xử lý cơ chế, service ra quyết định
@Repository
public class OrderRepository {
    // Query chung — chỉ là data access concern
    public List<Order> findByStatusAndCreatedAfter(OrderStatus status, LocalDateTime since) {
        return entityManager.createQuery(
            "SELECT o FROM Order o WHERE o.status = :status AND o.createdAt > :since"
        ).setParameter("status", status)
         .setParameter("since", since)
         .getResultList();
    }
}
 
@Service
public class OrderService {
    // Logic nghiệp vụ nằm trong service
    public List<Order> findImportantRecentOrders() {
        LocalDateTime lastWeek = LocalDateTime.now().minusWeeks(1);
        List<Order> recentOrders = orderRepository.findByStatusAndCreatedAfter(
            OrderStatus.ACTIVE, lastWeek);
 
        // Business rule được áp dụng trong service
        return recentOrders.stream()
                .filter(order -> order.getTotal().compareTo(new BigDecimal("500")) > 0)
                .collect(toList());
    }
}

modules/
├── orders/
│   ├── OrderController.java
│   ├── OrderService.java
│   └── OrderRepository.java
├── products/
│   ├── ProductController.java
│   ├── ProductService.java
│   └── ProductRepository.java

// Unit test cho tầng service — mock repository
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
 
    @Mock
    private OrderRepository orderRepository;
 
    @Mock
    private ProductRepository productRepository;
 
    @InjectMocks
    private OrderService orderService;
 
    @Test
    void shouldThrowWhenProductOutOfStock() {
        // Arrange
        Product product = new Product("prod-1", "Widget", 5); // stock: 5
        given(productRepository.findById("prod-1")).willReturn(Optional.of(product));
 
        CreateOrderCommand command = new CreateOrderCommand(
            "user-1",
            List.of(new OrderItemCommand("prod-1", 10)) // Yêu cầu 10, chỉ có 5 trong kho
        );
 
        // Act + Assert
        assertThatThrownBy(() -> orderService.createOrder(command))
                .isInstanceOf(InsufficientStockException.class);
 
        verify(orderRepository, never()).save(any()); // Order không nên được lưu
    }
}
 
// Integration test cho tầng repository — test với database thực
@DataJpaTest
class OrderRepositoryTest {
 
    @Autowired
    private JpaOrderRepository orderRepository;
 
    @Test
    void shouldFindOrdersByUserId() {
        // ... test với H2 in-memory database
    }
}
 
// Integration test cho tầng trình bày — mock service
@WebMvcTest(OrderController.class)
class OrderControllerTest {
 
    @Autowired
    private MockMvc mockMvc;
 
    @MockBean
    private OrderService orderService;
 
    @Test
    void shouldReturn201WhenOrderCreated() throws Exception {
        given(orderService.createOrder(any())).willReturn(testOrder());
 
        mockMvc.perform(post("/api/orders")
                .contentType(APPLICATION_JSON)
                .content("""
                    {"userId": "1", "items": [{"productId": "p1", "quantity": 2}]}
                    """))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.id").exists());
    }
}