《golang设计模式》第二部分·结构型模式-02-桥接模式(Bridge)

1. 概念

桥(Bridge)使用组合关系将代码的实现层和抽象层分离,让实现层与抽象层代码可以分别自由变化。

例如 客户端调用桥接接口实现原有功能和扩展功能的组合

1.1 角色

  • Implementor(实施者):
    • 具体实施者的抽象,可以是一个接口。
  • Concrete Implementor(具体实施者):
    • 可以理解为扩展之前的原有功能
    • 桥接接口会在实现扩展功能的基础上调用它实现这些原有功能
  • Abstraction(抽象化):
    • 我们可以理解为桥接接口,它在提供扩展功能的同时也桥接了原有功能的接口
    • Refined Abstraction提供一个统一接口
    • 它关联了Implementor(或者进一步是Implementor的聚合)
  • Refined Abstraction(扩展抽象化):
    • 可以理解为它实现了具体的扩展功能,并实际调用了mplementor接口完成了原有功能

1.2 类图

«interface»
Implementor
+serviceImpl() : ReturnType
ConcreteImplementor
+serviceImpl() : ReturnType
+customService() : Type
«interface»
Abstraction
+Implementor:Implementor
+abstractService()
RefinedAbstraction
+extraService()
Client

2. 代码示例

2.1 设计

  • 定义一个实施者颜色
  • 定义三个具体实施者红色绿色黄色
    • 他们的use()方法来实现使用对应颜色
  • 定义一个抽象化类(桥接接口)笔刷
  • 定义两个扩展抽象化类粗笔刷细笔刷
    • 他们的画画方法
      • 实现扩展功能——用对应笔刷画画
      • 同时调用实施者接口,实现了对应的颜色功能
  • 定义一个工厂函数用来实例化一个具体的笔刷
  • 调用
    • 声明一个实施者
    • 实例化一个具体实施者
    • 用具体实施者实例化一个桥接
    • 调用桥接的方法实现原有功能和扩展功能的组合

2.1 代码

package main

import "fmt"

//定义实施者类
type Color interface {
	Use()
}

//定义具体实施者A
type Red struct{}

func (r Red) Use() {
	fmt.Println("Use Red color")
}
//定义具体实施者B
type Green struct{}

func (g Green) Use() {
	fmt.Println("Use Green color")
}
//定义具体实施者C
type Yellow struct{}

func (y Yellow) Use() {
	fmt.Println("Use Yellow color")
}

// 定义抽象化类(或叫桥接接口)
type BrushPen interface {
	DrawPicture()
}

// 定义扩展抽象化A
type BigBrushPen struct {
	Color
}

//提供扩展功能,同时选择原功能执行
func (bbp BigBrushPen) DrawPicture() {
	fmt.Println("Draw picture with big brush pen")
	bbp.Use()
}

// 定义扩展抽象化B
type SmallBrushPen struct {
	Color
}
//提供扩展功能,同时选择原功能执行
func (sbp SmallBrushPen) DrawPicture() {
	fmt.Println("Draw picture with small brush pen")
	sbp.Use()
}

// 定义工厂方法生产具体的扩展抽象化(此处为了方便展示,和桥接模式无关)
func NewBrushPen(t string, color Color) BrushPen {
	switch t {
	case "BIG":
		return BigBrushPen{
			Color: color,
		}
	case "SMALL":
		return SmallBrushPen{
			Color: color,
		}
	default:
		return nil
	}
}

func main() {
    //声明实施者
	var tColor Color
	fmt.Println("========== 第一次测试 ==========")
	//定义为具体实施者
	tColor = Red{}
	//用具体实施者实例化一个抽象化
	tBrushPen := NewBrushPen("BIG", tColor)
	//用抽象化的画画功能完成扩展功能(粗细笔刷)和对应原功能(颜色)的组合操作
	tBrushPen.DrawPicture()
	fmt.Println("========== 第二次测试 ==========")
	tColor = Green{}
	tBrushPen = NewBrushPen("SMALL", tColor)
	tBrushPen.DrawPicture()
	fmt.Println("========== 第三次测试 ==========")
	tColor = Yellow{}
	tBrushPen = NewBrushPen("BIG", tColor)
	tBrushPen.DrawPicture()
}
  • 输出
========== 第一次测试 ==========
Draw picture with big brush pen  
Use Red color
========== 第二次测试 ========== 
Draw picture with small brush pen
Use Green color
========== 第三次测试 ========== 
Draw picture with big brush pen  
Use Yellow color

2.2 类图

«interface»
Color
+Use()
Red
+Use()
Green
+Use()
Yellow
+Use()
«interface»
BrushPen
+DrawPicture()
BigBrushPen
+Color
+DrawPicture()
SmallBrushPen
+Color
+DrawPicture()
Client

在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
以下是几种常见的Golang设计模式: 1. 工厂模式(Factory Pattern):用于创建对象的模式,通过定义一个创建对象的接口来实现对象的实例化。 ```go 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) GetShape(shapeType string) Shape { if shapeType == "circle" { return &Circle{} } else if shapeType == "rectangle" { return &Rectangle{} } return nil } func main() { factory := &ShapeFactory{} circle := factory.GetShape("circle") circle.Draw() // 输出:Drawing a circle rectangle := factory.GetShape("rectangle") rectangle.Draw() // 输出:Drawing a rectangle } ``` 2. 单例模式(Singleton Pattern):确保一个类只有一个实例,并提供一个全局访问点。 ```go type Singleton struct{} var instance *Singleton func GetInstance() *Singleton { if instance == nil { instance = &Singleton{} } return instance } func main() { singleton1 := GetInstance() singleton2 := GetInstance() fmt.Println(singleton1 == singleton2) // 输出:true } ``` 3. 观察者模式(Observer Pattern):定义了一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖它的对象都会得到通知并自动更新。 ```go type Subject struct { observers []Observer } func (s *Subject) Attach(observer Observer) { s.observers = append(s.observers, observer) } func (s *Subject) Notify() { for _, observer := range s.observers { observer.Update() } } type Observer interface { Update() } type ConcreteObserver struct{} func (co *ConcreteObserver) Update() { fmt.Println("Observer is updated") } func main() { subject := &Subject{} observer := &ConcreteObserver{} subject.Attach(observer) subject.Notify() // 输出:Observer is updated } ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

玄德公笔记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值