适配器模式
将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作。
image.png
package adapter
//适配器接口
type Target interface {
Request() string
}
//被适配的目标接口
type Adaptee interface {
SpecificRequest() string
}
//
type adapter struct {
Adaptee
}
//Request 实现Target接口
func (a *adapter) Request() string {
return a.SpecificRequest()
}
//NewAdapter 是Adapter的工厂函数
func NewAdapter(adaptee Adaptee) Target {
return &adapter{
Adaptee: adaptee,
}
}
桥接模式
设想如果要绘制矩形、圆形、椭圆、正方形，我们至少需要4个形状类，但是如果绘制的图形需要具有不同的颜色，如红色、绿色、蓝色等。那么有两种方案：1.为每一种形状设置一套颜色方案；2.根据实际需要对形状和颜色进行组合。第二种方案就是桥接模式，将抽象部分与它的实现部分分离，使它们都可以独立地变化。
image.png
优点
1.分离抽象接口及其实现部分。
2.桥接模式有时类似于多继承方案，但是多继承方案违背了类的单一职责原则
缺点
桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进
package bridge
import "fmt"
type Color interface {
Use()
}
type Red struct{}
func (r Red) Use() {
fmt.Println("Use Red color")
}
type Green struct{}
func (g Green) Use() {
fmt.Println("Use Green color")
}
type Yellow struct{}
func (y Yellow) Use() {
fmt.Println("Use Yellow color")
}
type BrushPen interface {
DrawPicture()
}
type BigBrushPen struct {
Color
}
func (bbp BigBrushPen) DrawPicture() {
fmt.Println("Draw picture with big brush pen")
bbp.Use()
}
装饰器模式
动态地给一个对象增加一些额外的职责(Responsibility)，就增加对象功能来说，装饰模式比生成子类实现更为灵活
image.png
package decorator
//原始接口
type Component interface {
Calc() int
}
//原始类
type ConcreteComponent struct{}
func (*ConcreteComponent) Calc() int {
return 0
}
//装饰类
type MulDecorator struct {
Component
num int
}
//装饰类实现了原始接口
func (d *MulDecorator) Calc() int {
return d.Component.Calc() * d.num
}
func WarpMulDecorator(c Component, num int) Component {
return &MulDecorator{
Component: c,
num: num,
}
}
外观模式
外部与一个子系统的通信必须通过一个统一的外观对象进行，为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
image.png
package facade
import "fmt"
type AModuleAPI interface {
TestA() string
}
type BModuleAPI interface {
TestB() string
}
//装饰接口
type API interface {
Test() string
}
//装饰结构体
type apiImpl struct {
a AModuleAPI
b BModuleAPI
}
func (a *apiImpl) Test() string {
aRet := a.a.TestA()
bRet := a.b.TestB()
return fmt.Sprintf("%s\n%s", aRet, bRet)
}
享元模式
运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用。
image.png
// 享元对象接口
type IFlyweight interface {
Operation(int) //来自外部的状态
}
// 共享对象
type ConcreteFlyweight struct {
name string
}
func (c *ConcreteFlyweight) Operation(outState int) {
if c == nil {
return
}
fmt.Println("共享对象响应外部状态", outState)
}
// 不共享对象
type UnsharedConcreteFlyweight struct {
name string
}
func (c *UnsharedConcreteFlyweight) Operation(outState int) {
if c == nil {
return
}
fmt.Println("不共享对象响应外部状态", outState)
}
代理模式
给某一个对象提供一个代 理，并由代理对象控制对原对象的引用
image.png
package proxy
type Subject interface {
Do() string
}
type RealSubject struct{}
func (RealSubject) Do() string {
return "real"
}
type Proxy struct {
real RealSubject
}
func (p Proxy) Do() string {
var res string
// 在调用真实对象之前的工作，检查缓存，判断权限，实例化真实对象等。。
res += "pre:"
// 调用真实对象
res += p.real.Do()
// 调用之后的操作，如缓存结果，对结果进行处理等。。
res += ":after"
return res
}
