Belajar Software Architecture and Design Patterns - GoF Behavioral Patterns

#Pendahuluan

Kelompok Behavioral adalah yang paling hidup di aplikasi backend nyata: ia mengatur bagaimana objek berkomunikasi, membagi tanggung jawab alur, dan membuat perilaku bisa ditukar. Lima pattern hari ini menutup katalog GoF series ini — dan semuanya akan langsung terpakai dalam latihan checkout engine.

#Pattern

#Strategy

Keluarga algoritma yang saling dipertukarkan — kita sudah menyentuhnya di OCP (episode 3):

interface DiscountStrategy {
    public function apply(int $subtotalCents): int;
}
 
final class PercentageDiscount implements DiscountStrategy {
    public function __construct(private int $percent) {}
    public function apply(int $subCents): int {
        return $subCents - intdiv($subCents * $this->percent, 100);
    }
}
final class FixedDiscount implements DiscountStrategy {
    public function __construct(private int $offCents) {}
    public function apply(int $subCents): int { return max(0, $subCents - $this->offCents); }
}

#Observer

Satu event, banyak pendengar tanpa saling mengenal:

@Injectable()
export class OrderService {
  constructor(@InjectEventEmitter() private emitter: EventEmitter2) {}
  place(dto: CheckoutDto) {
    const order = this.checkout.place(dto);
    this.emitter.emit('order.placed', order); // penerbit tak peduli siapa mendengar
  }
}
// Listener terpisah:
@OnEvent('order.placed')
async sendReceipt(e: OrderPlaced) { await this.mailer.receipt(e.order); }

OrderPlaced::dispatch($order); // event
class SendReceiptListener {
    public function handle(OrderPlaced $e): void { /* kirim email */ }
}
// Registrasi deklaratif di EventServiceProvider (atau auto-discovery).

#Template Method & Command & Chain of Responsibility

• Template Method: kerangka algoritma di base class, langkah bervariasi diserahkan subclass — cocok saat alur tetap tapi detail berubah per tipe.
• Command: permintaan dibungkus objek → bisa antri, ulang, audit. Inilah bentuk dari queue job (dispatch(new SendInvoiceJob($order)) di Laravel).
• Chain of Responsibility: request melewati rantai handler; tiap handler putuskan lanjut/berhenti.

$result = app(Pipeline::class)
    ->send($checkoutData)
    ->through([
        ValidateStock::class,
        ApplyPromo::class,
        CheckFraudScore::class,
    ])
    ->then(fn ($data) => $this->orders->create($data));

#Real-World Implementasi

Peta pemakaian pattern behavioral di ketiga stack:

#Praktik

Target outline: checkout engine dengan strategy diskon + pipeline validasi di 3 stack.

interface ValidationStep {
  validate(cart: Cart): Promise<void>; // throw jika gagal
}
 
@Injectable()
export class CheckoutEngine {
  private discounts = new Map<string, DiscountRule>();
  register(code: string, rule: DiscountRule) { this.discounts.set(code, rule); }
 
  async process(cart: Cart, steps: ValidationStep[]): Promise<Receipt> {
    for (const step of steps) await step.validate(cart); // chain
    let total = cart.subtotal();
    for (const [code] of cart.promos)
      total = this.discounts.get(code)!.apply(total);   // strategy
    return Receipt.from(total);
  }
}

type Validator func(*Cart) error
 
func ValidateStock(s StockChecker) Validator {
    return func(c *Cart) error { return s.EnsureAvailable(c.Items) }
}
func ValidateFraud(f FraudScorer) Validator {
    return func(c *Cart) error {
        if f.Score(c.UserID) > 80 { return errors.New("blocked") }
        return nil
    }
}
 
func (e *Engine) Process(c *Cart, validators ...Validator) (*Receipt, error) {
    for _, v := range validators {
        if err := v(c); err != nil { return nil, err }
    }
    total := c.Subtotal()
    for _, r := range e.rulesFor(c.Promos) { total = r.Apply(total) }
    return NewReceipt(total), nil
}

$receipt = app(Pipeline::class)
    ->send($cart)
    ->through([ValidateStock::class, ApplyPromo::class])
    ->then(function (Cart $cart) use (&$engine) {
        $strategy = $engine->resolve($cart->promoCode ?? 'none');
        return Receipt::from($strategy->apply($cart->subtotal()));
    });

Ujian akhir latihan: tambahkan aturan "diskon gratis ongkir jika subtotal di atas 500 ribu" — harus bisa dilakukan hanya dengan mendaftarkan strategy/rule baru tanpa menyentuh CheckoutEngine.

#Penutup

Rangkuman episode ini:

• Strategy menukar algoritma (diskon/auth/pricing); Observer memisahkan reaksi (events/listeners).
• Template Method untuk kerangka tetap-detail variabel; Command membungkus aksi jadi antrian; Chain/Pipeline memproses berurutan.
• Checkout engine membuktikan kombinasi pattern menghasilkan kode yang ekstensif-tanpa-modifikasi.

Katalog GoF tuntas! Episode 8 mulai FASE 3 dengan fondasi data modeling: DTO, Entity & Value Object — tiga jenis objek yang sering dicampuradukkan dan jadi sumber utama kode kotor. Sampai jumpa!