Golang Bridge Pattern

1. What is the Bridge Pattern

1.1 Definition and Concept

The Bridge Pattern, also known as the Bridge pattern, is a type of structural design pattern that decouples the abstraction and implementation, allowing them to vary independently. In simple terms, the Bridge Pattern is a solution that separates the abstraction from the implementation.

1.2 Purpose and Effect of the Bridge Pattern

The main purpose of the Bridge Pattern is to decouple the abstraction part from its implementation part so that they can change and expand independently. This is accomplished by establishing an abstract bridge class that is linked to a concrete implementation class.

2. Characteristics and Advantages of the Bridge Pattern

Some of the main characteristics and advantages of the Bridge Pattern include:

• Enhanced system scalability. Both the abstraction and implementation can be independently extended without affecting each other.
• Compliance with the Open/Closed Principle. The abstraction part and the implementation part can be extended independently without affecting each other.
• Transparency of implementation details to the client, allowing the hiding of implementation details from the user.

3. Application Scenarios of the Bridge Pattern

• When you want to separate the implementation of a complex object from its abstraction, the Bridge Pattern can be used. This may have a positive impact on the performance of existing code, especially when the program only uses a part of the object at runtime.
• When you need to share specific implementation states among multiple objects, but for the client code, they need to appear as independent classes.

4. Implementation of the Bridge Pattern in Golang

4.1 Introduction to UML Class Diagram

4.2 Detailed Implementation Steps

4.2.1 Define the Abstract Role Interface

First, we define a DrawAPI interface, the specific code is as follows:

// Abstract role interface
type DrawAPI interface {
	DrawACircle(radius, x, y int)
}

4.2.2 Implement the Concrete Role Class

Then, we define two classes, RedCircle and BlueCircle, which implement the methods in the DrawAPI interface:

// Concrete role class
type RedCircle struct {}

func (c *RedCircle) DrawACircle(radius, x, y int) {
    // logic of drawing a red circle
}

type BlueCircle struct {}

func (c *BlueCircle) DrawACircle(radius, x, y int) {
    // logic of drawing a blue circle
}

4.2.3 Define the Abstract Bridge Interface

Define the Shape bridge interface:

// Abstract bridge interface
type Shape interface {
	Draw()
}

4.2.4 Implement the Concrete Bridge Class

Implement the Circle class, which implements the Shape interface and contains an object of type DrawAPI interface:

// Concrete bridge class
type Circle struct {
    x, y, radius int
    drawAPI      DrawAPI
}

func (c *Circle) Draw() {
    c.drawAPI.DrawACircle(c.radius, c.x, c.y)
}

4.2.5 Client Invocation Example

func main() {
    redCircle := &Circle{100, 100, 10, new(RedCircle)}
    blueCircle := &Circle{100, 100, 10, new(BlueCircle)}

    redCircle.Draw()
    blueCircle.Draw()
}

In this way, we have implemented the Bridge pattern in Golang.