【每周小结】2023-Week4

junedayday

发布于 2023-02-18 08:40:44

24400

代码可运行

文章被收录于专栏：Go编程点滴Go编程点滴

运行总次数：0

代码可运行

新的一年已经到来，祝各位读者2023年身体健康、家庭美满。

回到本篇的主题，我继续来聊聊本周的一些心得。

Go技巧 - 接口实现下的三个代码复用技巧

在面向对象开发的场景下，我们经常会写高度重复的Go代码。为了帮助大家形成一定的方法论，这里以一个具体场景为例，分享我的三个技巧。

示例：一个接口 + 三个实现

我们以上图为例，看看示例代码：

// 接口定义 - 订单
// 方法定义：创建订单Create与关闭订单Close
type Order interface {
  Create() error
  Close() error
}

// 三种具体的订单类型 Order1 Order2 Order3
// 为了实现接口Order，这三个结构都需要实现 Create与Close 方法

// Order1部分
type Order1 struct {}

func (o *Order1) Create() error {
}

func (o *Order1) Close() error { 
}

// Order2部分
type Order2 struct {}

func (o *Order2) Create() error {
}

func (o *Order2) Close() error { 
}

// Order3部分
type Order3 struct {}

func (o *Order3) Create() error {
}

func (o *Order3) Close() error { 
}

在实际场景中，Order1/Order2/Order3的逻辑、数据高度相似，出现大量的重复性代码。如何提升这部分代码的开发效率呢？下面给出三个途径：

方法1：快刀斩乱麻 - 函数复用

最直接的方法就是抛开面向对象的一堆概念，单纯地用函数复用来解决问题：

func createOrder(ctx context.Context, data interface{}) error {
}

func closeOrder(ctx context.Context, data interface{}) error {
}

// 以Order1为例，Order2/Order3类似
type Order1 struct {}

func (o *Order1) Create() error {
  // 调用 createOrder
}

func (o *Order1) Close() error { 
  // 调用 closeOrder
}

这种编程思维是面向过程的，虽然不够抽象，但它确实是 最便捷的代码复用方式。而且，在很多情况下，我们不会对这块代码有大更新，函数复用是一个 高性价比 的选择。

但我们的追求不仅限于此：如果这块代码涉及业务核心，高频迭代，会出现什么样的现象呢？举3个例子：

// 示例1 - 入参不断增加
// 某些订单的需要一些额外的数据，那么就必须增加入参（并且这个参数很难通用！）
func createOrder(ctx context.Context, data interface{}, other, more interface{}) error {
}

// 示例2 - 大量的if-else
// 一个函数适配多种逻辑，只能增加判断逻辑
func createOrder(ctx context.Context, data interface{}, otherData interface{}) error {
  if orderType == 1 {
  } else if price > 1000 {
  } else {
  }
}

// 示例3 - 创建多个函数
func createOrder2() error {}
func createOrder3() error {}

以上这些代码是不整洁的，相信大部分人不愿在自己开发过程中看到。这种过程性代码复用的思路，见效虽快，但在复杂场景下弊端愈发明显。下面，我们引入第二个方法：

方法2：对象抽象的妙用 - 嵌套+Overwrite

Go并不是一门完全面向对象的语言，但对于复杂场景，会用嵌套来支持一定的代码复用。代码示例如下：

// 一个基础对象，实现了接口 Order
type CommonOrder struct {}

func (o *CommonOrder) Create() error {
}

func (o *CommonOrder) Close() error { 
}

// Order1 利用嵌套，直接实现了Create和Close两个方法
type Order1 struct {
  *CommonOrder
}

// Order2 也利用了嵌套，Close方法会复用，但Create方法会被覆盖
type Order2 struct {
  *CommonOrder
}

// Overwrite
func (o *Order2) Create() error {
}

// Order3 两个方法都会被覆盖
type Order3 struct {
  *CommonOrder
}

// Overwrite
func (o *Order3) Create() error {
}

// Overwrite
func (o *Order3) Close() error {
}

嵌套+Overwrite的组合能力，支撑了Go语言面向对象的很多特性。与之前的函数复用对比，这种方法的可读性会更棒（这也非常依赖开发者面向对象的抽象能力）。

到这一阶段，维护绝大多数的项目已经足够。但如果你是一个苛求细节的人，在继续开发的过程中会发现一个问题：即便代码的逻辑一致，我们却常常因为数据结构不同，而编写出高度重复性的代码。那么，我们再看第三个方法：

方法3：剥离数据结构的差异 - 泛型

我们先看如下代码：

type OrderInfo1 struct{}

func (o *Order1) Create() error {
  // 数据结构 OrderInfo1 保存的是 Order1 订单信息
  var order *OrderInfo1
  // 插入msyql
  err := mysql.Insert(order)
  if err != nil {
    return err
  }
  // 序列化后打印
  b,err := json.Marshal(order)
  if err != nil {
    return err
  }
  fmt.Println(string(b))
  return nil
}

type OrderInfo2 struct{}

func (o *Order2) Create() error {
  // 数据结构 OrderInfo2 保存的是 Order2 订单信息
  var order *OrderInfo2
  // 后面操作同Order1
}

type OrderInfo3 struct{}

func (o *Order3) Create() error {
  // 数据结构 OrderInfo3 保存的是 Order3 订单信息
  var order *OrderInfo3
  // 后面操作同Order1
}

这部分代码很难通过上述两个方法解决。而如果利用泛型，会变得非常巧妙：

// 将公共逻辑抽象到这个泛型函数中
func Create[OrderInfo interface{}](order OrderInfo) error {
  err := mysql.Insert(order)
  if err != nil {
    return err
  }
  b,err := json.Marshal(order)
  if err != nil {
    return err
  }
  fmt.Println(string(b))
  return nil
}

// 三个Order的Create方法就非常清晰了
func (o *Order1) Create() error {
  var order *OrderInfo1
  return Create[OrderInfo1](order)
}

func (o *Order2) Create() error {
  var order *OrderInfo2
  return Create[OrderInfo2](order)
}

func (o *Order3) Create() error {
  var order *OrderInfo3
  return Create[OrderInfo3](order)
}