Khởi tạoCreational

Abstract Factoryaka Kit

Một factory tạo ra cả một họ object đi cùng nhau, đảm bảo chúng luôn 'cùng bộ' với nhau.One factory creates a whole family of related objects, guaranteeing they always match each other.

Độ khóDifficulty: VừaMedium
Mức phổ biếnUsage: Mức phổ biếnUsage 3/5
Thời gian đọcReading time: ~8 phút đọc~8 min read

Thảo luậnDiscussion

Ví dụ đời thườngReal-life analogy

Mua nội thất theo bộ sưu tập: chọn bộ 'Scandinavian' là bàn, ghế, tủ đều gỗ sáng, chân mảnh; chọn bộ 'Indochine' là tất cả đều gỗ tối, hoa văn. Bạn không chọn từng món lẻ, mà chọn NHÀ SẢN XUẤT của cả bộ — nhờ vậy không bao giờ bị lệch tông giữa bàn và ghế.Buying furniture by collection: pick 'Scandinavian' and the table, chairs and cabinet are all light wood with slim legs; pick 'Indochine' and everything is dark wood with patterns. You don't choose pieces one by one — you choose the MAKER of the whole set, so the table and chairs never clash.

Vấn đề và giải phápProblem and solution

Không có patternWithout the pattern

Mỗi cổng thanh toán (VNPay, Momo) cần một BỘ object đi cùng nhau: client tạo link thanh toán, bộ kiểm tra chữ ký callback (IPN), client hoàn tiền... Nếu tạo lẻ từng cái bằng if/else, rất dễ có ngày dùng client VNPay nhưng lại verify chữ ký bằng thuật toán của Momo — lỗi bảo mật âm thầm, chỉ lộ ra khi tiền đã đi.Each payment gateway (VNPay, Momo) needs a SET of objects that belong together: a client creating the payment link, a callback (IPN) signature verifier, a refund client... Creating them one by one with if/else, someday you'll use the VNPay client but verify signatures with Momo's algorithm — a silent security bug that surfaces only after money moves.

Với Abstract FactoryWith Abstract Factory

Định nghĩa interface PaymentProviderFactory với các method tạo từng sản phẩm của họ (paymentClient(), signatureVerifier()). Mỗi cổng có một factory cụ thể tạo ra trọn bộ của riêng nó. Code nghiệp vụ chỉ chọn factory MỘT lần rồi lấy mọi thứ từ đó — không thể trộn lẫn hai họ.Define a PaymentProviderFactory interface with one creation method per product (paymentClient(), signatureVerifier()). Each gateway has a concrete factory producing its own complete set. Business code picks the factory ONCE and gets everything from it — the two families can't be mixed.

Thành phần tham giaParticipants

AbstractFactory: Interface khai báo các method tạo từng sản phẩm trong họ.Interface declaring a creation method for each product in the family.
ConcreteFactory: VnPayFactory, MomoFactory — tạo ra trọn bộ sản phẩm cùng họ.VnPayFactory, MomoFactory — create a complete set of matching products.
AbstractProduct: Interface cho từng loại sản phẩm: PaymentClient, SignatureVerifier.Interface for each product type: PaymentClient, SignatureVerifier.
ConcreteProduct: Cài đặt cụ thể của từng họ: VnPayClient, VnPayVerifier...Each family's concrete implementation: VnPayClient, VnPayVerifier...
Client: Chỉ làm việc với các interface, chọn factory một lần.Works only with interfaces and picks the factory once.

Sơ đồ và luồng thực thiDiagram and execution flow

Dùng Tự chạy hoặc phím mũi tên để đi qua từng bước gọi giữa các object. Console hiển thị output tương ứng của chương trình.Use Autoplay or the arrow keys to step through each call between objects. The console shows the matching program output.

1Lúc khởi động, Spring inject mọi factory (VNPAY, MOMO) vào PaymentService dưới dạng interface.At startup Spring injects every factory (VNPAY, MOMO) into PaymentService as the interface type.

← →

console

1factories = [VNPAY, MOMO]

implementsimplementsextendsextendsgọi / dùngcalls / usestạo racreatesgửi qua channelsends via channel1thứ tự chạy (bấm để nhảy bước)execution order (click to jump)

Code: Java Spring Boot ⇄ GoCode: Java Spring Boot ⇄ Go

Cùng một bài toán, hai ngôn ngữ. Rê chuột hoặc focus vào chú thích (số màu cam) để làm nổi bật dòng code tương ứng.Same problem, two languages. Hover or focus an annotation (orange number) to highlight its line.

JavaSpring Boot 3 · Java 21Spring Boot 3 · Java 21

package com.shop.pay;

import java.util.Map;

// Abstract factory: creates a FAMILY of objects that must match each other
public interface PaymentProviderFactory {1
    String provider();

    PaymentClient paymentClient();2

    SignatureVerifier signatureVerifier();

    // Abstract products (nested interfaces are implicitly public static)
    interface PaymentClient {3
        String createPaymentUrl(String orderId, long amountVnd);
    }

    interface SignatureVerifier {
        boolean verify(Map<String, String> params);
    }
}

GoGo 1.23 · thư viện chuẩnGo 1.23 · standard library

package payment

import "context"

type Client interface {1
	CreatePaymentURL(ctx context.Context, orderID string, amountVND int64) (string, error)
}

type Verifier interface {
	Verify(params map[string]string) bool
}

// ProviderFactory builds a matching family: Client + Verifier.
type ProviderFactory interface {2
	Client() Client
	Verifier() Verifier
}

Khác biệt chính giữa Java và GoKey differences between Java and Go

01Java có thể lồng interface sản phẩm bên trong interface factory; Go để các interface nhỏ ngang hàng trong package.Java can nest product interfaces inside the factory interface; Go keeps small, flat interfaces side by side in a package.
02Spring tự thu thập mọi ConcreteFactory qua List<PaymentProviderFactory>; Go tự lắp map factory trong main.Spring collects every ConcreteFactory via List<PaymentProviderFactory>; Go builds the factory map by hand in main.
03Java dùng lambda cho product một method; Go thường dùng struct nhỏ (hoặc kiểu hàm có method) cho product.Java uses lambdas for single-method products; Go usually uses small structs (or a func type with a method) for products.
04Go không có kế thừa nên 'họ' được giữ bằng việc constructor trả về interface và giấu struct cụ thể (unexported).Go has no inheritance, so the 'family' is held together by constructors returning interfaces while concrete structs stay unexported.

Ứng dụng thực tếReal-world usage

JDK: DocumentBuilderFactory, XML/JAXPJDK: DocumentBuilderFactory, XML/JAXP
DocumentBuilderFactory.newInstance() trả về factory của một implementation XML, tạo ra các object parser cùng họ.DocumentBuilderFactory.newInstance() returns a factory for one XML implementation, producing matching parser objects.
JDBC ConnectionJDBC Connection
Một Connection của PostgreSQL tạo ra Statement, PreparedStatement, Blob... đều thuộc cùng driver — không thể trộn với MySQL.A PostgreSQL Connection creates Statement, PreparedStatement, Blob... all from the same driver — never mixed with MySQL.
Go: database/sql driver, cloud SDKGo: database/sql drivers, cloud SDKs
driver.Driver → Conn → Stmt/Tx là một họ cài đặt theo từng driver. Lớp storage đa cloud (S3/GCS + queue tương ứng) cũng hay theo mẫu này.driver.Driver → Conn → Stmt/Tx is a per-driver family. Multi-cloud storage layers (S3/GCS + matching queue) often follow this too.
Cổng thanh toán, đa nhà cung cấpPayment gateways, multi-vendor setups
VNPay/Momo/ZaloPay, mỗi nơi một bộ client + verifier + refund riêng; hoặc bộ 'sandbox' vs 'production' cho cả hệ thống.VNPay/Momo/ZaloPay each have their own client + verifier + refund set; or a 'sandbox' vs 'production' kit for the whole system.

Khi nào dùng và khi nào khôngWhen to use it, and when not

Nên dùng khiUse it when

Có nhiều object phải đi cùng nhau theo 'họ', trộn lẫn sẽ sai (bảo mật, định dạng, giao thức).Several objects must go together as a family and mixing them is wrong (security, format, protocol).
Hệ thống cần hỗ trợ nhiều nhà cung cấp/biến thể và chọn một bộ lúc cấu hình hoặc lúc chạy.The system supports several vendors/variants and picks one set at config time or runtime.
Muốn thay cả bộ sang bản giả khi test (fake gateway kit).You want to swap the whole set for fakes in tests (a fake gateway kit).

Không nên dùng khiAvoid it when

Chỉ có MỘT loại sản phẩm — Factory Method hoặc Strategy là đủ.There's only ONE product type — Factory Method or Strategy is enough.
Họ sản phẩm hay phải thêm loại sản phẩm mới — mỗi lần thêm là phải sửa interface và MỌI factory.The family keeps gaining new product types — each addition means changing the interface and EVERY factory.

Ưu điểmPros

Đảm bảo các sản phẩm luôn tương thích với nhau.Guarantees products are always compatible with each other.
Thêm một họ mới (ZaloPay) không sửa code nghiệp vụ.Adding a new family (ZaloPay) doesn't touch business code.
Gom config của mỗi nhà cung cấp về một chỗ.Collects each vendor's config in one place.

Nhược điểmCons

Nhiều interface và class — nặng nề nếu họ chỉ có 1–2 sản phẩm.Many interfaces and classes — heavy if the family has only 1–2 products.
Thêm một LOẠI sản phẩm mới (ví dụ RefundClient) phải sửa interface và tất cả factory.Adding a new product TYPE (e.g. RefundClient) requires changing the interface and every factory.

Anti-pattern: lỗi thường gặpAnti-pattern: common mistake

Chọn từng sản phẩm lẻ bằng if/elsePicking each product separately with if/else

Mỗi chỗ cần object lại tự if/else theo provider. Chỉ cần một chỗ viết nhầm điều kiện là client VNPay đi cặp với verifier Momo — chữ ký luôn sai hoặc tệ hơn, luôn đúng. Hãy chọn factory một lần và lấy mọi thứ từ đó.Each spot that needs an object does its own if/else on provider. One wrong condition and a VNPay client pairs with a Momo verifier — signatures always fail or, worse, always pass. Pick the factory once and get everything from it.

PaymentClient client = provider.equals("VNPAY")
        ? new VnPayClient(tmnCode) : new MomoClient(partnerCode);

// ... 200 lines later, someone else wrote:
SignatureVerifier verifier = provider.startsWith("MOMO") || isTest
        ? new MomoVerifier(momoSecret)          // ❌ test mode: VNPay + Momo mixed
        : new VnPayVerifier(vnpSecret);
verifier.verify(params);

Dễ nhầm vớiEasily confused with

Abstract Factory vs Factory Method

Factory Method: MỘT method tạo MỘT sản phẩm, thường qua kế thừa. Abstract Factory: MỘT object tạo NHIỀU sản phẩm cùng họ, qua composition.Factory Method: ONE method creating ONE product, often via inheritance. Abstract Factory: ONE object creating MANY family products, via composition.

Abstract Factory vs Strategy

Cách chọn theo key giống Strategy, nhưng Strategy thay một HÀNH VI, còn Abstract Factory trả về một BỘ object để dùng tiếp.The key-based lookup looks like Strategy, but Strategy swaps one BEHAVIOUR while Abstract Factory returns a SET of objects to use.

Bài tập áp dụngExercise

Thêm sản phẩm thứ ba vào họ: RefundClient với method refund(orderId, amountVnd), và cài đặt cho cả VNPay và Momo.Add a third product to the family: a RefundClient with refund(orderId, amountVnd), implemented for both VNPay and Momo.

Kiểm tra kiến thứcKnowledge check

Câu 1 / 5Question 1 of 5

Abstract Factory khác Factory Method ở điểm cốt lõi nào?What is the core difference between Abstract Factory and Factory Method?

Phím 1–4 để chọn đáp án, Enter để kiểm tra.Press 1–4 to choose an answer, Enter to check.

Thẻ ghi nhớFlashcards

Ôn tập ngắt quãng (spaced repetition): thẻ được lặp lại sau 1 → 3 → 7 → 14 → 30 ngày để củng cố trí nhớ dài hạn.Spaced repetition: cards are repeated after 1 → 3 → 7 → 14 → 30 days to build long-term memory.

Pattern liên quanRelated patterns

Factory Method Builder Prototype Strategy

Thảo luậnDiscussion

Abstract Factoryaka Kit

VừaMedium

Mức phổ biếnUsage 3/5

~8 phút đọc~8 min read

package com.shop.pay; import java.util.Map; // Abstract factory: creates a FAMILY of objects that must match each other public interface PaymentProviderFactory {1 String provider(); PaymentClient paymentClient();2 SignatureVerifier signatureVerifier(); // Abstract products (nested interfaces are implicitly public static) interface PaymentClient {3 String createPaymentUrl(String orderId, long amountVnd); } interface SignatureVerifier { boolean verify(Map<String, String> params); } }

package payment import "context" type Client interface {1 CreatePaymentURL(ctx context.Context, orderID string, amountVND int64) (string, error) } type Verifier interface { Verify(params map[string]string) bool } // ProviderFactory builds a matching family: Client + Verifier. type ProviderFactory interface {2 Client() Client Verifier() Verifier }

PaymentClient client = provider.equals("VNPAY") ? new VnPayClient(tmnCode) : new MomoClient(partnerCode); // ... 200 lines later, someone else wrote: SignatureVerifier verifier = provider.startsWith("MOMO") || isTest ? new MomoVerifier(momoSecret) // ❌ test mode: VNPay + Momo mixed : new VnPayVerifier(vnpSecret); verifier.verify(params);