Introduction to the Command Pattern

Welcome back! In the previous lessons, we explored various behavioral patterns like the Strategy and Observer Patterns. This time, we'll dive into the Command Pattern, a powerful technique that encapsulates a request as an object, thereby allowing for the parameterization and queuing of requests.

In this lesson, you will discover how to implement the Command Pattern in Go, which will enable you to decouple the sender and receiver of a request. Specifically, you'll learn to:

1. Define a Command interface: Create a blueprint for executing commands.
2. Implement Concrete Commands: Learn to encapsulate specific actions (like turning a light on or off).
3. Use an Invoker: Understand how to create an invoker to hold and execute commands.

Let's take a peek at an example, which we'll break down step by step:

We start by defining a Command interface with an Execute method:

// Command interface
type Command interface {
    Execute()
}

Next, we create concrete commands that implement the Command interface. The LightOnCommand and LightOffCommand structs represent turning a light on and off, respectively, and implement the Execute method to print the corresponding message when executed:

// Concrete Command for turning on the light
type LightOnCommand struct {}

func (c *LightOnCommand) Execute() {
    fmt.Println("The light is turned on.")
}

// Concrete Command for turning off the light
type LightOffCommand struct {}

func (c *LightOffCommand) Execute() {
    fmt.Println("The light is turned off.")
}

We then create an invoker, Button, that holds a command and triggers it when needed. The Press method executes the command stored in the invoker. Therefore if the invoker holds the LightOnCommand, pressing the button will turn the light on:

// Invoker
type Button struct {
    command Command
}

// NewButton creates a new Button
func NewButton(command Command) *Button {
    return &Button{command: command}
}

// SetCommand method for Button
func (b *Button) SetCommand(command Command) {
    b.command = command
}

// Press method for Button which triggers the command
func (b *Button) Press() {
    b.command.Execute()
}

Finally, we demonstrate how to use the Command Pattern in the main function by creating concrete commands, setting them on the invoker, and triggering them using the invoker:

func main() {
    lightOn := &LightOnCommand{}
    lightOff := &LightOffCommand{}

    button := NewButton(lightOn)
    button.Press() // Output: The light is turned on.

    button.SetCommand(lightOff)
    button.Press() // Output: The light is turned off.
}

As you see in the output comments, the Command Pattern allows us to encapsulate actions as objects, making it easy to parameterize and execute them.

Let's break down the key components of the Command Pattern:

• Command: This interface defines the method that concrete commands must implement. In our example, the Execute method is used to trigger the command.
• Concrete Commands: These are the specific commands that encapsulate actions. In our example, LightOnCommand and LightOffCommand are concrete commands that turn the light on and off, respectively.
• Invoker: The Button struct acts as an invoker that holds a command and triggers it when needed. The Press method executes the command.
• Client Code: The main function demonstrates how to create concrete commands, set them on the invoker, and trigger them using the invoker.