使用Golang的interface接口设计准则

作者 : 开心源码 本文共6638个字,预计阅读时间需要17分钟 发布时间: 2022-05-13 共294人阅读

1 interface接口

interface 是GO语言的基础特性之一。可以了解为一种类型的规范或者者商定。它跟java,C# 不太一样,不需要显示说明实现了某个接口,它没有继承或者子类或者“implements”关键字,只是通过商定的形式,隐式的实现interface 中的方法就可。因而,Golang 中的 interface 让编码更灵活、易扩展。
如何了解go 语言中的interface ? 只要记住以下三点就可:

\color{red}{1. interface 是方法声明的集合}
\color{red}{2. 任何类型的对象实现了在interface 接口中声明的全部方法,则表明该类型实现了该接口。}
\color{red}{3. interface 可以作为一种数据类型,实现了该接口的任何对象都可以给对应的接口类型变量赋值。}

注意:
  a. interface 可以被任意对象实现,一个类型/对象也可以实现多个 interface
  b. 方法不能重载,如 eat(), eat(s string) 不能同时存在

package mainimport "fmt"type Phone interface {    call()}type NokiaPhone struct {}func (nokiaPhone NokiaPhone) call() {    fmt.Println("I am Nokia, I can call you!")}type ApplePhone struct {}func (iPhone ApplePhone) call() {    fmt.Println("I am Apple Phone, I can call you!")}func main() {    var phone Phone    phone = new(NokiaPhone)    phone.call()    phone = new(ApplePhone)    phone.call()}

上述中表现了interface接口的语法,在main函数中,也表现了多态的特性。
同样一个phone的笼统接口,分别指向不同的实体对象,调用的call()方法,打印的效果不同,那么就是表现出了多态的特性。

2 面向对象中的开闭准则

2.1 平铺式的模块设计

那么作为interface数据类型,他存在的意义在哪呢? 实际上是为了满足少量面向对象的编程思想。我们知道,软件设计的最高目标就是高内聚,低耦合。那么其中有一个设计准则叫开闭准则。什么是开闭准则呢,接下来我们看一个例子:

package mainimport "fmt"//我们要写一个类,Banker银行业务员type Banker struct {}//存款业务func (this *Banker) Save() {    fmt.Println( "进行了 存款业务...")}//转账业务func (this *Banker) Transfer() {    fmt.Println( "进行了 转账业务...")}//支付业务func (this *Banker) Pay() {    fmt.Println( "进行了 支付业务...")}func main() {    banker := &Banker{}    banker.Save()    banker.Transfer()    banker.Pay()}

代码很简单,就是一个银行业务员,他可能拥有很多的业务,比方Save()存款、Transfer()转账、Pay()支付等。那么假如这个业务员模块只有这几个方法还好,但是随着我们的程序写的越来越复杂,银行业务员可能就要添加方法,会导致业务员模块越来越臃肿。

Easy搞定Golang设计模式.001.png

这样的设计会导致,当我们去给Banker增加新的业务的时候,会直接修改原有的Banker代码,那么Banker模块的功能会越来越多,出现问题的几率也就越来越大,如果此时Banker已经有99个业务了,现在我们要增加第100个业务,可能因为一次的不小心,导致之前99个业务也一起崩溃,由于所有的业务都在一个Banker类里,他们的耦合度太高,Banker的职责也不够单一,代码的维护成本随着业务的复杂正比成倍增大。

2.2 开闭准则设计

那么,假如我们拥有接口, interface这个东西,那么我们即可以笼统一层出来,制作一个笼统的Banker模块,而后提供一个笼统的方法。 分别根据这个笼统模块,去实现支付Banker(实现支付方法),转账Banker(实现转账方法)
如下:

Easy搞定Golang设计模式.002.png

那么仍然可以搞定程序的需求。 而后,当我们想要给Banker增加额外功能的时候,之前我们是直接修改Banker的内容,现在我们可以单独定义一个股票Banker(实现股票方法),到这个系统中。 而且股票Banker的实现成功或者者失败都不会影响之前的稳固系统,他很单一,而且独立。

所以以上,当我们给一个系统增加一个功能的时候,不是通过修改代码,而是通过增添代码来完成,那么就是开闭准则的核心思想了。所以要想满足上面的要求,是肯定需要interface来提供一层笼统的接口的。

golang代码实现如下:

package mainimport "fmt"//笼统的银行业务员type AbstractBanker interface{    DoBusi()    //笼统的解决业务接口}//存款的业务员type SaveBanker struct {    //AbstractBanker}func (sb *SaveBanker) DoBusi() {    fmt.Println("进行了存款")}//转账的业务员type TransferBanker struct {    //AbstractBanker}func (tb *TransferBanker) DoBusi() {    fmt.Println("进行了转账")}//支付的业务员type PayBanker struct {    //AbstractBanker}func (pb *PayBanker) DoBusi() {    fmt.Println("进行了支付")}func main() {    //进行存款    sb := &SaveBanker{}    sb.DoBusi()    //进行转账    tb := &TransferBanker{}    tb.DoBusi()        //进行支付    pb := &PayBanker{}    pb.DoBusi()}

当然我们也可以根据AbstractBanker设计一个小框架

//实现架构层(基于笼统层进行业务封装-针对interface接口进行封装)func BankerBusiness(banker AbstractBanker) {    //通过接口来向下调用,(多态现象)    banker.DoBusi()}

那么main中可以如下实现业务调用:

func main() {    //进行存款    BankerBusiness(&SaveBanker{})    //进行存款    BankerBusiness(&TransferBanker{})    //进行存款    BankerBusiness(&PayBanker{})}

再看开闭准则定义:
开闭准则:一个软件实体如类、模块和函数应该对扩开展放,对修改关闭。
简单的说就是在修改需求的时候,应该尽量通过扩展来实现变化,而不是通过修改已有代码来实现变化。

3 接口的意义

好了,现在interface已经基本理解,那么接口的意义最终在哪里呢,想必现在你已经有了一个初步的认知,实际上接口的最大的意义就是实现多态的思想,就是我们可以根据interface类型来设计API接口,那么这种API接口的适应能力不仅能适应当下所实现的一律模块,也适应未来实现的模块来进行调用。 调用未来可能就是接口的最大意义所在吧,这也是为什么架构师那么值钱,由于良好的架构师是可以针对interface设计一套框架,在未来许多年却仍然适用。

4 面向对象中的依赖倒转准则

4.1 耦合度极高的模块关系设计

混乱的依赖关系.png

package mainimport "fmt"// === > 奔驰汽车 <===type Benz struct {}func (this *Benz) Run() {    fmt.Println("Benz is running...")}// === > 宝马汽车  <===type BMW struct {}func (this *BMW) Run() {    fmt.Println("BMW is running ...")}//===> 司机张三  <===type Zhang3 struct {    //...}func (zhang3 *Zhang3) DriveBenZ(benz *Benz) {    fmt.Println("zhang3 Drive Benz")    benz.Run()}func (zhang3 *Zhang3) DriveBMW(bmw *BMW) {    fmt.Println("zhang3 drive BMW")    bmw.Run()}//===> 司机李四 <===type Li4 struct {    //...}func (li4 *Li4) DriveBenZ(benz *Benz) {    fmt.Println("li4 Drive Benz")    benz.Run()}func (li4 *Li4) DriveBMW(bmw *BMW) {    fmt.Println("li4 drive BMW")    bmw.Run()}func main() {    //业务1 张3开奔驰    benz := &Benz{}    zhang3 := &Zhang3{}    zhang3.DriveBenZ(benz)    //业务2 李四开宝马    bmw := &BMW{}    li4 := &Li4{}    li4.DriveBMW(bmw)}

我们来看上面的代码和图中每个模块之间的依赖关系,实际上并没有用到任何的interface接口层的代码,显然最后我们的两个业务 张三开奔驰, 李四开宝马,程序中也都实现了。但是这种设计的问题就在于,小规模没什么问题,但是一旦程序需要扩展,比方我现在要添加一个丰田汽车 或者者 司机王五, 那么模块和模块的依赖关系将成指数级递增,想蜘蛛网一样越来越难维护和捋顺。

4.2 面向笼统层依赖倒转

依赖倒转设计.png
如上图所示,假如我们在设计一个系统的时候,将模块分为3个层次,笼统层、实现层、业务逻辑层。那么,我们首先将笼统层的模块和接口定义出来,这里就需要了interface接口的设计,而后我们依照笼统层,依次实现每个实现层的模块,在我们写实现层代码的时候,实际上我们只要要参考对应的笼统层实现就好了,实现每个模块,也和其余的实现的模块没有关系,这样也符合了上面详情的开闭准则。这样实现起来每个模块只依赖对象的接口,而和其余模块没关系,依赖关系单一。系统容易扩展和维护。
我们在指定业务逻辑也是一样,只要要参考笼统层的接口来业务就好了,笼统层暴露出来的接口就是我们业务层可以使用的方法,而后可以通过多态的线下,接口指针指向哪个实现模块,调用了就是具体的实现方法,这样我们业务逻辑层也是依赖笼统成编程。
我们就将这种的设计准则叫做依赖倒转准则。
来一起看一下修改的代码:

package mainimport "fmt"// ===== >   笼统层  < ========type Car interface {    Run()}type Driver interface {    Drive(car Car)}// ===== >   实现层  < ========type BenZ struct {    //...}func (benz * BenZ) Run() {    fmt.Println("Benz is running...")}type Bmw struct {    //...}func (bmw * Bmw) Run() {    fmt.Println("Bmw is running...")}type Zhang_3 struct {    //...}func (zhang3 *Zhang_3) Drive(car Car) {    fmt.Println("Zhang3 drive car")    car.Run()}type Li_4 struct {    //...}func (li4 *Li_4) Drive(car Car) {    fmt.Println("li4 drive car")    car.Run()}// ===== >   业务逻辑层  < ========func main() {    //张3 开 宝马    var bmw Car    bmw = &Bmw{}    var zhang3 Driver    zhang3 = &Zhang_3{}    zhang3.Drive(bmw)    //李4 开 奔驰    var benz Car    benz = &BenZ{}    var li4 Driver    li4 = &Li_4{}    li4.Drive(benz)}

4.3 依赖倒转小练习

模拟组装2台电脑,
— 笼统层 —有显卡Card 方法display,有内存Memory 方法storage,有解决器CPU 方法calculate
— 实现层层 —有 Intel因特尔公司 、产品有(显卡、内存、CPU),有 Kingston 公司, 产品有(内存3),有 NVIDIA 公司, 产品有(显卡)
— 逻辑层 —1. 组装一台Intel系列的电脑,并运行,2. 组装一台 Intel CPU Kingston内存 NVIDIA显卡的电脑,并运行

/*    模拟组装2台电脑    --- 笼统层 ---    有显卡Card  方法display    有内存Memory 方法storage    有解决器CPU   方法calculate    --- 实现层层 ---    有 Intel因特尔公司 、产品有(显卡、内存、CPU)    有 Kingston 公司, 产品有(内存3)    有 NVIDIA 公司, 产品有(显卡)    --- 逻辑层 ---    1. 组装一台Intel系列的电脑,并运行    2. 组装一台 Intel CPU  Kingston内存 NVIDIA显卡的电脑,并运行*/package mainimport "fmt"//------  笼统层 -----type Card interface{    Display()}type Memory interface {    Storage()}type CPU interface {    Calculate()}type Computer struct {    cpu CPU    mem Memory    card Card}func NewComputer(cpu CPU, mem Memory, card Card) *Computer{    return &Computer{        cpu:cpu,        mem:mem,        card:card,    }}func (this *Computer) DoWork() {    this.cpu.Calculate()    this.mem.Storage()    this.card.Display()}//------  实现层 -----//inteltype IntelCPU struct {    CPU }func (this *IntelCPU) Calculate() {    fmt.Println("Intel CPU 开始计算了...")}type IntelMemory struct {    Memory}func (this *IntelMemory) Storage() {    fmt.Println("Intel Memory 开始存储了...")}type IntelCard struct {    Card}func (this *IntelCard) Display() {    fmt.Println("Intel Card 开始显示了...")}//kingstontype KingstonMemory struct {    Memory}func (this *KingstonMemory) Storage() {    fmt.Println("Kingston memory storage...")}//nvidiatype NvidiaCard struct {    Card}func (this *NvidiaCard) Display() {    fmt.Println("Nvidia card display...")}//------  业务逻辑层 -----func main() {    //intel系列的电脑    com1 := NewComputer(&IntelCPU{}, &IntelMemory{}, &IntelCard{})    com1.DoWork()    //杂牌子    com2 := NewComputer(&IntelCPU{}, &KingstonMemory{}, &NvidiaCard{})    com2.DoWork()}

文章推荐

开源软件作品

(原创开源)Zinx-基于Golang轻量级服务器并发框架[完整版(附教程视频)]
(原创开源)Lars-基于C++负载均衡远程调度系统[完整版]

精选文章

[典藏版]Golang调度器GMP原理与调度全分析


关于作者:

作者:Aceld(刘丹冰)

mail: danbing.at@gmail.com
github: aceld
原创书籍gitbook: http://legacy.gitbook.com/@aceld

关注作者

微信公众号“刘丹冰Aceld”

原创公告:未经作者允许请勿转载, 假如转载请注明出处

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » 使用Golang的interface接口设计准则

发表回复