Skip to content
TungDaDev's Blog

SOLID trong Java: 5 nguyên tắc qua bài toán tài khoản ngân hàng

Solid.webp
Published on
11 mins read

Chắc bạn đã từng đụng những codebase mà chỉ sửa lại câu chữ in sao kê cũng làm vỡ luôn logic trừ tiền, hoặc một class kế thừa class cha xong phải viết throw new UnsupportedOperationException() ở nửa số hàm vì không biết làm gì với chúng. Năm nguyên tắc SOLID ra đời để trị đúng những căn bệnh thiết kế hướng đối tượng kiểu đó.

SOLID do Robert C. Martin (hay còn gọi là Uncle Bob) đúc kết lại trong bài viết "Design Principles and Design Patterns" (2000), còn cái tên viết tắt SOLID thì do Michael Feathers đặt sau đó vài năm. Thực ra không phải nguyên tắc nào cũng do Uncle Bob tự nghĩ ra: Open/Closed là của Bertrand Meyer (1988), còn Liskov Substitution là của Barbara Liskov (1987).

Bắt đầu thôiii :)))

# single responsibility principle (srp)

Phát biểu quen thuộc nhất của SRP là "một class chỉ nên có một lý do để thay đổi". Nói cụ thể hơn, mỗi class hay hàm chỉ nên phục vụ một mục đích rõ ràng; khi phát sinh thay đổi, phạm vi sửa chỉ gói gọn trong đúng nhiệm vụ đó chứ không lan sang những phần chẳng liên quan:

/*
* Violates SRP
*/
public class BankAccount {
    private double balance;
 
    public void deposit(double amount) {
        balance += amount;
    }
 
    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            System.out.println("Insufficient funds");
        }
    }
 
    public void printBalance() {
        System.out.println("Current balance: " + balance);
    }
}

Đoạn code trên vi phạm SRP: chỉ cần yêu cầu đổi, chẳng hạn hiển thị số dư theo định dạng khác, là phải sửa class BankAccount, trong khi class này đáng ra chỉ lo chuyện tiền trong tài khoản.

"Lý do để thay đổi" ở đây nên hiểu là ai yêu cầu thay đổi. Về sau Uncle Bob nói rõ hơn: một module chỉ nên chịu trách nhiệm trước một nhóm người dùng (actor). Quy tắc tính tiền do bên nghiệp vụ quyết, còn cách hiển thị do bên làm giao diện hay báo cáo quyết. Hai nhóm này đổi ý vào những lúc khác nhau, nên tách ra thì sửa bên này không làm vỡ bên kia.

(Ví dụ dùng double cho gọn; tiền thật thì nên dùng BigDecimal hoặc lưu số nguyên theo đơn vị nhỏ nhất, vì double cộng trừ bị sai số làm tròn.)

Cách xử lý là tách thành hai class, mỗi class một nhiệm vụ.

/*
* Follows SRP
*/
public class BankAccount {
    private double balance;
 
    public void deposit(double amount) {
        balance += amount;
    }
 
    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            throw new IllegalArgumentException("Insufficient funds");
        }
    }
 
    public double getBalance() {
        return balance;
    }
}
 
public class BalanceDisplayer {
    public void printBalance(BankAccount account) {
        System.out.println("Current balance: " + account.getBalance());
    }
}

# open/closed principle (ocp)

Nguyên tắc Đóng/Mở nói rằng một thành phần phần mềm nên mở cho việc mở rộng (open for extension), nhưng đóng với việc chỉnh sửa (closed for modification). Tức là khi cần thêm hành vi mới, bạn viết thêm code mới cắm vào chứ không phải mở class cũ đang chạy ổn định ra đập đi sửa lại.

Tiếp nối ví dụ trên, giả sử giờ mình muốn hiển thị số dư theo nhiều định dạng khác nhau. Nếu cứ mỗi lần thêm một kiểu in lại mở BalanceDisplayer ra chèn thêm nhánh if/else, sớm muộn class đó cũng thành một đống bùi nhùi. Thay vào đó, ta rút ra một interface chung để muốn thêm định dạng mới thì chỉ việc viết class mới:

/*
* Interface for balance display
*/
public interface BalanceDisplay {
    void displayBalance(BankAccount account);
}
 
/*
* Implementation for displaying balance in a simple format
*/
public class SimpleBalanceDisplay implements BalanceDisplay {
    @Override
    public void displayBalance(BankAccount account) {
        System.out.println("Current balance: " + account.getBalance());
    }
}
 
/*
* Implementation for displaying balance in a fancy format
*/
public class FancyBalanceDisplay implements BalanceDisplay {
    @Override
    public void displayBalance(BankAccount account) {
        System.out.println("Fancy Balance: $" + account.getBalance() + " ~~~");
    }
}

Muốn thêm định dạng mới (JSON, HTML...) thì viết thêm một class implement BalanceDisplay, code đang gọi displayBalance không phải sửa dòng nào. "Đóng" ở đây là đóng với chỉnh sửa, chứ không phải không bao giờ được đụng vào. Cũng đừng dựng interface cho mọi thứ từ đầu: chỗ nào thật sự hay thay đổi theo kiểu "thêm một loại mới" thì mới đáng mở điểm mở rộng.

# liskov substitution principle (lsp)

Barbara Liskov định nghĩa nguyên tắc này từ góc độ hệ thống kiểu: nếu B là kiểu con (subtype) của A, thì bất kỳ chỗ nào trong chương trình đang nhận một đối tượng kiểu A, ta đều có thể truyền đối tượng kiểu B vào thay thế mà chương trình vẫn chạy đúng như kỳ vọng ban đầu:

// Giả sử BankAccount có thêm constructor BankAccount(double initialBalance)
 
/*
* Subclass SavingsAccount
*/
public class SavingsAccount extends BankAccount {
    public SavingsAccount(double balance) {
        super(balance);
    }
 
    /*
    * Additional functionality specific to SavingsAccount
    */
    public void calculateInterest() {
        // Calculate interest for savings account
    }
}
 
public class GoldAccount extends BankAccount {
    private double bonusPoints;
 
    public GoldAccount(double balance, double bonusPoints) {
        super(balance);
        this.bonusPoints = bonusPoints;
    }
 
    @Override
    public void deposit(double amount) {
        super.deposit(amount + (bonusPoints * 0.1)); // Adds bonus points to the deposit
    }
}

Class SavingsAccount tuân thủ LSP: nó chỉ thêm method riêng như calculateInterest, còn cách gửi và rút tiền vẫn y như class cha.

Class GoldAccount thì vi phạm LSP vì đổi hành vi của method deposit so với class cha BankAccount.

Nói cho chính xác thì override không tự nó là vi phạm. Vi phạm là khi class con phá lời hứa (contract) mà code gọi class cha đang dựa vào. Với BankAccount, lời hứa ngầm là "gửi x thì số dư tăng đúng x". Một đoạn đối soát kiểu assert after - before == amount chạy đúng với BankAccount, SavingsAccount, nhưng sai với GoldAccount. Muốn có thưởng thì nên tách ra thành thao tác riêng (ví dụ addBonus()), để deposit giữ đúng nghĩa ban đầu.

# interface segregation principle (isp)

Nguyên tắc Phân tách Interface nhắc chúng ta đừng bắt client phải phụ thuộc vào những method mà nó chẳng bao giờ gọi tới. Thay vì gom đủ thứ vào một "fat interface" (interface béo phì) bắt mọi class con phải cài đặt cho đủ bộ, hãy tách thành các interface nhỏ gọn theo từng nhóm vai trò cụ thể:

/*
* Violation of ISP
*/
public interface IBankAccount {
    void deposit(double amount);
    void withdraw(double amount);
    double getBalance();
    void printStatement();
    void requestLoan();
}
 
public class BankAccount implements IBankAccount {
    private double balance;
 
    public void deposit(double amount) {
        // implementation details
    }
 
    public void withdraw(double amount) {
        // implementation details
    }
 
    public double getBalance() {
        // implementation details
    }
 
    public void printStatement() {
        // implementation details
    }
 
    public void requestLoan() {
        // implementation details
    }
}

Interface IBankAccount vi phạm ISP vì chứa những method mà không phải class nào implement nó cũng cần.

Class BankAccount phải implement hết IBankAccount, dù có thể chẳng cần method requestLoan.

/*
* Adheres to ISP
* Interface for account management
*/
public interface AccountManager {
    void deposit(double amount);
    void withdraw(double amount);
    double getBalance();
}
 
/*
* Interface for account reporting
*/
public interface AccountReporter {
    void printStatement();
}
 
/*
* Interface for loan management
*/
public interface LoanManager {
    void requestLoan();
}

Giờ mỗi class chỉ phụ thuộc vào những interface đúng với trách nhiệm của nó, đúng tinh thần ISP. Ví dụ tài khoản thanh toán thông thường chỉ cần implements AccountManager, AccountReporter, còn class nào hỗ trợ vay mới implement thêm LoanManager. Lợi ích còn nằm ở phía người dùng interface: màn hình in sao kê chỉ cần nhận AccountReporter, nên đổi gì ở phần vay cũng không làm nó phải biên dịch hay test lại.

# dependency inversion principle (dip)

Nguyên tắc cuối cùng phát biểu hai ý gắn liền với nhau: module cấp cao không nên phụ thuộc trực tiếp vào module cấp thấp mà cả hai nên phụ thuộc vào trừu tượng (abstraction); đồng thời, bản thân phần trừu tượng không được phụ thuộc vào chi tiết cài đặt, mà chi tiết phải phụ thuộc ngược vào trừu tượng.

Thử nghĩ tới quán cà phê đầu hẻm nhà bạn. Chủ quán không ký hợp đồng riêng với Vietcombank, Techcombank, MoMo..., cũng không cần biết khách dùng ngân hàng nào. Quán chỉ dán một tấm mã QR lên quầy và nói: "muốn trả tiền thì quét mã". Ngân hàng hay ví điện tử nào muốn khách của mình trả được tiền ở đây thì tự lo hỗ trợ quét mã đó. Quán (module cấp cao) và ngân hàng (module cấp thấp) không biết gì về nhau, cả hai cùng dựa vào một thứ trừu tượng là "thanh toán qua mã QR". Mai có thêm một ví điện tử mới thì quán cũng chẳng phải đổi gì. Ví dụ code dưới đây đúng là chuyện thanh toán như vậy.

/*
* Violates DIP
*/
public class ShoppingMall {
    private BankAccount bankAccount;
 
    public ShoppingMall(BankAccount bankAccount) {
        this.bankAccount = bankAccount;
    }
 
    public void doPayment(String order, double amount) {
        bankAccount.withdraw(amount);
        // Process the payment
    }
}

Ở ví dụ này, ShoppingMall (module cấp cao) phụ thuộc trực tiếp vào BankAccount (module cấp thấp), nên vi phạm DIP.

Cách sửa là thêm một lớp trừu tượng để cả ShoppingMall và BankAccount cùng phụ thuộc vào.

/*
* Adhering to DIP
*/
public interface PaymentProcessor {
    void processPayment(double amount);
}
 
 
public class BankAccount implements PaymentProcessor {
    // implementation details
}
 
public class ShoppingMall {
    private PaymentProcessor paymentProcessor;
 
    public ShoppingMall(PaymentProcessor paymentProcessor) {
        this.paymentProcessor = paymentProcessor;
    }
 
    public void doPayment(String order, double amount) {
        paymentProcessor.processPayment(amount);
        // Process the payment
    }
}

Chữ "inversion" nằm ở chỗ ai sở hữu interface. PaymentProcessor nên được định nghĩa theo nhu cầu của ShoppingMall và đặt cùng package với nó (vì thế mình bỏ getBalance() khỏi interface, ShoppingMall không dùng tới). Khi đó chiều phụ thuộc ở mức source code bị đảo lại: module cấp thấp phải theo interface của module cấp cao, chứ không phải ngược lại. Thực tế cũng ít khi bắt BankAccount implement thẳng interface thanh toán, thường sẽ có một adapter kiểu BankAccountPaymentProcessor bọc BankAccount bên trong, sau này thêm ví điện tử hay thẻ tín dụng thì chỉ viết thêm adapter.

Cũng đừng nhầm DIP với Dependency Injection. Constructor nhận PaymentProcessor từ ngoài vào là DI, một kỹ thuật giúp làm DIP cho tiện; còn DIP là nguyên tắc về hướng phụ thuộc. Truyền vào qua constructor mà kiểu vẫn là class cụ thể BankAccount, như ví dụ vi phạm ở trên, thì vẫn chưa đạt DIP.

# lời kết

Đừng hiểu SOLID theo kiểu giáo điều là hễ viết một class mới cũng phải đẻ kèm một interface chỉ có đúng một bản cài đặt. SOLID dùng tốt nhất lúc review thiết kế hoặc gỡ rối một module đang phình to. Lần tới mở một class to nhất trong project, thử hỏi năm câu:

  • Class này đang phục vụ mấy nhóm người dùng? (SRP)
  • Chỗ đang phải if/else theo loại có đáng rút thành interface không? (OCP)
  • Class con có đang lén phá lời hứa của class cha không? (LSP)
  • Interface có đang ép người dùng gánh thêm hàm thừa không? (ISP)
  • Tầng nghiệp vụ có đang bị trói chặt vào chi tiết hạ tầng bên dưới không? (DIP)

Câu nào trả lời làm bạn ngập ngừng thì đó là chỗ nên sửa trước.

Chỉ là những ghi chép cá nhân với hy vọng mang lại chút giá trị. Nếu thấy hữu ích, đừng ngại chia sẻ cho bạn bè & đồng nghiệp nhé!

Happy coding 😎 👍🏻 🚀 🔥.

Reference: