golang设计模式(6)适配器模式

适配器模式设计意图
将一个类型的接口转换成客户希望的另外一个接口,使原本由于接口不兼容而不能一起工作的类可以一起工作。

适用性
.想适用一个已经存在的类型,而其接口不符合需求
.创建一个可以复用的类型,该类型可以与其他不相关的类型或不可预见的类型协同工作。
.(仅适用于对象Adapter)想使用一些已经存在的子类,但是不可能对每个子类修改为匹配他们的接口,对象适配器可以适配它的父类接口。

结构(uml)
适配器模式

适配器模式的类型
适配器可以分为类型适配器和对象适配器。
对于类型适配器:
.用一个具体的adapter类对adaptee和target进行匹配。结果是当我们想要匹配一个类及它的所有子类时,类adapter将无法胜任工作。
.类适配器可以使adapter重定义adptee的部分行为,因为adapter是adaptee的子类
.仅仅引入一个对象,并不需要额外的指针间接得到adaptee

对应对象适配器:
.对象适配器允许一个adapter和多个adaptee,即多个adaptee及其子类一起工作。
.对象适配器可能在重用方面会比较差,因为可以使用到的是adaptee的子类而不是adaptee本身。

总之,使用适配器,最重要的考虑因素为两个接口的相似程度,没有理由去适配两个毫无关联的接口。

golang实现

package main
import (
    "fmt"
)

type OldInterface interface {
    InsertToDatabase(Data interface{}) (bool, error)
}

type AddCustomInfoToMysql struct {
    DbName string
}

func (pA *AddCustomInfoToMysql) InsertToDatabase(info interface{}) (bool, error) {
    switch info.(type) {
    case string:
        fmt.Println("add ", info.(string), " to ", pA.DbName, " successful!")
    }
    return true, nil
}

type NewInterface interface {
    SaveData(Data interface{}) (bool, error)
}

type Adapter struct {
    OldInterface
}

func (pA *Adapter) SaveData(Data interface{}) (bool, error) {
    fmt.Println("In Adapter")
    return pA.InsertToDatabase(Data)
}

func main() {

    var iNew NewInterface
    iNew = &Adapter{OldInterface: &AddCustomInfoToMysql{DbName: "mysql"}}
    iNew.SaveData("helloworld")
    return
}

从实现例子可以看出,老接口方法为InsertToDatabase,新接口方法为SaveData。两者具有一点的相似性。当系统不想保留接口的时候,就可以用适配器来修饰。

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 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
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值