實踐GoF的設計模式：工廠方法模式

// demo/network/http/http_client.go
package http

// 建立一個新的HTTP客戶端，以Socket介面作為入參
func NewClient(socket network.Socket, ip string) (*Client, error) {
  ... // 一些初始化邏輯
	return client, nil
}

// 使用NewClient時，我們可以傳入Sidecar來給Http客戶端附加額外的流控功能
client, err := http.NewClient(sidecar.NewFlowCtrlSidecar(network.DefaultSocket()), "192.168.0.1")

type ServiceMediator struct {
  ...
	server *http.Server
}

// Forward 轉發請求，請求URL為 /{serviceType}+ServiceUri 的形式，如/serviceA/api/v1/task
func (s *ServiceMediator) Forward(req *http.Request) *http.Response {
    ...
    // 發現下游服務的目的IP地址
    dest, err := s.discovery(svcType)
    // 建立HTTP客戶端，硬編碼sidecar.NewFlowCtrlSidecar(network.DefaultSocket())
    client, err := http.NewClient(sidecar.NewFlowCtrlSidecar(network.DefaultSocket()), s.localIp)
    // 通過HTTP客戶端轉發請求
    resp, err := client.Send(dest, forwardReq)
    ...
}

type ServiceMediator struct {
  ...
	server *http.Server
  // 依賴Socket抽象介面
  socket network.Socket
}

// Forward 轉發請求，請求URL為 /{serviceType}+ServiceUri 的形式，如/serviceA/api/v1/task
func (s *ServiceMediator) Forward(req *http.Request) *http.Response {
    ...
    // 發現下游服務的目的IP地址
    dest, err := s.discovery(svcType)
    // 建立HTTP客戶端，將s.socket抽象介面作為入參
    client, err := http.NewClient(s.socket, s.localIp)
    // 通過HTTP客戶端轉發請求
    resp, err := client.Send(dest, forwardReq)
    ...
}

// 在ServiceMediator初始化時，將具體型別的Sidecar注入到ServiceMediator中
mediator := &ServiceMediator{
  socket: sidecar.NewFlowCtrlSidecar(network.DefaultSocket())
}

// demo/sidecar/sidecar_factory.go

// 關鍵點1: 定義一個Sidecar工廠抽象介面
type Factory interface {
  // 關鍵點2: 工廠方法返回Socket抽象介面
	Create() network.Socket
}

// 關鍵點3: 按照需要實現具體的工廠
// demo/sidecar/raw_socket_sidecar_factory.go
// RawSocketFactory 只具備原生socket功能的sidecar，實現了Factory介面
type RawSocketFactory struct {
}
func (r RawSocketFactory) Create() network.Socket {
	return network.DefaultSocket()
}

// demo/sidecar/all_in_one_sidecar_factory.go
// AllInOneFactory 具備所有功能的sidecar工廠，實現了Factory介面
type AllInOneFactory struct {
	producer mq.Producible
}
func (a AllInOneFactory) Create() network.Socket {
	return NewAccessLogSidecar(NewFlowCtrlSidecar(network.DefaultSocket()), a.producer)
}

// demo/service/mediator/service_mediator.go

type ServiceMediator struct {
  ...
	server *http.Server
  // 關鍵點4: 客戶端依賴Factory抽象介面
  sidecarFactory sidecar.Factory
}

// Forward 轉發請求，請求URL為 /{serviceType}+ServiceUri 的形式，如/serviceA/api/v1/task
func (s *ServiceMediator) Forward(req *http.Request) *http.Response {
    ...
    // 發現下游服務的目的IP地址
    dest, err := s.discovery(svcType)
    // 建立HTTP客戶端，呼叫sidecarFactory.Create()生成Socket作為入參
    client, err := http.NewClient(s.sidecarFactory.Create(), s.localIp)
    // 通過HTTP客戶端轉發請求
    resp, err := client.Send(dest, forwardReq)
    ...
}

// 關鍵點5: 在ServiceMediator初始化時，將具體型別的sidecar.Factory注入到ServiceMediator中
mediator := &ServiceMediator{
  sidecarFactory: &AllInOneFactory{}
  // sidecarFactory: &RawSocketFactory{}
}

// demo/sidecar/sidecar_factory_func.go

// 關鍵點1: 定義Sidecar工廠方法型別
type FactoryFunc func() network.Socket

// 關鍵點2: 按需定義具體的工廠方法實現，注意這裡定義的是工廠方法的工廠方法，返回的是FactoryFunc工廠方法型別
func RawSocketFactoryFunc() FactoryFunc {
	return func() network.Socket {
		return network.DefaultSocket()
	}
}

func AllInOneFactoryFunc(producer mq.Producible) FactoryFunc {
	return func() network.Socket {
		return NewAccessLogSidecar(NewFlowCtrlSidecar(network.DefaultSocket()), producer)
	}
}

type ServiceMediator struct {
  ...
	server *http.Server
  // 關鍵點3: 客戶端依賴FactoryFunc工廠方法型別
  sidecarFactoryFunc FactoryFunc
}

func (s *ServiceMediator) Forward(req *http.Request) *http.Response {
    ...
    dest, err := s.discovery(svcType)
    // 關鍵點4: 建立HTTP客戶端，呼叫sidecarFactoryFunc()生成Socket作為入參
    client, err := http.NewClient(s.sidecarFactoryFunc(), s.localIp)
    resp, err := client.Send(dest, forwardReq)
    ...
}

// 關鍵點5: 在ServiceMediator初始化時，將具體型別的FactoryFunc注入到ServiceMediator中
mediator := &ServiceMediator{
  sidecarFactoryFunc: RawSocketFactoryFunc()
  // sidecarFactory: AllInOneFactoryFunc(producer)
}

// 並非FactoryFunc型別，無法實現多型
func AllInOneFactoryFunc(producer mq.Producible) network.Socket {
    return NewAccessLogSidecar(NewFlowCtrlSidecar(network.DefaultSocket()), producer)
}

// demo/sidecar/sidecar_simple_factory.go

// 關鍵點1: 定義sidecar型別
type Type uint8

// 關鍵點2: 按照需要定義sidecar具體型別
const (
	Raw Type = iota
	AllInOne
)

// 關鍵點3: 定義簡單工廠物件
type SimpleFactory struct {
	producer mq.Producible
}

// 關鍵點4: 定義工廠方法，入參為sidecar型別，根據switch-case或者if-else來建立產品
func (s SimpleFactory) Create(sidecarType Type) network.Socket {
	switch sidecarType {
	case Raw:
		return network.DefaultSocket()
	case AllInOne:
		return NewAccessLogSidecar(NewFlowCtrlSidecar(network.DefaultSocket()), s.producer)
	default:
		return nil
	}
}

// 關鍵點5: 建立產品時傳入具體的sidecar型別，比如sidecar.AllInOne
simpleFactory := &sidecar.SimpleFactory{producer: producer}
sidecar := simpleFactory.Create(sidecar.AllInOne)

public class Packet {
    private final Endpoint src;
    private final Endpoint dest;
    private final Object payload;

    private Packet(Endpoint src, Endpoint dest, Object payload) {
        this.src = src;
        this.dest = dest;
        this.payload = payload;
    }

    // 靜態工廠方法
    public static Packet of(Endpoint src, Endpoint dest, Object payload) {
        return new Packet(src, dest, payload);
    }
		...
}

// 用法
packet = Packet.of(src, dest, payload)

// demo/network/packet.go
type Packet struct {
	src     Endpoint
	dest    Endpoint
	payload interface{}
}

// 工廠方法
func NewPacket(src, dest Endpoint, payload interface{}) *Packet {
	return &Packet{
		src:     src,
		dest:    dest,
		payload: payload,
	}
}

// 用法
packet := NewPacket(src, dest, payload)