GoLang - 30 - Design Patterns in Go

Design Patterns in Go: Singleton, Factory, and Observer Patterns

Design patterns are essential tools for creating clean, maintainable, and flexible software. In Go, you can apply various design patterns to solve common problems. In this section, we’ll explore three key design patterns in Go: the Singleton pattern, the Factory pattern, and the Observer pattern.

The Singleton Pattern

The Singleton pattern ensures that a class has only one instance and provides a global point of access to it. This is useful when you want to restrict the instantiation of a type to a single object. In Go, you can implement the Singleton pattern using a combination of Go’s features:

Private Constructor: Ensure that the constructor of your type is private, preventing direct instantiation from outside the package.
Exported Instance: Provide an exported instance of your type, allowing access to the single object.
Once.Do: Use Go’s “sync.Once” to initialize the instance lazily and safely.

Example: Singleton Pattern

Let’s create a simple Singleton pattern for a logger in Go:


package singleton

import (
    "log"
    "sync"
)

type Logger struct {
    logLevel int
}

var instance *Logger
var once sync.Once

func GetLogger() *Logger {
    once.Do(func() {
        instance = &Logger{logLevel: 1}
    })
    return instance
}

func (l *Logger) SetLogLevel(level int) {
    l.logLevel = level
}

func (l *Logger) Log(message string) {
    if l.logLevel >= 1 {
        log.Println(message)
    }
}

In this example, the “sync.Once” package ensures that the instance of the logger is created only once when “GetLogger” is called for the first time.

The Factory Pattern

The Factory pattern is used to create objects without specifying the exact class of the object that will be created. It provides an interface for creating objects but leaves the choice of the object’s type to the subclasses. In Go, you can implement the Factory pattern using interface types:

Factory Interface: Define a factory interface that declares a method for creating objects.
Concrete Factories: Create concrete factory types that implement the factory interface and return specific object types.
Client Code: Use the factory interface to create objects without knowing their exact types.

Example: Factory Pattern

Let’s create a factory for geometric shapes in Go:


package factory

import "fmt"

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

type Square struct {
    SideLength float64
}

func (s Square) Area() float64 {
    return s.SideLength * s.SideLength
}

type ShapeFactory interface {
    CreateShape() Shape
}

type CircleFactory struct{}

func (cf CircleFactory) CreateShape() Shape {
    return Circle{Radius: 1.0}
}

type SquareFactory struct{}

func (sf SquareFactory) CreateShape() Shape {
    return Square{SideLength: 2.0}
}

func CalculateArea(sf ShapeFactory) {
    shape := sf.CreateShape()
    fmt.Printf("Area of shape: %.2f\n", shape.Area())
}

In this example, we have defined a factory for geometric shapes with concrete factories for circles and squares. The client code, represented by the “CalculateArea” function, uses the factory interface to create shapes without knowledge of their exact types.

The Observer Pattern

The Observer pattern defines a one-to-many relationship between objects, where one object (the subject) maintains a list of its dependents (observers) and notifies them of state changes. This pattern is useful when you need to establish dynamic relationships between objects. In Go, you can implement the Observer pattern using channels:

Subject: Create a subject struct with an observer channel to which observers can subscribe.
Observer Interface: Define an observer interface with an “Update” method for receiving updates.
Register Observers: Allow observers to register themselves with the subject’s observer channel.
Notify Observers: Notify registered observers when the subject’s state changes.

Example: Observer Pattern

Let’s implement a simple chat room using the Observer pattern in Go:


package observer

import "fmt"

type Message struct {
    Sender    string
    Content   string
}

type Observer interface {
    Update(message Message)
}

type ChatRoom struct {
    observers []Observer
}

func (cr *ChatRoom) RegisterObserver(observer Observer) {
    cr.observers = append(cr.observers, observer)
}

func (cr *ChatRoom) SendMessage(message Message) {
    fmt.Printf("%s: %s\n", message.Sender, message.Content)
    cr.NotifyObservers(message)
}

func (cr *ChatRoom) NotifyObservers(message Message) {
    for _, observer := range cr.observers {
        observer.Update(message)
    }
}

In this example, the “ChatRoom” acts as the subject, and observers can register themselves and receive updates when a message is sent in the chat room.

Conclusion

Design patterns are valuable tools for writing well-structured and maintainable Go code. The Singleton, Factory, and Observer patterns are just a few examples of how you can apply design patterns to your Go applications to improve code organization and maintainability.

GoLang – 30 – Design Patterns in Go