How to Apply Design Patterns in Go

Table of Contents

1. Introduction
2. Prerequisites
3. Design Patterns Overview
4. Singleton Pattern
5. Factory Pattern
6. Observer Pattern
7. Conclusion

Introduction

Welcome to this tutorial on how to apply design patterns in Go! Design patterns are reusable solutions to common problems that occur in software design. They provide a proven approach to solving these problems and can enhance code organization, maintainability, and reusability.

By the end of this tutorial, you will have a solid understanding of various design patterns and how to implement them in Go. We will cover three popular design patterns: Singleton, Factory, and Observer.

Prerequisites

Before proceeding with this tutorial, you should be familiar with the basics of Go programming language including variables, functions, and structs. Additionally, you should have Go installed on your system.

Design Patterns Overview

Design patterns are categorized into three main types: Creational, Structural, and Behavioral patterns. Creational patterns focus on object creation, Structural patterns deal with object composition, and Behavioral patterns address communication between objects.

In this tutorial, we will primarily focus on Creational and Behavioral patterns as they are widely used in Go projects.

Singleton Pattern

The Singleton pattern ensures that a class has only one instance and provides a global point of access to it. This pattern is often used when you want to restrict the number of instances for a resource-intensive object or when you need a shared resource across multiple parts of an application.

To implement the Singleton pattern in Go, you can follow these steps:

1. Create a struct type with private data and a private constructor.

2. Add a static method to the struct to return the instance of the struct.

3. Access the singleton instance using the static method.

   Let’s illustrate these steps with an example. Consider a Logger struct that we want to make a singleton:

    package main
       
    import (
    	"fmt"
    )
       
    type Logger struct {
    	logs []string
    }
       
    var instance *Logger
       
    func GetLogger() *Logger {
    	if instance == nil {
    		instance = &Logger{}
    	}
    	return instance
    }
       
    func (logger *Logger) AddLog(log string) {
    	logger.logs = append(logger.logs, log)
    }
       
    func (logger *Logger) PrintLogs() {
    	for _, log := range logger.logs {
    		fmt.Println(log)
    	}
    }
       
    func main() {
    	logger := GetLogger()
       
    	logger.AddLog("First log")
    	logger.AddLog("Second log")
    	logger.PrintLogs()
    }
   

   In the code above, we define a Logger struct with private logs data. The GetLogger function is responsible for creating and returning the singleton instance of the Logger. By calling GetLogger multiple times, we will always get the same instance.

   Singleton pattern ensures that no matter where and how many times we access the Logger, we always operate on the same instance. This can be useful in scenarios where we want to maintain a single log instance throughout the application.

Factory Pattern

The Factory pattern provides a way to create objects without exposing the instantiation logic to the client. It encapsulates the object creation in a separate factory class, allowing the client to use the factory to create objects based on specific conditions or requirements.

To implement the Factory pattern in Go, you can follow these steps:

1. Create an interface for the objects that the factory will create.

2. Implement concrete types that satisfy the interface.

3. Create a factory struct that has a method to create objects based on input conditions.

   Let’s demonstrate this pattern with an example. Consider a Shape interface and its concrete implementations: Circle and Rectangle. We will create a ShapeFactory that can create different types of shapes based on user input:

    package main
       
    import (
    	"fmt"
    )
       
    type Shape interface {
    	Draw()
    }
       
    type Circle struct{}
       
    func (c *Circle) Draw() {
    	fmt.Println("Drawing a circle")
    }
       
    type Rectangle struct{}
       
    func (r *Rectangle) Draw() {
    	fmt.Println("Drawing a rectangle")
    }
       
    type ShapeFactory struct{}
       
    func (sf *ShapeFactory) CreateShape(shapeType string) Shape {
    	switch shapeType {
    	case "circle":
    		return &Circle{}
    	case "rectangle":
    		return &Rectangle{}
    	default:
    		return nil
    	}
    }
       
    func main() {
    	shapeFactory := ShapeFactory{}
       
    	circle := shapeFactory.CreateShape("circle")
    	circle.Draw()
       
    	rectangle := shapeFactory.CreateShape("rectangle")
    	rectangle.Draw()
    }
   

   In the code above, we define a Shape interface and its concrete implementations, Circle and Rectangle. The ShapeFactory struct has a CreateShape method that returns a Shape based on the shapeType input.

   The Factory pattern allows the client to create objects without knowing the specific implementation details. It provides a way to abstract the object creation logic and enable flexibility in creating different types of objects.

Observer Pattern

The Observer pattern establishes a one-to-many relationship between objects such that when one object changes its state, all its dependent objects are notified automatically. This pattern is useful when you want to maintain consistency between related objects or when you need to trigger certain actions based on changes in other objects.

To implement the Observer pattern in Go, you can follow these steps:

1. Define an interface for the observers with a method to receive updates.

2. Implement concrete observer types that satisfy the observer interface.

3. Create a subject struct that maintains a list of observers and has methods to add, remove, and notify observers.

   Let’s demonstrate this pattern with an example. Consider a subject called WeatherStation that maintains weather-related data. We will create observers to display current conditions and forecast:

    package main
       
    import (
    	"fmt"
    )
       
    type Observer interface {
    	Update(temperature float64, humidity float64, pressure float64)
    }
       
    type CurrentConditionsDisplay struct{}
       
    func (ccd *CurrentConditionsDisplay) Update(temperature float64, humidity float64, pressure float64) {
    	fmt.Printf("Current Conditions: Temperature=%.2f, Humidity=%.2f, Pressure=%.2f\n", temperature, humidity, pressure)
    }
       
    type ForecastDisplay struct{}
       
    func (fd *ForecastDisplay) Update(temperature float64, humidity float64, pressure float64) {
    	fmt.Println("Forecast: Sunshine expected")
    }
       
    type WeatherStation struct {
    	observers []Observer
    }
       
    func (ws *WeatherStation) AddObserver(observer Observer) {
    	ws.observers = append(ws.observers, observer)
    }
       
    func (ws *WeatherStation) RemoveObserver(observer Observer) {
    	for i, obs := range ws.observers {
    		if obs == observer {
    			ws.observers = append(ws.observers[:i], ws.observers[i+1:]...)
    			break
    		}
    	}
    }
       
    func (ws *WeatherStation) NotifyObservers(temperature float64, humidity float64, pressure float64) {
    	for _, observer := range ws.observers {
    		observer.Update(temperature, humidity, pressure)
    	}
    }
       
    func main() {
    	weatherStation := WeatherStation{}
    	currentConditionsDisplay := CurrentConditionsDisplay{}
    	forecastDisplay := ForecastDisplay{}
       
    	weatherStation.AddObserver(&currentConditionsDisplay)
    	weatherStation.AddObserver(&forecastDisplay)
       
    	weatherStation.NotifyObservers(25.5, 70.2, 1013.5)
    }
   

   In the code above, we define an Observer interface and two concrete implementations: CurrentConditionsDisplay and ForecastDisplay. The WeatherStation struct acts as the subject and keeps track of its observers. When the subject’s state changes, it notifies all its observers.

   The Observer pattern enables loose coupling between subjects and observers. It allows for adding or removing observers dynamically and ensures that changes in one part of the system are automatically propagated to other parts.

Conclusion

In this tutorial, we covered three popular design patterns in Go: Singleton, Factory, and Observer. These design patterns provide reusable solutions for common problems in software design.

You should now have a good understanding of how to implement these patterns in Go. Remember to study and practice these patterns further to fully grasp their benefits and applications.

Design patterns are powerful tools in software development. They can help improve the structure and maintainability of your code, so it’s essential to explore and utilize them in your projects.

Published: 28 September 2022

Related Articles

• Getting Started Guide: Introduction to Go Programming on Linux
• Writing Idiomatic and Effective Go Code
• Mastering Array Manipulation in Go
• Effective Use of Select Statements in Go
• How to Improve the Runtime Performance of Go Programs
• The Comprehensive Guide to the sync.Mutex and sync.RWMutex in Go
• Creating a Multi-Page Web Application in Go
• A Practical Guide to Go's Minimal Version Selection
• Go Design Patterns: An In-Depth Guide
• Understanding and Resolving Go Modules Errors
• Working with File Metadata in Go
• How to Use the os.FileInfo Interface in Go
• Understanding Channel Types in Go
• Mastering the Use of Go's fmt.Stringer Interface
• Reading and Writing to a Text File in Go
• Understanding Map Operations in Go
• Writing a CLI for Log Parsing in Go
• Understanding Go's Garbage Collection Mechanism
• Go Project Structure: Best Practices for Large Applications
• Go Design Patterns and Idiomatic Practices