Khởi tạoCreational

Prototypeaka Clone

Tạo object mới bằng cách sao chép một object mẫu đã cấu hình sẵn, rồi chỉ sửa phần khác biệt.Create new objects by copying a pre-configured sample object, then changing only what differs.

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

Thảo luậnDiscussion

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

Mỗi tháng phòng marketing lại làm chương trình 10.10, 11.11, 12.12. Không ai soạn lại kế hoạch từ con số 0 — họ 'Save as' file của đợt trước, đổi tên, đổi ngày, chỉnh vài mức giảm giá. Nhưng nhớ là phải 'Save as' thật, chứ sửa thẳng lên file gốc là hỏng luôn mẫu.Every month marketing runs a 10.10, 11.11, 12.12 sale. Nobody writes the plan from scratch — they 'Save as' last campaign's file, rename it, change the date, tweak a few discounts. But it must be a real 'Save as': editing the original file ruins the template.

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

Không có patternWithout the pattern

Một chiến dịch khuyến mãi có hàng chục thiết lập: danh mục áp dụng, mức giảm theo hạng thành viên, giới hạn ngân sách... Tạo mới từ đầu cho mỗi đợt sale vừa dài vừa dễ sót. Tệ hơn, nếu bạn 'copy' bằng cách gán tham chiếu hoặc copy nông, sửa mức giảm của đợt 11.11 lại làm hỏng luôn cấu hình gốc dùng cho 12.12.A promo campaign has dozens of settings: eligible categories, discounts per membership tier, budget limits... Building each sale from scratch is long and error-prone. Worse, if you 'copy' by assigning a reference or doing a shallow copy, editing the 11.11 discounts silently corrupts the master config used for 12.12.

Với PrototypeWith Prototype

Giữ các object mẫu (prototype) đã cấu hình đầy đủ, và cho chúng khả năng tự sao chép (copy() / Clone()), sao chép SÂU các phần mutable như list, map. Muốn tạo mới thì clone mẫu rồi chỉnh vài field. Trong Java nên dùng copy constructor thay vì Cloneable; trong Go viết method Clone() với slices.Clone / maps.Clone.Keep fully configured sample objects (prototypes) that can copy themselves (copy() / Clone()), deep-copying mutable parts like lists and maps. To create a new one, clone a sample and tweak a few fields. In Java prefer a copy constructor over Cloneable; in Go write a Clone() method using slices.Clone / maps.Clone.

Thành phần tham giaParticipants

Prototype: Object biết tự sao chép chính nó (copy()/Clone()).An object that knows how to copy itself (copy()/Clone()).
Prototype Registry: Kho các bản mẫu đã cấu hình sẵn, tra theo key.A store of pre-configured samples, looked up by key.
Client: Xin một bản sao từ registry rồi chỉnh phần khác biệt.Asks the registry for a copy, then tweaks what differs.

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, registry dựng sẵn các bản mẫu đầy đủ cấu hình.At startup the registry builds fully configured sample campaigns.

← →

console

1prototypes registered: FLASH_SALE, MEGA_SALE

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.promo;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// Prototype via a copy constructor (preferred over Cloneable/clone())
public class Campaign {1
    private String name;
    private LocalDate startDate;
    private final List<String> categories;
    private final Map<String, Integer> discountByTier;

    public Campaign(String name, LocalDate startDate) {
        this.name = name;
        this.startDate = startDate;
        this.categories = new ArrayList<>();
        this.discountByTier = new HashMap<>();
    }

    // Copy constructor: deep-copies every mutable collection
    public Campaign(Campaign other) {
        this.name = other.name;
        this.startDate = other.startDate;2
        this.categories = new ArrayList<>(other.categories);3
        this.discountByTier = new HashMap<>(other.discountByTier);
    }

    public Campaign copy() { return new Campaign(this); }4

    public Campaign rename(String n) { this.name = n; return this; }
    public Campaign startOn(LocalDate d) { this.startDate = d; return this; }
    public Campaign addCategory(String c) { categories.add(c); return this; }
    public Campaign discount(String tier, int pct) { discountByTier.put(tier, pct); return this; }

    public int discountFor(String tier) { return discountByTier.getOrDefault(tier, 0); }
}

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

package promo

import (
	"fmt"
	"maps"
	"slices"
	"time"
)

type Campaign struct {
	Name       string
	Start      time.Time
	Categories []string
	Discounts  map[string]int // tier -> percent
}

// Clone returns a deep copy: slices and maps get their own backing storage.
func (c *Campaign) Clone() *Campaign {
	cp := *c // copies every field, but slice/map headers still point to shared data1
	cp.Categories = slices.Clone(c.Categories)2
	cp.Discounts = maps.Clone(c.Discounts)3
	return &cp
}

type Registry struct {
	protos map[string]*Campaign
}

func NewRegistry() *Registry {
	return &Registry{protos: map[string]*Campaign{}}
}

func (r *Registry) Register(key string, c *Campaign) { r.protos[key] = c }

func (r *Registry) New(key string) (*Campaign, error) {
	p, ok := r.protos[key]
	if !ok {
		return nil, fmt.Errorf("promo: no prototype %q", key)
	}
	return p.Clone(), nil4
}

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

01Java: tránh Cloneable/clone(), dùng copy constructor hoặc static copyOf. Go: gán struct đã là copy (nông), tự viết Clone() cho phần sâu.Java: avoid Cloneable/clone(), use a copy constructor or a static copyOf. Go: assigning a struct already copies it (shallowly); write Clone() for the deep part.
02Go có sẵn slices.Clone và maps.Clone (1.21+); Java dùng new ArrayList<>(src), List.copyOf, Map.copyOf.Go has slices.Clone and maps.Clone (1.21+); Java uses new ArrayList<>(src), List.copyOf, Map.copyOf.
03Đối tượng bất biến (record Java, LocalDate, string Go) không cần clone — chia sẻ tham chiếu là an toàn. Bất biến là cách 'né' Prototype gọn nhất.Immutable objects (Java records, LocalDate, Go strings) need no cloning — sharing references is safe. Immutability is the neatest way to sidestep Prototype.
04Spring @Scope("prototype") KHÔNG phải mẫu Prototype: nó tạo instance MỚI qua constructor mỗi lần lấy bean, không sao chép object nào.Spring's @Scope("prototype") is NOT the Prototype pattern: it builds a NEW instance via the constructor each time, copying nothing.

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

Copy constructor trong collection JavaJava collection copy constructors
new ArrayList<>(list), new HashMap<>(map), List.copyOf(...) là dạng Prototype phổ biến nhất bạn dùng hằng ngày.new ArrayList<>(list), new HashMap<>(map), List.copyOf(...) are the most common Prototype forms you use every day.
Spring: BeanDefinition và RestClient.mutate()Spring: BeanDefinition and RestClient.mutate()
restClient.mutate() / webClient.mutate() sao chép cấu hình client hiện có thành builder mới để chỉnh tiếp — tinh thần Prototype.restClient.mutate() / webClient.mutate() copy an existing client's config into a new builder to tweak — the Prototype spirit.
Go: http.Request.Clone, tls.Config.CloneGo: http.Request.Clone, tls.Config.Clone
req.Clone(ctx) sao chép sâu request để sửa header an toàn trong middleware; tls.Config.Clone() sao chép cấu hình TLS.req.Clone(ctx) deep-copies a request so middleware can change headers safely; tls.Config.Clone() copies TLS config.
Mẫu chiến dịch, sản phẩm biến thểCampaign templates, product variants
Sàn TMĐT 'nhân bản' sản phẩm để tạo biến thể màu/size, hoặc nhân bản chiến dịch sale tháng trước.Marketplaces 'duplicate' a listing to create color/size variants, or duplicate last month's sale campaign.

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

Nên dùng khiUse it when

Object có cấu hình phức tạp và các bản mới chỉ khác bản mẫu một ít.Objects with complex config where new ones differ only slightly from a sample.
Tạo từ đầu tốn kém (đọc DB, tính toán nặng) mà sao chép thì rẻ.Creating from scratch is expensive (DB reads, heavy computation) while copying is cheap.
Cần 'chụp' trạng thái để sửa trên bản sao mà không ảnh hưởng bản gốc.You need a snapshot to modify safely without affecting the original.

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

Object bất biến — cứ dùng chung, không cần clone.Immutable objects — just share them, no cloning needed.
Object chứa tài nguyên không sao chép được (connection, file handle, goroutine đang chạy).Objects holding uncopyable resources (connections, file handles, running goroutines).
Object đơn giản, tạo bằng constructor/builder đã đủ nhanh và rõ.Simple objects where a constructor/builder is already fast and clear.

Ưu điểmPros

Tạo object phức tạp nhanh, không lặp lại code cấu hình.Create complex objects quickly without repeating config code.
Bản mẫu là 'nguồn sự thật' duy nhất cho cấu hình mặc định.The sample is the single source of truth for default config.
Thêm loại mới chỉ bằng cách đăng ký bản mẫu mới, không cần class mới.Add new kinds just by registering a new sample, no new class needed.

Nhược điểmCons

Copy sâu dễ sai: quên một field mutable là có bug dữ liệu dùng chung rất khó tìm.Deep copying is error-prone: miss one mutable field and you get a hard-to-find shared-data bug.
Object có tham chiếu vòng hoặc lồng nhiều tầng thì clone phức tạp.Cloning gets complicated with circular references or deep nesting.

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

Copy nông rồi tưởng là bản saoShallow copy mistaken for a real copy

Struct Go được copy khi gán, nhưng map/slice bên trong vẫn dùng chung. Sửa mức giảm giá của 'bản sao' là sửa luôn bản mẫu — mọi đợt sale sau đều sai giá. Luôn viết Clone() có copy sâu.A Go struct is copied on assignment, but the maps/slices inside are still shared. Editing the 'copy's' discounts edits the sample too — every later sale gets wrong prices. Always write a deep-copying Clone().

func (r *Registry) New(key string) Campaign {
	return *r.protos[key] // ❌ shallow: Discounts map is shared
}

sale := reg.New("MEGA_SALE")
sale.Discounts["GOLD"] = 40 // ❌ silently changes the master too

Dễ nhầm vớiEasily confused with

Prototype vs Singleton

Spring đặt tên scope 'singleton' và 'prototype' cạnh nhau, nhưng prototype scope chỉ là 'tạo mới mỗi lần', không phải sao chép object mẫu.Spring names 'singleton' and 'prototype' scopes side by side, but prototype scope just means 'new each time', not copying a sample object.

Prototype vs Memento

Memento cũng chụp trạng thái, nhưng để KHÔI PHỤC sau này (undo). Prototype sao chép để TẠO object mới.Memento also snapshots state, but to RESTORE it later (undo). Prototype copies to CREATE new objects.

Bài tập áp dụngExercise

Thêm field Vouchers []Voucher (Voucher là struct có Code string và Limits map[string]int) vào Campaign và cập nhật Clone()/copy constructor cho đúng.Add a Vouchers []Voucher field (Voucher is a struct with Code string and Limits map[string]int) to Campaign and update Clone()/the copy constructor correctly.

Kiểm tra kiến thứcKnowledge check

Câu 1 / 5Question 1 of 5

Ý tưởng cốt lõi của Prototype là gì?What is the core idea of Prototype?

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

Builder Factory Method Abstract Factory Memento

Thảo luậnDiscussion

Prototypeaka Clone

VừaMedium

Mức phổ biếnUsage 2/5

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

package com.shop.promo; import java.time.LocalDate; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; // Prototype via a copy constructor (preferred over Cloneable/clone()) public class Campaign {1 private String name; private LocalDate startDate; private final List<String> categories; private final Map<String, Integer> discountByTier; public Campaign(String name, LocalDate startDate) { this.name = name; this.startDate = startDate; this.categories = new ArrayList<>(); this.discountByTier = new HashMap<>(); } // Copy constructor: deep-copies every mutable collection public Campaign(Campaign other) { this.name = other.name; this.startDate = other.startDate;2 this.categories = new ArrayList<>(other.categories);3 this.discountByTier = new HashMap<>(other.discountByTier); } public Campaign copy() { return new Campaign(this); }4 public Campaign rename(String n) { this.name = n; return this; } public Campaign startOn(LocalDate d) { this.startDate = d; return this; } public Campaign addCategory(String c) { categories.add(c); return this; } public Campaign discount(String tier, int pct) { discountByTier.put(tier, pct); return this; } public int discountFor(String tier) { return discountByTier.getOrDefault(tier, 0); } }

package promo import ( "fmt" "maps" "slices" "time" ) type Campaign struct { Name string Start time.Time Categories []string Discounts map[string]int // tier -> percent } // Clone returns a deep copy: slices and maps get their own backing storage. func (c *Campaign) Clone() *Campaign { cp := *c // copies every field, but slice/map headers still point to shared data1 cp.Categories = slices.Clone(c.Categories)2 cp.Discounts = maps.Clone(c.Discounts)3 return &cp } type Registry struct { protos map[string]*Campaign } func NewRegistry() *Registry { return &Registry{protos: map[string]*Campaign{}} } func (r *Registry) Register(key string, c *Campaign) { r.protos[key] = c } func (r *Registry) New(key string) (*Campaign, error) { p, ok := r.protos[key] if !ok { return nil, fmt.Errorf("promo: no prototype %q", key) } return p.Clone(), nil4 }

func (r *Registry) New(key string) Campaign { return *r.protos[key] // ❌ shallow: Discounts map is shared } sale := reg.New("MEGA_SALE") sale.Discounts["GOLD"] = 40 // ❌ silently changes the master too