SOLID Principles: Dependency Inversion Principle

Hôm nay chúng ta cùng nhau đến với bài viết cuối cùng, nguyên lý cuối cùng của SOLID Dependency Inversion Principle.

1. Các module cấp cao không nên phụ thuộc vào các modules cấp thấp. Cả 2 nên phụ thuộc vào abstraction.

2. Abstraction không nên phụ thuộc vào chi tiết, mà ngược lại.

Ở đây ta có một ví dụ về việc code không theo Dependency Inversion Principle (DIP).

package com.gkatzioura.solid.di;
 public class BackEndDeveloper {
     public void writeJava() {
     }
 }

package com.gkatzioura.solid.di;
 public class FrontEndDeveloper {
     public void writeJavascript() {
     }
 }

package com.gkatzioura.solid.di;
 public class Project {
     private BackEndDeveloper backEndDeveloper = new BackEndDeveloper();
     private FrontEndDeveloper frontEndDeveloper = new FrontEndDeveloper();
     public void implement() {
         backEndDeveloper.writeJava();
         frontEndDeveloper.writeJavascript();
     }
 }

Với cấu trúc code như thế này, nếu class Project cần nhiều deverloper hơn ta sẽ liên tục phải sửa code trong class Project.
Nếu thằng BackendDeveloper chuyển từ viết Java sang viết PHP thì chúng ta lại tiếp tục sửa đổi nhiều class vì chúng đang bị phụ thuộc lẫn nhau. Ta có thể áp dụng DIP vào đây như sau.

package com.gkatzioura.solid.di;
 public interface Developer {
     void develop();
 }

package com.gkatzioura.solid.di;
 public class BackEndDeveloper implements Developer {
     @Override
     public void develop() {
         writeJava();
     }
     private void writeJava() {
     }
 }

package com.gkatzioura.solid.di;
 public class FrontEndDeveloper implements Developer {
     @Override
     public void develop() {
         writeJavascript();
     }
     public void writeJavascript() {
     }
 }

package com.gkatzioura.solid.di;
 import java.util.List;
 public class Project {
     private List developers;
     public Project(List developers) {
         this.developers = developers;
     }
     public void implement() {
         developers.forEach(d->d.develop());
     }
 }

Và thế là ta đã có class Project không phụ thuộc vào module cấp thấp mà phụ thuộc vào abstractions. Ngoài ra các modue cấp thấp và chi tiết của chúng phụ thuộc vào absstractions.

DIP được sử dụng rất nhiều. Tất nhiên có cũng có những ưu nhược điểm. Bên cạnh đó vẫn có nhiều sự tranh cãi về việc áp dụng DIP

Ưu điểm: Giảm sự kết dính giữa các module, Code dễ bảo trì thay thế, Dễ viết Unit test.

Nhược điểm: Khái niệm khó hiểu, Sử dụng Interface dẫn đến khó debug, Làm tăng độ phức tạp của code

Vậy là chúng ta đã kết thúc series SOLID. Hy vọng nó sẽ có ích cho các bạn trong việc thiết kế, viết code.
Hãy hiểu những nguyên lý này như những hướng dẫn giúp code của bạn đẹp hơn dễ bảo trì hơn. Nhưng tất nhiên nếu áp dụng không đúng lúc đúng chỗ nó sẽ cho tác dụng ngược lại.
Ta cần biết về nó và áp dụng một cách mềm dẻo.
Chúc các bạn trở thành những developer giỏi và yêu nghề nhé.