Creational Patterns

Nov 2, 2024#代码设计110

AI Translation

This post is translated from Chinese into English through AI.View Original

AI-generated summary

The document discusses two design patterns for configuring objects in Go: the Builder pattern and the Functional Options pattern. ### Builder Pattern - A `ServerBuilder` struct is created to set properties of a `Server` object using method chaining. - Methods like `Default` and `WithProtocol` configure the server's address, port, and protocol. - The `Build` method returns the configured `Server` object. - Example usage demonstrates creating a server with specified address, port, and protocol. ### Functional Options Pattern - This pattern uses a function type (`Option`) that modifies a `Server` object. - Options are applied through a variadic function in the `NewServer` constructor, allowing flexible configuration without needing to declare an empty object. - An example shows how to create a server using functional options to set its protocol. Both patterns are used for property configuration, with the Builder pattern requiring an initial object and the Functional Options pattern allowing for more flexibility without needing a pre-defined object.

Builder Pattern#

Create a builder object, use the object's methods to set properties, and return the object through the Build() method.

Use case: Property configuration

type ServerBuilder struct {
  Server
}

func (s *ServerBuilder) Default(addr string, port int) *ServerBuilder{
  s.Server.Addr = addr
  s.Server.Port = port
  return s
}

func (s *ServerBuilder) WithProtocol(protocol string) *ServerBuilder{
  s.Server.Protocol = protocol
  return s
}

func (s *ServerBuilder) Build() Server{
  return s.Server
}


# Invocation
func main() {
  s := ServerBuilder{}
  server := s.Default().
  	WithProtocol("udp").
	  Build()
}

Functional Options#

Create a func type that assigns values to the receiver, and obtain the target object by looping through the func slice in the new method.

Use case: Property configuration

vs Builder Pattern: No need to declare an empty object

type Option func(*Server)

func WithProtocol(protocol string) Option {
  return func(s *Server) {
    s.Protocol = protocol
  }
}

func NewServer(addr string, port int, opts ...Option) {
  srv := Server{
    Addr: addr,
    Port: port,
  }
  for i := range opts {
    opts[i](&srv)
  }
}

func main() {
  s := NewServer("localhost", 1024, WithProtocol("udp"))
}