Hướng dẫn Java Design Pattern – Strategy

Có một vài trường hợp, các lớp chỉ khác nhau về hành vi của chúng. Trong trường hợp như vậy, ý tưởng tốt là chúng ta sẽ tách biệt các thuật toán trong các lớp riêng biệt để có khả năng lựa chọn các thuật toán khác nhau trong thời gian chạy (run-time). Ý tưởng này được gọi là Strategy Pattern, một pattern giúp chúng ta giải quyết vấn đề về sự thay đổi, tương tự như State Design Pattern.

1. Strategy Pattern là gì?

Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from the clients that use it.

Strategy Pattern là một trong những Pattern thuộc nhóm hành vi (Behavior Pattern). Nó cho phép định nghĩa tập hợp các thuật toán, đóng gói từng thuật toán lại, và dễ dàng thay đổi linh hoạt các thuật toán bên trong object. Strategy cho phép thuật toán biến đổi độc lập khi người dùng sử dụng chúng.

Ý nghĩa thực sự của Strategy Pattern là giúp tách rời phần xử lý một chức năng cụ thể ra khỏi đối tượng. Sau đó tạo ra một tập hợp các thuật toán để xử lý chức năng đó và lựa chọn thuật toán nào mà chúng ta thấy đúng đắn nhất khi thực thi chương trình. Mẫu thiết kế này thường được sử dụng để thay thế cho sự kế thừa, khi muốn chấm dứt việc theo dõi và chỉnh sửa một chức năng qua nhiều lớp con.

2. Cài đặt Strategy Pattern như thế nào?

Các thành phần tham gia Strategy Pattern:

• Strategy : định nghĩa các hành vi có thể có của một Strategy.
• ConcreteStrategy : cài đặt các hành vi cụ thể của Strategy.
• Context : chứa một tham chiếu đến đối tượng Strategy và nhận các yêu cầu từ Client, các yêu cầu này sau đó được ủy quyền cho Strategy thực hiện.

2.1. Ví dụ Strategy Pattern với ứng dụng sắp xếp

Chương trình của chúng ta cung cấp nhiều giải thuật sắp xếp khác nhau: quick sort, merge sort, selection sort, heap sort, tim sort, …. Tùy theo loại dữ liệu, số lượng phần tử, … mà người dùng có thể chọn một giải thuật sắp xếp phù hợp.

SortStrategy.java

package com.maixuanviet.patterns.behavioral.strategy.sort;
 
import java.util.List;
 
public interface SortStrategy {
 
    <T> void sort(List<T> items);
}

QuickSort.java

package com.maixuanviet.patterns.behavioral.strategy.sort;
 
import java.util.List;
 
public class QuickSort implements SortStrategy {
 
    @Override
    public <T> void sort(List<T> items) {
        System.out.println("Quick sort");
    }
}

MergeSort.java

package com.maixuanviet.patterns.behavioral.strategy.sort;
 
import java.util.List;
 
public class MergeSort implements SortStrategy {
 
    @Override
    public <T> void sort(List<T> items) {
        System.out.println("Merge sort");
    }
}

SelectionSort.java

package com.maixuanviet.patterns.behavioral.strategy.sort;
 
import java.util.List;
 
public class SelectionSort implements SortStrategy {
 
    @Override
    public <T> void sort(List<T> items) {
        System.out.println("Selection sort");
    }
}

SortedList.java

package com.maixuanviet.patterns.behavioral.strategy.sort;

import java.util.ArrayList;
import java.util.List;

public class SortedList {

	private SortStrategy strategy;
	private List<String> items = new ArrayList<>();
	
	public void setSortStrategy(SortStrategy strategy) {
		this.strategy = strategy;
	}

	public void add(String name) {
		items.add(name);
	}

	public void sort() {
		strategy.sort(items);
	}
}

SortStrategy.java

package com.maixuanviet.patterns.behavioral.strategy.sort;
 
import java.util.ArrayList;
import java.util.List;
 
public class SortedList {
 
    private SortStrategy strategy;
    private List<String> items = new ArrayList<>();
     
    public void setSortStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }
 
    public void add(String name) {
        items.add(name);
    }
 
    public void sort() {
        strategy.sort(items);
    }
}

StrategyPatternExample.java

package com.maixuanviet.patterns.behavioral.strategy.sort;
 
public class StrategyPatternExample {
 
    public static void main(String[] args) {
 
        SortedList sortedList = new SortedList();
        sortedList.add("Java Core");
        sortedList.add("Java Design Pattern");
        sortedList.add("Java Library");
        sortedList.add("Java Framework");
 
        sortedList.setSortStrategy(new QuickSort());
        sortedList.sort();
 
        sortedList.setSortStrategy(new MergeSort());
        sortedList.sort();
    }
}

Output của chương trình:

Quick sort
Merge sort

2.2. Ví dụ Strategy Pattern với ứng dụng thanh toán online

CreditCardStrategy.java

package com.maixuanviet.patterns.behavioral.strategy.payment;

public class CreditCardStrategy implements PaymentStrategy {

	private String name;
	private String cardNumber;
	private String cvv;
	private String dateOfExpiry;

	public CreditCardStrategy(String nm, String ccNum, String cvv, String expiryDate) {
		this.name = nm;
		this.cardNumber = ccNum;
		this.cvv = cvv;
		this.dateOfExpiry = expiryDate;
	}

	@Override
	public void pay(int amount) {
		System.out.println(amount + " paid with credit/debit card");
	}

}

Item.java

package com.maixuanviet.patterns.behavioral.strategy.payment;

public class Item {

	private String upcCode;
	private int price;

	public Item(String upc, int cost) {
		this.upcCode = upc;
		this.price = cost;
	}

	public String getUpcCode() {
		return upcCode;
	}

	public int getPrice() {
		return price;
	}

}

PaymentStrategy.java

package com.maixuanviet.patterns.behavioral.strategy.payment;

public interface PaymentStrategy {

	void pay(int amount);
}

PaypalStrategy.java

package com.maixuanviet.patterns.behavioral.strategy.payment;

public class PaypalStrategy implements PaymentStrategy {

	private String emailId;
	private String password;

	public PaypalStrategy(String email, String pwd) {
		this.emailId = email;
		this.password = pwd;
	}

	@Override
	public void pay(int amount) {
		System.out.println(amount + " paid using Paypal.");
	}

}

ShoppingCart.java

package com.maixuanviet.patterns.behavioral.strategy.payment;

import java.util.ArrayList;
import java.util.List;

public class ShoppingCart {

	private List<Item> items = new ArrayList<>();

	public void addItem(Item item) {
		this.items.add(item);
	}

	public void removeItem(Item item) {
		this.items.remove(item);
	}

	public int calculateTotal() {
		int sum = 0;
		for (Item item : items) {
			sum += item.getPrice();
		}
		return sum;
	}

	public void pay(PaymentStrategy paymentMethod) {
		int amount = calculateTotal();
		paymentMethod.pay(amount);
	}
}

StrategyPatternExample.java

package com.maixuanviet.patterns.behavioral.strategy.payment;

public class StrategyPatternExample {

	public static void main(String[] args) {
		ShoppingCart cart = new ShoppingCart();

		Item item1 = new Item("Elements of Reusable Object-Oriented Software – GOF", 40);
		Item item2 = new Item("Design Pattern for Dummy", 50);

		cart.addItem(item1);
		cart.addItem(item2);

		// pay by paypal
		cart.pay(new PaypalStrategy("javadesignpattern@maixuanviet.com", "LapTrinhJava"));

		// pay by credit card
		cart.pay(new CreditCardStrategy("GP Coder", "1234567890", "407", "10/17"));
	}
}

3. Lợi ích của Strategy Pattern là gì?

• Đảm bảo nguyên tắc Single responsibility principle (SRP) : một lớp định nghĩa nhiều hành vi và chúng xuất hiện dưới dạng với nhiều câu lệnh có điều kiện. Thay vì nhiều điều kiện, chúng ta sẽ chuyển các nhánh có điều kiện liên quan vào lớp Strategy riêng lẻ của nó.
• Đảm bảo nguyên tắc Open/Closed Principle (OCP) : chúng ta dễ dàng mở rộng và kết hợp hành vi mới mà không thay đổi ứng dụng.
• Cung cấp một sự thay thế cho kế thừa.

4. Sử dụng Strategy Pattern khi nào?

• Khi muốn có thể thay đổi các thuật toán được sử dụng bên trong một đối tượng tại thời điểm run-time.
• Khi có một đoạn mã dễ thay đổi, và muốn tách chúng ra khỏi chương trình chính để dễ dàng bảo trì.
• Tránh sự rắc rối, khi phải hiện thực một chức năng nào đó qua quá nhiều lớp con.
• Cần che dấu sự phức tạp, cấu trúc bên trong của thuật toán.

5. So sánh Strategy Pattern vs State Pattern

Sự phụ thuộc (dependency):

• State Pattern đi kèm với một chút phụ thuộc trong các lớp con, chẳng hạn một State biết về các trạng thái khác xuất hiện trước/ sau nó. Ví dụ: tín hiệu đèn giao thông như đèn đỏ -> đèn xanh -> đèn vàng, ứng dụng workflow nơi mà chúng có thể biết được bước trước và sau nó làm gì.
• Strategy Pattern không có sự phụ thuộc như State. Bất kỳ loại trạng thái nào cũng có thể được khởi tạo một cách độc lập, chúng không biết được sự tồn tại của các Strategy khác. Ví dụ: người dùng có thể lựa chọn giải thuật sắp xếp, phương thức thanh toán, nén file rar/zip, xuất báo cáo ra file excel/ csv, …

Mục đích sử dụng (intent) :

• Strategy Pattern quyết định cách thực hiện một số hành động, sử dụng Strategy khi chúng ta cần  trả lời how.
• Trong khi State Pattern quyết định khi nào để thực hiện chúng, sử dụng Strategy khi chúng ta cần  trả lời when/ what (state or type).

Thời điểm khởi tạo (binding time):

• Strategy Pattern là một mô hình khởi tạo một lần, không có sự luân chuyển trạng thái.
• Trong khi State  Pattern thì năng động hơn (có thể nhiều lần), có sự luân chuyển từ trạng thái này sang trạng thái khác. State Pattern có thể coi là trường hợp mở rộng của Strategy Pattern.