Modelul Chain of Responsibility în Go

Ce este

Modelul Chain of Responsibility (lanțul de responsabilitate) trimite o cerere de-a lungul unui lanț de handlere. Fiecare handler fie se ocupă de cerere, fie o predă următorului. Expeditorul cunoaște doar prima verigă — niciodată pe cel care o va rezolva de fapt.

Exemplu: o linie de suport

O problemă intră la botul de chat. Ce nu poate rezolva botul ajunge la suportul tehnic; ce nu poate rezolva suportul tehnic ajunge la manager, care se ocupă de tot ce primește.

Trimite mai departe până când cineva poate rezolva

„fără internet” face un singur pas și se oprește la suportul tehnic; cererea de rambursare parcurge tot lanțul până la manager. Apelantul a scris aceeași singură linie în ambele cazuri.

Scrie un program Go cu un Chain of Responsibility: structuri Handler cu un nume, o funcție canFix și un pointer next. Construiește un lanț de suport format din bot de chat, suport tehnic și manager (care rezolvă totul). Trimite o problemă pe care o poate rezolva veriga din mijloc și una care ajunge până la manager, afișând fiecare pas.

> Ieșire: program Go și rezultatul capturat

Prompt

Scrie un program Go cu un Chain of Responsibility: structuri Handler cu un nume, o funcție canFix și un pointer next. Construiește un lanț de suport format din bot de chat, suport tehnic și manager (care rezolvă totul). Trimite o problemă pe care o poate rezolva veriga din mijloc și una care ajunge până la manager, afișând fiecare pas.

Ieșire: program Go și rezultatul capturat

package main

import "fmt"

type Handler struct {
  name   string
  canFix func(problem string) bool
  next   *Handler
}

func (h *Handler) Handle(problem string) {
  if h.canFix(problem) {
    fmt.Println(h.name, "a rezolvat:", problem)
    return
  }
  fmt.Println(h.name, "trimite mai departe")
  if h.next != nil {
    h.next.Handle(problem)
  }
}

func main() {
  manager := &Handler{
    name:   "manager",
    canFix: func(p string) bool { return true },
  }
  tech := &Handler{
    name:   "suport tehnic",
    canFix: func(p string) bool { return p == "fără internet" },
    next:   manager,
  }
  bot := &Handler{
    name:   "bot de chat",
    canFix: func(p string) bool { return p == "parolă uitată" },
    next:   tech,
  }

  bot.Handle("fără internet")
  fmt.Println("---")
  bot.Handle("cerere de rambursare")
}

Când să îl folosești

Folosește-l când mai multe părți ar putea trata o cerere, iar cea potrivită nu se cunoaște dinainte — escaladarea la suport, middleware, tratarea evenimentelor, fluxuri de aprobare.

Renunță la el când handlerul este mereu cunoscut — cheamă-l direct. Un lanț cu o singură verigă, sau unul care se termină mereu la aceeași verigă, este un simplu apel de funcție deghizat.

Avantaje și dezavantaje

Avantaje: expeditorul și receptorii sunt decuplați; verigile pot fi adăugate, eliminate și reordonate liber; fiecare handler rămâne mic.

Dezavantaje: nu există nicio garanție că cineva tratează cererea — un lanț rupt o înghite în tăcere; urmărirea unei cereri prin multe verigi face depanarea mai lentă.