Strategy pattern với Spring Boot: ít class thừa, bean không giữ state

- Published on
- 10 mins read
Mã khuyến mãi giảm 10.000 đồng. Đơn đầu tiên trong ngày được giảm 10.000, đơn thứ hai 20.000, đơn thứ ba 30.000. Không ai sửa cấu hình. Lỗi nằm trong một class Strategy nhìn rất vô hại, và phần cuối bài sẽ mổ nó ra.
Strategy Pattern là một trong những mẫu thiết kế quen thuộc nhất, mà vẫn hay bị dùng máy móc theo sách giáo khoa cũ: đẻ ra cả tá class con, mỗi class chỉ chứa đúng một hàm 3 dòng, cây thư mục thành mê cung. Từ khi Java 8 cho hàm làm "công dân hạng nhất" (First-Class Functions), cộng thêm Dependency Injection của Spring Boot, cách viết Strategy đã gọn hơn hẳn: bớt class thừa mà vẫn giữ type-safety.
Tính chiết khấu đơn hàng trong E-Commerce, chọn thuật toán nén dữ liệu, chọn thuật toán mã hoá trong FinTech: chỗ nào cũng cần tách phần thuật toán hay thay đổi ra khỏi luồng điều phối nghiệp vụ. Strategy Pattern làm đúng việc đó.
# Strategy vs state vs template method
Ba behavioral pattern này hay bị nhầm vì nhìn Class Diagram thì na ná nhau:
# bảng so sánh chi tiết
| Tiêu chí | Strategy Pattern | State Pattern | Template Method Pattern |
|---|---|---|---|
| Cách cài đặt | Composition (uỷ quyền) | Composition (uỷ quyền) | Inheritance (kế thừa) |
| Ai quyết định đổi? | Client hoặc Service Context chọn strategy phù hợp | Các State tự chuyển qua lại với nhau | Chốt cứng lúc biên dịch (Compile-time) |
| Dùng để làm gì | Đổi qua lại giữa các thuật toán độc lập | Quản lý vòng đời trạng thái của object | Dùng lại khung logic chung |
| Có giữ trạng thái không | Strategy thường Stateless (không giữ trạng thái) | State thường giữ ngữ cảnh để chuyển đổi | Tuỳ vào cây kế thừa |
Nếu chỉ vẽ sơ đồ lớp UML, Strategy và State trông gần như giống hệt nhau: cả hai đều có một class Context giữ tham chiếu tới một interface rồi uỷ quyền lời gọi xuống cho implementation bên dưới. Điểm khác nhau nằm ở quyền điều khiển sự thay đổi: với Strategy, các thuật toán hoàn toàn không biết sự tồn tại của nhau, phía gọi bên ngoài (Client hoặc Engine) chủ động lắp một thuật toán vào để tính toán rồi thôi. Ngược lại, với State Pattern, bản thân đối tượng đang đi qua một vòng đời (như đơn hàng chuyển từ Draft → Paid → Shipped), và chính trạng thái hiện tại biết rõ quy tắc để tự chuyển Context sang trạng thái kế tiếp.
# từ Java 8 trở đi: lambda thay cho đống class thừa
Trước Java 8, muốn có 3 cách định dạng ngày tháng thì phải tạo 1 Interface và 3 Class riêng:
# viết gọn bằng functional interfaces
Không cần tạo class RoadShipping, SeaShipping nữa, chỉ cần dùng BiFunction<BigDecimal, BigDecimal, BigDecimal> hoặc tự định nghĩa một @FunctionalInterface. Tự định nghĩa thường dễ đọc hơn: tên ShippingCalculator.calculate(weightKg, distanceKm) nói rõ ý nghĩa hơn BiFunction.apply(a, b). Và với tiền thì dùng BigDecimal, đừng dùng Double vì sai số dấu phẩy động (0.1 + 0.2 ra 0.30000000000000004).
@FunctionalInterface
public interface ShippingCalculator {
BigDecimal calculate(BigDecimal weightKg, BigDecimal distanceKm);
}
// Bảng biểu diễn chiến lược dưới dạng Lambda hoặc Static Method References:
public class ShippingStrategies {
public static final ShippingCalculator ROAD =
(weight, distance) -> weight.multiply(new BigDecimal("1.5")).add(distance.multiply(new BigDecimal("0.5")));
public static final ShippingCalculator SEA =
(weight, distance) -> weight.multiply(new BigDecimal("1.0")).add(distance.multiply(new BigDecimal("0.2")));
public static final ShippingCalculator AIR =
(weight, distance) -> weight.multiply(new BigDecimal("2.5")).add(distance.multiply(new BigDecimal("1.0")));
}Ở tầng Controller / Service, đổi strategy giờ nhẹ nhàng hẳn:
public class ShippingService {
public BigDecimal computeCost(BigDecimal weight, BigDecimal dist, ShippingCalculator calculator) {
return calculator.calculate(weight, dist); // Nhận trực tiếp bất kỳ Lambda nào!
}
}
// Gọi thực thi:
shippingService.computeCost(w, d, ShippingStrategies.AIR);
// Hoặc truyền trực tiếp inline lambda cho chương trình khuyến mãi đặc biệt:
shippingService.computeCost(w, d, (weight, dist) -> BigDecimal.ZERO); // Miễn phí vận chuyển# ví dụ cỡ enterprise: dynamic promotion & pricing engine
Ở các hệ thống thương mại điện tử lớn, tính giá khuyến mãi (Discount & Pricing) hiếm khi chỉ là chọn 1 trong N thuật toán độc lập. Thực tế, một đơn hàng lúc thanh toán có thể được áp dụng chồng (stack) nhiều chương trình khuyến mãi nối tiếp nhau: vừa được giảm giá theo hạng thành viên (VIP Tier Discount), vừa áp thêm mã coupon giảm tiền mặt cho đơn hàng đầu tiên, lại vừa hưởng ưu đãi Flash Sale theo khung giờ. Lúc này, chúng ta kết hợp Strategy Pattern thành một đường ống xử lý tuần tự (Composite Strategy Pipeline):
# viết promotion Strategy với Spring Boot
public interface PromotionStrategy {
boolean isApplicable(OrderContext context);
DiscountResult applyDiscount(OrderContext context);
int getExecutionOrder(); // Thứ tự ưu tiên áp dụng (Order precedence)
}
@Component
@Order(1)
public class VipCustomerPromotionStrategy implements PromotionStrategy {
@Override
public boolean isApplicable(OrderContext context) {
return context.customer().isVip();
}
@Override
public DiscountResult applyDiscount(OrderContext context) {
BigDecimal discount = context.currentTotal().multiply(new BigDecimal("0.10"));
return new DiscountResult("VIP_10_PERCENT", discount);
}
@Override
public int getExecutionOrder() { return 1; }
}
@Component
@Order(2)
public class FirstOrderPromotionStrategy implements PromotionStrategy {
@Override
public boolean isApplicable(OrderContext context) {
return context.customer().totalOrders() == 0;
}
@Override
public DiscountResult applyDiscount(OrderContext context) {
return new DiscountResult("FIRST_ORDER_FIXED", new BigDecimal("50000"));
}
@Override
public int getExecutionOrder() { return 2; }
}# engine tự gom hết strategy (Spring autowiring)
@Service
public class PromotionExecutionEngine {
private final List<PromotionStrategy> strategies;
// Spring tự inject mọi bean PromotionStrategy, và List được inject đã được sắp theo @Order.
// Ở đây sắp lại theo getExecutionOrder(): trong code thật chỉ nên giữ MỘT nguồn thứ tự,
// hai nguồn lệch nhau là bug khó thấy.
public PromotionExecutionEngine(List<PromotionStrategy> strategies) {
this.strategies = strategies.stream()
.sorted(Comparator.comparingInt(PromotionStrategy::getExecutionOrder))
.toList();
}
public OrderPricingResult calculateFinalPrice(OrderContext context) {
BigDecimal runningTotal = context.initialTotal();
List<DiscountResult> appliedDiscounts = new ArrayList<>();
for (PromotionStrategy strategy : strategies) {
if (strategy.isApplicable(context)) {
DiscountResult result = strategy.applyDiscount(context);
runningTotal = runningTotal.subtract(result.amount()).max(BigDecimal.ZERO); // không để giá âm
appliedDiscounts.add(result);
// Cập nhật giá trị đơn hàng sau khi giảm để chiến lược tiếp theo tính toán
context = context.withCurrentTotal(runningTotal);
}
}
return new OrderPricingResult(runningTotal, appliedDiscounts);
}
}Thứ tự thực thi ở đây ảnh hưởng trực tiếp tới số tiền thanh toán chứ chẳng phải chuyện sắp xếp cho đẹp code. Đơn hàng 1.000.000đ nếu giảm 10% trước rồi mới trừ 50.000đ thì khách trả 850.000đ; nhưng nếu trừ 50.000đ trước rồi mới giảm 10% trên phần còn lại thì khách phải trả 855.000đ. Vì vậy, thứ tự áp dụng (getExecutionOrder) phải là một quy tắc nghiệp vụ được chốt rõ ràng, tuyệt đối không để phụ thuộc vào thứ tự ngẫu nhiên lúc Spring quét bean. Trên hệ thống thật, bạn thường sẽ cần thêm cờ loại trừ (ví dụ voucher này không được dùng chung với Flash Sale) và mức trần giảm giá tối đa cho mỗi đơn hàng.
# cái bẫy thread-safety khi chạy đa luồng
Một trong những lỗi nặng nhất khi viết Strategy trong Spring Boot là để strategy giữ trạng thái (Stateful Strategy):
// NGUY HIỂM: Rò rỉ trạng thái giữa các request và các luồng!
@Component
public class BrokenDiscountStrategy implements PromotionStrategy {
private BigDecimal accumulatedDiscount = BigDecimal.ZERO; // BIẾN MUTABLE TRÊN SPRING SINGLETON!
@Override
public boolean isApplicable(OrderContext context) { return true; }
@Override
public int getExecutionOrder() { return 99; }
@Override
public DiscountResult applyDiscount(OrderContext context) {
// Nhiều requests đồng thời cùng sửa đổi accumulatedDiscount -> RACE CONDITION!
this.accumulatedDiscount = this.accumulatedDiscount.add(new BigDecimal("10000"));
return new DiscountResult("PROMO", this.accumulatedDiscount);
}
}Ngay cả khi chỉ có một thread, đoạn code này vẫn sai: bean là singleton nên accumulatedDiscount sống qua mọi request, đơn sau được giảm 20.000, đơn sau nữa 30.000... Chạy đa luồng thì tệ hơn, hai request cùng đọc rồi cùng ghi đè nhau nên con số còn không đoán trước được.
Nguyên tắc không được phá: mọi Strategy bean trong Spring Boot phải Stateless (không giữ trạng thái). Cần dữ liệu gì thì truyền qua tham số method (
OrderContext context), còn kết quả trả về phải là một DTO/Record immutable mới.
# checklist trước khi lên production (architect's checklist)
- 1. Stateless 100%: soát lại các class Strategy, đảm bảo không có biến instance mutable nào có thể gây race condition khi chạy đa luồng.
- 2. Tận dụng Functional Interface: strategy chỉ có 1 hàm tính toán đơn giản thì dùng Lambda hoặc
Function<T, R>, đừng tạo class riêng. - 3. Chốt thứ tự áp dụng (Ordering): khi kết hợp nhiều Strategy (Composite Pipeline), luôn ghi rõ độ ưu tiên bằng
@Orderhoặc methodgetOrder(). - 4. Fallback Strategy: luôn có một strategy mặc định (No-Op Strategy:
return input;) cho trường hợp không strategy nào khớp điều kiện. - 5. Đo thời gian chạy: gắn metric đo thời gian chạy của từng Strategy, để bắt được thuật toán nào đang kéo P99 Latency của đơn hàng lên.
# lời kết
Việc nên làm ngay: mở các class Strategy đang có, tìm field nào không phải final. Mỗi field như vậy trên một singleton bean là một ứng viên cho lỗi "đơn thứ ba được giảm 30.000".
Còn chuyện chọn cách viết thì theo mình: nếu thuật toán chỉ là một biểu thức tính toán ngắn không phụ thuộc bên ngoài thì cứ dùng Lambda / @FunctionalInterface cho gọn; khi nào thuật toán cần inject thêm Repository, gọi API ngoài hoặc cần viết bộ unit test riêng biệt thì mới tách thành các Spring Bean. Và nếu cả nghiệp vụ chỉ có vỏn vẹn hai nhánh cố định không bao giờ đổi, một câu if-else rõ ràng vẫn tốt hơn dựng cả một bộ interface phức tạp. Phần chọn implementation lúc runtime bằng Map bean có nói kỹ hơn ở bài Factory pattern.
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 😎 👍🏻 🚀 🔥.
On this page
- # Strategy vs state vs template method
- # bảng so sánh chi tiết
- # từ Java 8 trở đi: lambda thay cho đống class thừa
- # viết gọn bằng functional interfaces
- # ví dụ cỡ enterprise: dynamic promotion & pricing engine
- # viết promotion Strategy với Spring Boot
- # engine tự gom hết strategy (Spring autowiring)
- # cái bẫy thread-safety khi chạy đa luồng
- # checklist trước khi lên production (architect's checklist)
- # lời kết