Giới thiệu

Trong phát triển phần mềm hiện đại, độ phức tạp ngày càng gia tăng. Nếu không có cấu trúc đúng, mã nguồn có thể trở nên mong manh, khó kiểm thử và tốn kém trong việc bảo trì. Kiến trúc sạch (Clean Architecture) cung cấp một triết lý thiết kế rõ ràng nhằm giải quyết những thách thức này bằng cách giữ cho logic kinh doanh cốt lõi độc lập với các framework, cơ sở dữ liệu và các công cụ bên ngoài khác. Điều này giúp ứng dụng của bạn duy trì tính khả thi, có thể kiểm thử và linh hoạt, ngay cả khi công nghệ thay đổi.

Bài viết này sẽ xem xét các nguyên tắc của Kiến trúc Sạch, cách tổ chức cấu trúc của nó và một ví dụ thực tế về việc triển khai.

Định nghĩa Kiến trúc Sạch

Định nghĩa chính thức:
Kiến trúc sạch là một triết lý thiết kế phần mềm tổ chức một ứng dụng thành các lớp độc lập, riêng biệt. Mục tiêu chính của nó là tách biệt các quy tắc kinh doanh cốt lõi khỏi các chi tiết triển khai như framework, cơ sở dữ liệu hay giao diện người dùng.

Bằng cách áp dụng sự tách biệt này, bạn có thể:

• Thay thế cơ sở dữ liệu mà không cần chạm vào logic kinh doanh của bạn.
• Thay đổi framework web mà không cần viết lại toàn bộ hệ thống.
• Kiểm thử các quy tắc cốt lõi mà không phụ thuộc vào các hệ thống bên ngoài chậm chạp và dễ hỏng.

Cấu trúc của Kiến trúc Sạch

Hãy tưởng tượng Kiến trúc Sạch như bốn vòng tròn đồng tâm, mỗi vòng tròn đại diện cho một lớp với trách nhiệm cụ thể:

Entities – Quy Tắc Kinh Doanh Doanh Nghiệp

• Chứa các mô hình miền cốt lõi và quy tắc.
• Độc lập với các framework, cơ sở dữ liệu hay thư viện.
• Được thiết kế để ổn định và có thể tái sử dụng trên nhiều ứng dụng khác nhau.

Use Cases – Quy Tắc Kinh Doanh Ứng Dụng

• Định nghĩa cách mà ứng dụng phản ứng với đầu vào.
• Điều phối giữa các entities và quy tắc kinh doanh.
• Không biết đến chi tiết của web, UI hay cơ sở dữ liệu.

Interface Adapters

• Chứa các controller, presenters, gateways và mappers.
• Điều chỉnh dữ liệu giữa các hệ thống bên ngoài và các lớp nội bộ.
• Chuyển đổi đầu vào/đầu ra thành các hình thức mà ứng dụng cốt lõi hiểu.

Frameworks & Drivers

• Bao gồm các cơ sở dữ liệu, framework web, hệ thống tệp hoặc các công cụ bên ngoài khác.
• Được coi là “chi tiết” thay vì bản chất của ứng dụng.
• Có thể được thay thế mà không ảnh hưởng đến logic kinh doanh.

Tầm quan trọng của Kiến trúc Sạch

Tách biệt nhiệm vụ: Mỗi lớp tập trung vào một mục đích duy nhất, giúp hệ thống dễ bảo trì và mở rộng.

Khả năng kiểm thử: Các quy tắc kinh doanh có thể được kiểm thử mà không cần đến cơ sở dữ liệu hay framework.

Tính linh hoạt: Thay đổi các framework, cơ sở dữ liệu hay lớp UI mà không chạm vào logic cốt lõi.

Khả năng mở rộng: Hỗ trợ sự phát triển và tích hợp mà không hy sinh cấu trúc.

Ví dụ thực tiễn

Ví dụ sau đây minh họa cách các nguyên tắc của Kiến trúc Sạch có thể được áp dụng trong thực tế, thể hiện sự tách biệt nhiệm vụ giữa các vòng tròn đồng tâm.

Đối tượng miền - Entities

package com.thedevhorse.cleanarchitecture.domain;

public class Athlete {

    private String athleteId;
    private String name;
    private int age;
    private Category category;

    private Athlete(String athleteId,
                    String name,
                    int age) {
        this.athleteId = athleteId;
        this.name = name;
        this.age = age;
        setCategory(age);
    }

    public static Athlete create(final String athleteId,
                                 final String name,
                                 final int age) {
        return new Athlete(athleteId, name, age);
    }

}

Đối tượng này đại diện cho thực thể kinh doanh cốt lõi. Nó độc lập với cơ sở hạ tầng, framework hay cơ sở dữ liệu.

Triển khai Use Case

package com.thedevhorse.cleanarchitecture.usecase;

public class AthleteUseCaseImpl implements AthleteInputPort {

    private final AthleteDaoOutputPort athleteDaoOutputPort;

    public AthleteUseCaseImpl(AthleteDaoOutputPort athleteDaoOutputPort) {
        this.athleteDaoOutputPort = athleteDaoOutputPort;
    }

    @Override
    public Athlete getAthlete(final String athleteId) {
        return athleteDaoOutputPort.getAthleteById(athleteId);
    }

    @Override
    public void createAthlete(final Athlete athlete) {
        athleteDaoOutputPort.createAthlete(athlete);
    }

    @Override
    public void updateAthlete(final Athlete athlete) {
        athleteDaoOutputPort.updateAthlete(athlete);
    }
}

Triển khai các quy tắc kinh doanh ứng dụng cụ thể, điều phối hành động giữa các port và entities.

Use Case - Port Đầu Vào

package com.thedevhorse.cleanarchitecture.usecase.port.in;

public interface AthleteInputPort {

    Athlete getAthlete(String athleteId);

    void createAthlete(Athlete athlete);

    void updateAthlete(Athlete athlete);

}

Định nghĩa hợp đồng cho các use case, bảo vệ việc triển khai khỏi các phụ thuộc bên ngoài.

Use Case - Port Đầu Ra

package com.thedevhorse.cleanarchitecture.usecase.port.out;

public interface AthleteDaoOutputPort {

   Athlete getAthleteById(String athleteId);

   void createAthlete(Athlete athlete);

   void updateAthlete(Athlete athlete);
}

Xác định cách mà use case tương tác với các lớp lưu trữ mà không cần biết chi tiết cơ sở dữ liệu thực tế.

Interface Adapters – Controller

package com.thedevhorse.cleanarchitecture.infra.controller;

@RestController
@RequestMapping("/api/athletes")
public class AthleteController {

    private final AthleteInputPort athleteInputPort;

    public AthleteController(AthleteInputPort athleteInputPort) {
        this.athleteInputPort = athleteInputPort;
    }

    @GetMapping("/{athleteId}")
    public AthleteResponse getAthlete(@PathVariable String athleteId) {
        return mapToAthleteResponse(
                athleteInputPort.getAthlete(athleteId)
        );
    }

    @PostMapping
    public void createAthlete(@RequestBody AthleteRequest athleteRequest) {
        athleteInputPort.createAthlete(
                mapToAthlete(athleteRequest)
        );
    }

    @PutMapping
    public void updateAthlete(@RequestBody  AthleteRequest athleteRequest) {
        athleteInputPort.updateAthlete(
                mapToAthlete(athleteRequest)
        );
    }
}

Đóng vai trò là cầu nối giữa các yêu cầu HTTP và use case, điều chỉnh dữ liệu đến và đi.

Frameworks & Drivers – DB

package com.thedevhorse.cleanarchitecture.infra.repository;

@Component
public class AthleteDaoImpl implements AthleteDaoOutputPort {

    private final AthleteRepository athleteRepository;

    public AthleteDaoImpl(AthleteRepository athleteRepository) {
        this.athleteRepository = athleteRepository;
    }

    @Override
    public Athlete getAthleteById(final String athleteId) {
        return mapToAthlete(findEntityById(athleteId));
    }

    @Override
    public void createAthlete(Athlete athlete) {
        athleteRepository.save(mapToAthleteEntity(athlete));
    }

    @Override
    public void updateAthlete(Athlete athlete) {
        AthleteEntity athleteEntity = findEntityById(athlete.athleteId());
        athleteEntity.setAge(athlete.age());
        athleteEntity.setName(athlete.name());

        athleteRepository.save(athleteEntity);
    }
}

Thực hiện các thao tác lưu trữ bằng cách sử dụng một framework và cơ sở dữ liệu cụ thể, được ẩn sau giao diện port đầu ra.

Kết luận

Bằng cách áp dụng Kiến trúc Sạch, bạn xây dựng các ứng dụng mà:

• Logic kinh doanh cốt lõi được tách biệt khỏi các chi tiết kỹ thuật.
• Nhiệm vụ được phân chia rõ ràng giữa các lớp.
• Framework và công cụ có thể thay thế mà không cần viết lại lõi kinh doanh.

Điều này dẫn đến các hệ thống linh hoạt, dễ bảo trì và có thể kiểm thử — sẵn sàng phát triển khi yêu cầu của bạn thay đổi.

Tài nguyên bổ sung

Để có hướng dẫn video từng bước về ví dụ này và giải thích sâu hơn về mẫu trong thực tế, hãy xem hướng dẫn đầy đủ:

🟥▶️Xem video

Hãy nhớ rằng, tốc độ thực sự không đến từ việc vội vàng. Nó đến từ việc làm đúng. Như Robert C. Martin đã nói, "Cách duy nhất để đi nhanh, là đi đúng."

Câu hỏi thường gặp (FAQ)

1. Kiến trúc sạch là gì?
Kiến trúc sạch là một triết lý thiết kế phần mềm giúp tách biệt logic kinh doanh cốt lõi khỏi các chi tiết triển khai, giúp dễ bảo trì và mở rộng.

2. Tại sao nên sử dụng kiến trúc sạch?
Sử dụng kiến trúc sạch giúp dễ dàng thay đổi các công nghệ và frameworks mà không làm ảnh hưởng đến logic cốt lõi của ứng dụng.

3. Đâu là điểm mạnh của kiến trúc sạch?
Kiến trúc sạch mang lại khả năng kiểm thử cao, tách biệt nhiệm vụ rõ ràng và khả năng mở rộng tốt cho ứng dụng của bạn.

Thực hành tốt nhất

• Tạo các lớp rõ ràng cho từng phần của ứng dụng để dễ bảo trì.
• Thực hiện kiểm thử tự động cho các quy tắc kinh doanh.

Những cạm bẫy thường gặp

• Không tách biệt rõ ràng các lớp, dẫn đến sự phụ thuộc lẫn nhau.
• Không kiểm thử các quy tắc kinh doanh độc lập.

Mẹo hiệu suất

• Sử dụng bộ nhớ cache cho các thao tác truy vấn cơ sở dữ liệu để cải thiện hiệu suất.
• Tối ưu hóa các truy vấn SQL để giảm thời gian phản hồi.

Tài liệu tham khảo

• Kiến trúc sạch - Uncle Bob