脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - 分析Go语言接口的设计原则

分析Go语言接口的设计原则

2021-08-10 01:15盛开的太阳 Golang

interface是Go语言的基础特性之一, 可以理解为对一种类型的规范或者约束。他跟java、c++不同, Go语言实现接口不需要显示说明实现了哪个接口, 也没有继承或者子类或者implement关键字。只是通过约定的形式, 隐式的实现接口中的方法即

一、前言

go的interface写起来更自由, 无需显示的实现, 只要实现了与interfece所包含的所有函数签名的相同的方法即可。让编码更灵活, 易扩展。

如何理解go语言中的interface呢?

1. interface是方法声明的集合

2.接口的方法与实现接口的类型方法格式一致

3.接口中所有方法均被实现

4. interface可以作为一种数据类型,实现了该接口的任何对象都可以给对应的接口类型变量赋值

特别说明两点：

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

那么作为interface数据类型，他存在的意义在哪呢？ 实际上是为了满足一些面向对象的编程思想。我们知道，软件设计的最高目标就是高内聚，低耦合。那么其中有一个设计原则叫开闭原则。什么是开闭原则

二、开闭原则

在面向对象编程领域中，开闭原则规定“软件中的对象（类，模块，函数等等）应该对于扩展是开放的，但是对于修改是封闭的”，这意味着一个实体是允许在不改变它的源代码的前提下变更它的行为。

看重点: 对于扩展是开放的, 对于修改是封闭的.

举个例子: 银行每天要办理不同的业务, 存款, 转账, 取款等. 如果直接是实体来实现如下

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package bank
 
import "fmt"
 
type banker struct {
 
}
 
func (b *banker) save() {
    fmt.println("存钱")
}
 
func (b *banker) transfer() {
    fmt.println("转账")
}
 
func (b *banker) get() {
    fmt.println("取钱")
}

有个人要来存钱取钱转账了

?
1
2
3
4
5
6
7
8
9
10
package main
 
import "aaa/bank"
 
func main() {
    var b = bank.banker{}
    b.save()
    b.get()
    b.transfer()
}

那么随着业务越来越多, 越来越大. 我又要新增加一些业务, 比如基金, 股票. 然后越来越多,越来越大. 导致banker这个模块越来越臃肿

分析Go语言接口的设计原则

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

我们使用开闭原则, 使用interface将banker模块抽象出来. 然后根据这个抽象的模块, 去实现save, get, transfer.....

分析Go语言接口的设计原则

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

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

golang代码实现如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package bank
 
import "fmt"
 
// 对银行的业务进行抽象
type business interface {
    dobussiness()
}
 
 
// 存钱业务
type savebussiness struct {
}
 
 
func (b *savebussiness) dobussiness() {
    fmt.sprintf("存钱")
}
 
 
//取钱业务
type getbussiness struct {
}
 
func (g *getbussiness) dobussiness() {
    fmt.println("取钱")
}
 
 
// 转账业务
type transferbusi struct {
 
}
 
func (t *transferbusi) dobussiness() {
    fmt.sprintf("转账")
}

然后我今天去了银行, 我们封装一个银行, 银行有各种各样的能力.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main
 
import (
    "aaa/bank"
    "fmt"
)
 
// 这有一个银行, 银行可以办理业务
func bank(b bank.business) {
    fmt.println("办理业务: ", b.dobussiness())
}
 
func main() {
    // 办理具体的业务
    bank(&bank.savebussiness{})
    bank(&bank.getbussiness{})
    bank(&bank.transferbusi{})
}

这样, 当银行增加业务类型, 比如股票的时候, 只需要扩展业务接口就可以了, 不会对原来的接口进行修改

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

接口的意义:

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

三、依赖倒置原则

3.1、什么是依赖倒置原则　　

依赖倒置原则（dependence inversion principle）是程序要依赖于抽象接口，不要依赖于具体实现。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

3.2、一个耦合度极高的模块关系设计

分析Go语言接口的设计原则

张三驾驶奔驰, 张三驾驶宝马, 张三驾驶丰田.

李四驾驶宝马, 李四驾驶奔驰, 李四驾驶丰田

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package yldz
 
import "fmt"
 
// 奔驰车
type benz struct {
 
}
 
func (b *benz) run() string{
    return fmt.sprintf("奔驰启动")
}
// 宝马
type bm struct {
 
}
 
func (b *bm) run() string{
    return fmt.sprintf("宝马启动")
}
//丰田
type ft struct {
 
}
 
func (t *ft) run() string{
    return fmt.sprintf("丰田启动")
}
//====驾车人,张三
type zhangsan struct {
 
}
 
func (t *zhangsan) driverbenz(b *benz) {
    fmt.println("张三驾驶", b.run())
}
 
func (t *zhangsan) driverbm(b *bm) {
    fmt.println("张三驾驶", b.run())
}
 
func (t *zhangsan) driverft(b *ft) {
    fmt.println("张三驾驶", b.run())
}
 
// 驾车人----李四.......
?
1
2
3
4
5
6
7
8
9
10
package main
 
import "aaa/yldz"
 
func main() {
    z := yldz.zhangsan{}
    z.driverbenz(&yldz.benz{})
    z.driverbm(&yldz.bm{})
    z.driverft(&yldz.ft{})
}

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

3.3、面向抽象层依赖倒转

分析Go语言接口的设计原则

如上图所示，我们在设计一个系统的时候，将模块分为3个层次，抽象层、实现层、业务逻辑层。

  • 将抽象层的模块和接口定义出来，这里就需要了interface接口的设计，
  • 我们依照抽象层，依次实现每个实现层的模块，在我们写实现层代码的时候，实际上我们只需要参考对应的抽象层实现就好了，实现每个模块，也和其他的实现的模块没有关系，这样也符合了上面介绍的开闭原则。这样实现起来每个模块只依赖对象的接口，而和其他模块没关系，依赖关系单一。系统容易扩展和维护。
  • 业务逻辑层也是一样，只需要参考抽象层的接口来实现业务就好了，抽象层暴露出来的接口就是我们业务层可以使用的方法，然后可以通过多态的方向，接口指针指向哪个实现模块，调用了就是具体的实现方法，这样我们业务逻辑层也是依赖抽象成编程。

看看具体的实现

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package yldz
 
import "fmt"
 
type car interface {
    run() string
}
 
type driver interface {
    // 接口变量肚子里有一个指针, 所以接口变量不需要使用指针.
    driver(car car)
}
 
 
// 奔驰车
type benz struct {
 
}
 
func (b *benz) run() string{
    return fmt.sprintf("奔驰启动")
}
 
// 宝马车
type bm struct {
 
}
 
func (b *bm) run() string{
    return fmt.sprintf("宝马启动")
}
 
// 丰田车
type ft struct {
 
}
 
func (t *ft) run() string{
    return fmt.sprintf("丰田启动")
}
 
// ====张三
type zhangsan struct {
 
}
 
func (t *zhangsan) driver(car car) {
    fmt.println("驾驶",car.run())
}
?
1
2
3
4
5
6
7
8
9
func main() {
 
    benz := yldz.benz{}
    zs := yldz.zhangsan{}
    zs.driver(&benz)
 
    ft := yldz.ft{}
    zs.driver(&ft)
}

以上就是分析go语言接口的设计原则的详细内容，更多关于go 接口的资料请关注服务器之家其它相关文章！

原文链接：https://www.cnblogs.com/ITPower/p/12303673.html

  • 接口
  • GO语言

    • 延伸 · 阅读

    精彩推荐
    • Golanggolang如何使用struct的tag属性的详细介绍

      golang如何使用struct的tag属性的详细介绍

      这篇文章主要介绍了golang如何使用struct的tag属性的详细介绍，从例子说起，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看...

      Go语言中文网11352020-05-21
    • Golanggo日志系统logrus显示文件和行号的操作

      go日志系统logrus显示文件和行号的操作

      这篇文章主要介绍了go日志系统logrus显示文件和行号的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      SmallQinYan12302021-02-02
    • GolangGolang中Bit数组的实现方式

      Golang中Bit数组的实现方式

      这篇文章主要介绍了Golang中Bit数组的实现方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      天易独尊11682021-06-09
    • Golanggolang json.Marshal 特殊html字符被转义的解决方法

      golang json.Marshal 特殊html字符被转义的解决方法

      今天小编就为大家分享一篇golang json.Marshal 特殊html字符被转义的解决方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧 ...

      李浩的life12792020-05-27
    • Golanggolang的httpserver优雅重启方法详解

      golang的httpserver优雅重启方法详解

      这篇文章主要给大家介绍了关于golang的httpserver优雅重启的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，...

      helight2992020-05-14
    • Golanggolang 通过ssh代理连接mysql的操作

      golang 通过ssh代理连接mysql的操作

      这篇文章主要介绍了golang 通过ssh代理连接mysql的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      a165861639710342021-03-08
    • Golanggo语言制作端口扫描器

      go语言制作端口扫描器

      本文给大家分享的是使用go语言编写的TCP端口扫描器，可以选择IP范围，扫描的端口，以及多线程，有需要的小伙伴可以参考下。 ...

      脚本之家3642020-04-25
    • GolangGolang通脉之数据类型详情

      Golang通脉之数据类型详情

      这篇文章主要介绍了Golang通脉之数据类型，在编程语言中标识符就是定义的具有某种意义的词，比如变量名、常量名、函数名等等，Go语言中标识符允许由...

      羌4272021-11-24
    最近更新
    编辑推荐
    阅读排行
    热门标签
    gosublime 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图