[网络数据] 实践GoF的设计模式：工厂方法模式

摘要：工厂方法模式（Factory Method Pattern）将对象创建的逻辑封装起来，为使用者提供一个简单易用的对象创建接口，常用于不指定对象具体类型的情况下创建对象的场景。

// 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{}
}

  

• 定义一个工厂方法抽象接口，比如前文中的 sidecar.Factory。  
  
• 工厂方法中，返回需要创建的对象/接口，比如 network.Socket。其中，工厂方法通常命名为 Create。  
  
• 按照具体需要，定义工厂方法抽象接口的具体实现对象，比如 RawSocketFactory 和 AllInOneFactory。  
  
• 客户端使用时，依赖工厂方法抽象接口。  
  
• 在客户端初始化阶段，完成具体工厂对象的依赖注入。
  

// 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)

  

• 对象实例化逻辑较为复杂时，可选择使用工厂方法模式/简单工厂/静态工厂方法来进行封装，为客户端提供一个易用的接口。  
  
• 如果实例化的对象/接口涉及多种实现，可以使用工厂方法模式实现多态。  
  
• 普通对象的创建，推荐使用静态工厂方法，比直接的实例化（比如 &Packet{src: src, dest: dest, payload: payload}）具备更好的可读性和低耦合。
  

  

• 代码的可读性更好。  
  
• 与客户端程序解耦，当实例化逻辑变更时，只需改动工厂方法即可，避免了霰弹式修改。
  

  

• 引入工厂方法模式会新增一些对象/接口的定义，滥用会导致代码更加复杂。