Design Pattern: Dependency Injection

Khi thực hiện những dự án với độ phức tạp cao ngoài việc thiết kế tính năng cho ứng dụng, tổ chức code luôn là vấn đề được đặt lên hàng đầu. Tổ chức tốt giúp dễ dàng bảo trì và mở rộng code về sau.

Dependency Injection là gì?

Trong lập trình hướng đối tượng các class được liên kết với nhau theo một mối quan hệ nào đó. Dependency là một loại quan hệ giữa 2 class mà trong đó 1 class hoạt động độc lập và class còn lại phụ thuộc bởi class kia. Ví dụ, có 2 class Wheel và class Bicycle, trong class Bicycle có chứa 1 biến toàn cục kiểu class Wheel. 

public class Wheel{
	...
	public Wheel(){
		...
	}
	
	public void Roll(){
		...
	}
}

public class Bicycle{
	public Wheel _wheel;
	
	public void Bicycle(){
		_wheel = new Wheel();
	}
	
	public void Run(){
		_wheel.Roll();
	}
}

public class Application{
	public Bicycle _bicycle;
	
	public Application(){
		_bicycle = new Bicycle();
	}
	
	public Start(){
		Bicycle.Run();
	}
}

Đây là 1 trong những cách hiện thực quen thuộc nhưng với cách thiết kế này sẽ sinh ra sự phụ thuộc code giữa class Bicycle và Wheel. Wheel được khởi tạo trong constructor của Bicycle, giả sử trong tương lai muốn sử dụng 1 loại Wheel khác, lúc này phải thay đổi rất nhiều trong class Bicycle, hay đơn giản muốn chỉnh sửa trong class Wheel cũ, không có gì để đảm bảo chắc chắn rằng Bicycle vẫn có thể hoạt động tốt mà không cần trải qua 1 sự nâng cấp nào.

Dependency Injection là 1 dạng design pattern được thiết kế nhằm ngăn chặn sự phụ thuộc nêu trên, điều này giúp giảm chi phí trong việc sửa đổi và nâng cấp hệ thống. Nhờ vậy khi thực thiện thay đổi 1 class A thì những class chứa biến kiểu class A cũng không cần phải thay đổi theo.

Cách hiện thực

Dependency Injection có thể được hiện thực dựa trên các quy tắc sau:

• Các class sẽ không phụ thuộc trực tiếp lẫn nhau mà thay vào đó chúng sẽ liên kết với nhau thông qua 1 Interface hoặc base class (đối với một số ngôn ngữ không hỗ trợ Interface).
• Việc khởi tạo các class sẽ do các Interface quản lí thay vì class phụ thuộc nó.

public interface IWheel{
	void Roll();
}

public class WoodenWheel implements IWheel{
	@Override
	public void Roll(){
		....
	}
}

//--------------------------------------------------------------

public interface IBicycle{
	void Run();
}

public class SmartBike implements IBicycle{
	private IWheel _wheel;
	
	public SmartBike(IWheel wheel){
		this._wheel = wheel;
	}
	
	@Override
	public void Run(){
		_wheel.Roll();
	}
}

//--------------------------------------------------------------

public interface WheelInjector{
	public IBicycle getBicycle();
}

public class WoodenWheelInjector implements WheelInjector{
	public IBicycle getBicycle(){
		return new SmartBike(new WoodenWheel());
	}
}

//--------------------------------------------------------------

public class Application{
	public WheelInjector injector = null;
	private SmartBike _bicycle;
		
	public Application(){
		injector = new WoodenWheelInjector();
        _bicycle = injector.getBicycle();
	}
	
	public Start(){
		_bicycle.Run();
	}
}