Programming Pattern on CctoctoFX

Go编程模式：Visitor（k8s）

Wed, 31 Mar 2021 11:22:18 +0800

概述

最近在看kubernetes的kubectl部分源码，记录一下其中用到的visitor编程模式(实际上kubectl主要用到了builder和visitor)。visitor模式是将算法和操作对象结构分离的一种方法。换句话说，这样的分离能够在不修改对象结构的情况下向原有对象新增操作，是符合开闭原则的。这个文章以一些例子去讨论kubectl中到底如何玩的。

从一个例子出发

写一个简单的Visitor模式示例：

我们的代码中有一个Visitor的函数定义，还有一个Shape接口，其需要使用 Visitor函数做为参数
我们的实例的对象 Circle和 Rectangle实现了 Shape 的接口的 accept() 方法，这个方法就是等外面给我传递一个Visitor。

package main
import (
    "encoding/json"
    "encoding/xml"
    "fmt"
)
type Visitor func(shape Shape)
type Shape interface {
    accept(Visitor)
}
type Circle struct {
    Radius int
}
func (c Circle) accept(v Visitor) {
    v(c)
}
type Rectangle struct {
    Width, Heigh int
}
func (r Rectangle) accept(v Visitor) {
    v(r)
}

然后，我们实现两个Visitor，一个是用来做JSON序列化的，另一个是用来做XML序列化的:

func JsonVisitor(shape Shape) {
    bytes, err := json.Marshal(shape)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(bytes))
}
func XmlVisitor(shape Shape) {
    bytes, err := xml.Marshal(shape)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(bytes))
}

下面是我们的使用Visitor这个模式的代码：

Go编程模式：Pipeline

Wed, 03 Feb 2021 11:22:18 +0800

概述

这篇文章介绍Go编程里的Pipeline模式。如果是对Unix/Linux命令行熟悉的人会知道，Pipeline其实就是把每个命令拼接起来完成一个组合功能的技术。当下诸如流式处理，函数式编程，以及应用Gateway对微服务进行简单API编排，其实都受pipeline技术方式的影响。换句话说，这种技术能够很容易得把代码按照单一职责的原则拆分成多个高内聚低耦合的小模块，然后拼装起来去完成比较复杂的功能。

Design Pattern: Overview

Wed, 11 Nov 2020 11:22:18 +0800

Design pattern

Builder Pattern

scenario：build complicated object

package msg

type Message struct {
	Header *Header
	Body   *Body
}
type Header struct {
	SrcAddr  string
	SrcPort  uint64
	DestAddr string
	DestPort uint64
	Items    map[string]string
}
type Body struct {
	Items []string
}

// Message对象的复杂对象
type builder struct{
  once *sync.Once
  msg *Message
}

// 返回Builder对象
func Builder() *builder{
  return &builder{
    once: &sync.Once{},
    msg: &Message{Header: &Header{}, Body: &Body{}},
  }
}

func (b *builder) WithSrcAddr(srcAddr string) *builder{
  b.msg.Header.SrcAddr = srcAddr
  return b
}

//......
func (b *builder) WithHeaderItem(key, value string) *builder{
  //map只初始化一次
  b.once.Do(func(){
    b.msg.Header.Items = make(map[string]string)
  })
  b.msg.Header.Items[key] = value
  return b
}

func (b *builder) WithBodyItem(record string) *builder{
  b.msg.Body.Items = append(b.msg.Body.Items, record)
  return b
} 

func (b *builder) Build() *Message{
  return b.msg
}

Test code

package test
func TestMessageBuilder(t *testing.T) {
  // 使用消息建造者进行对象创建
	message := msg.Builder().
		WithSrcAddr("192.168.0.1").
		WithSrcPort(1234).
		WithDestAddr("192.168.0.2").
		WithDestPort(8080).
		WithHeaderItem("contents", "application/json").
		WithBodyItem("record1").
		WithBodyItem("record2").
		Build()
	if message.Header.SrcAddr != "192.168.0.1" {
		t.Errorf("expect src address 192.168.0.1, but actual %s.", message.Header.SrcAddr)
	}
	if message.Body.Items[0] != "record1" {
		t.Errorf("expect body item0 record1, but actual %s.", message.Body.Items[0])
	}
}