Chain of Responsibility en Go

Chain of Responsibility es un patrón de diseño de comportamiento que permite pasar solicitudes a lo largo de la cadena de manejadores potenciales hasta que uno de ellos gestiona la solicitud.

El patrón permite que varios objetos gestionen la solicitud sin acoplar la clase emisora a las clases concretas de los receptores. La cadena puede componerse dinámicamente durante el tiempo de ejecución con cualquier manejador que siga una interfaz manejadora estándar.

Aprende más sobre el patrón Chain of Responsibility

Ejemplo conceptual

Veamos el patrón Chain of Responsibility con el caso de una aplicación de hospital. Un hospital puede tener varios departamentos, como:

Recepción
Consulta
Sala de curas
Caja

Cuando llega un paciente, primero pasa por recepción, después por la consulta del médico y después por la sala de curas, y por último por la caja (etcétera). El paciente pasa por una cadena de departamentos y cada uno de ellos envía al paciente un poco más allá en la cadena, una vez que se complete su función.

El patrón se aplica cuando hay varios candidatos para procesar la misma solicitud. Cuando no quieres que el cliente elija el receptor ya que varios objetos pueden gestionar la solicitud. Además, quieres desacoplar el cliente de los receptores. El cliente solo necesita conocer el primer elemento de la cadena.

Al igual que en el ejemplo del hospital, el paciente pasa primero por la recepción. Después, en base al estado del paciente, desde recepción lo envían al siguiente manejador de la cadena.

department.go: Interfaz manejador

package main

type Department interface {
	execute(*Patient)
	setNext(Department)
}

reception.go: Manipulador concreto

package main

import "fmt"

type Reception struct {
	next Department
}

func (r *Reception) execute(p *Patient) {
	if p.registrationDone {
		fmt.Println("Patient registration already done")
		r.next.execute(p)
		return
	}
	fmt.Println("Reception registering patient")
	p.registrationDone = true
	r.next.execute(p)
}

func (r *Reception) setNext(next Department) {
	r.next = next
}

doctor.go: Manipulador concreto

package main

import "fmt"

type Doctor struct {
	next Department
}

func (d *Doctor) execute(p *Patient) {
	if p.doctorCheckUpDone {
		fmt.Println("Doctor checkup already done")
		d.next.execute(p)
		return
	}
	fmt.Println("Doctor checking patient")
	p.doctorCheckUpDone = true
	d.next.execute(p)
}

func (d *Doctor) setNext(next Department) {
	d.next = next
}

medical.go: Manipulador concreto

package main

import "fmt"

type Medical struct {
	next Department
}

func (m *Medical) execute(p *Patient) {
	if p.medicineDone {
		fmt.Println("Medicine already given to patient")
		m.next.execute(p)
		return
	}
	fmt.Println("Medical giving medicine to patient")
	p.medicineDone = true
	m.next.execute(p)
}

func (m *Medical) setNext(next Department) {
	m.next = next
}

cashier.go: Manipulador concreto

package main

import "fmt"

type Cashier struct {
	next Department
}

func (c *Cashier) execute(p *Patient) {
	if p.paymentDone {
		fmt.Println("Payment Done")
	}
	fmt.Println("Cashier getting money from patient patient")
}

func (c *Cashier) setNext(next Department) {
	c.next = next
}

patient.go

package main

type Patient struct {
	name              string
	registrationDone  bool
	doctorCheckUpDone bool
	medicineDone      bool
	paymentDone       bool
}

main.go: Código cliente

package main

func main() {

	cashier := &Cashier{}

	//Set next for medical department
	medical := &Medical{}
	medical.setNext(cashier)

	//Set next for doctor department
	doctor := &Doctor{}
	doctor.setNext(medical)

	//Set next for reception department
	reception := &Reception{}
	reception.setNext(doctor)

	patient := &Patient{name: "abc"}
	//Patient visiting
	reception.execute(patient)
}

output.txt: Resultado de la ejecución

Reception registering patient
Doctor checking patient
Medical giving medicine to patient
Cashier getting money from patient patient

Basado en: Golang By Example