Command
Propósito
Según el libro "Patrones de Diseño" [29] el patrón Command "encapsula una petición en un objeto, permitiendo así parametrizar a los clientes con diferentes peticiones, hacer cola o llevar registro de las peticiones, y poder deshacer las operaciones".
También conocido como
Action, Transaction
Estructura

Participantes
Orden:
declara una interfaz para ejecutar una operación.
Orden Concreta:
define un enlace entre una variable Receptor y una acción.
implementa Ejecutar invocando la correspondiente operación u operaciones del Receptor.
Cliente:
crea una variable OrdenConcreta y establece su receptor.
Invocador:
le pide a la orden que ejecute la petición.
Receptor:
sabe cómo llevar a cabo las operaciones asociadas a una petición. Cualquier clase puede actuar como Receptor.
Implementación
No se observan impedimentos y/o modificaciones de la estructura original del patrón para su implementación en Go.
Código de ejemplo
En este ejemplo queremos poder prender y apagar un televisor mediante la invocación de comandos mediante un control remoto.
Implementación:
// Interface Comando (Orden)
type Comando interface {
Ejecutar() string
}
// Comando Prender (OrdenConcreta)
type ComandoPrender struct {
receptor Receptor
}
func (cp ComandoPrender) Ejecutar() string {
return cp.receptor.Prender()
}
// Comando Apagar (OrdenConcreta)
type ComandoApagar struct {
receptor Receptor
}
func (ca ComandoApagar) Ejecutar() string {
return ca.receptor.Apagar()
}
// Invocador
type Invocador struct {
comandos []Comando
}
func (i *Invocador) GuardarComando(comando Comando) {
i.comandos = append(i.comandos, comando)
}
func (i *Invocador) EliminarUltimoComando() {
if len(i.comandos) != 0 {
i.comandos = i.comandos[:len(i.comandos)-1]
}
}
func (i *Invocador) Limpiar() {
i.comandos = []Comando{}
}
func (i *Invocador) Ejecutar() string {
var resultados string
for _, comando := range i.comandos {
resultados += comando.Ejecutar() + "\n"
}
return resultados
}
// Receptor
type Receptor struct{}
func (r Receptor) Prender() string {
return "- Prender Televisor"
}
func (r Receptor) Apagar() string {
return "- Apagar Televisor"
}
Se puede probar la implementación del patrón de la siguiente forma:
invocador := Invocador{comandos: []Comando{}}
receptor := Receptor{}
// se establecen dos comandos concretos y se los elimina
// el invocador queda sin comandos que ejecutar
invocador.GuardarComando(ComandoPrender{receptor: receptor})
invocador.GuardarComando(ComandoApagar{receptor: receptor})
invocador.Limpiar()
// se establecen dos comandos concretos iguales y se elimina el último
// el invocador queda con un único comando para ejecutar
invocador.GuardarComando(ComandoPrender{receptor: receptor})
invocador.GuardarComando(ComandoPrender{receptor: receptor})
invocador.EliminarUltimoComando()
// se establece un comando concreto más
invocador.GuardarComando(ComandoApagar{receptor: receptor})
// el invocador ejecuta los dos comandos
fmt.Printf("Comandos ejecutados:\n%v\n", invocador.Ejecutar())
Código de ejemplo | Ejecutar código
Atención: Esta publicación se encuentra abandonada. Puede acceder a la versión vigente en https://leanpub.com/designpatternsingo
Última actualización
¿Te fue útil?