Go|使用Options模式和建造者模式创建对象实战

以下是使用Options模式和建造者模式创建对象的完整攻略：

Go | 使用Options模式和建造者模式创建对象实战

在Go语言中，Options模式和建造者模式是常用的创建对象的模式。它们可以帮助我们灵活地配置和构建对象，提供了更好的可读性和可维护性。

Options模式

Options模式通过定义一系列的选项函数，允许用户根据需要选择性地配置对象的属性。每个选项函数负责设置一个属性，并返回一个函数类型，用于链式调用。

示例代码1：使用Options模式创建数据库连接对象

package main

import \"fmt\"

type DBOptions struct {
    Host     string
    Port     int
    Username string
    Password string
}

type DBConnection struct {
    host     string
    port     int
    username string
    password string
}

type DBOption func(*DBOptions)

func WithHost(host string) DBOption {
    return func(o *DBOptions) {
        o.Host = host
    }
}

func WithPort(port int) DBOption {
    return func(o *DBOptions) {
        o.Port = port
    }
}

func WithUsername(username string) DBOption {
    return func(o *DBOptions) {
        o.Username = username
    }
}

func WithPassword(password string) DBOption {
    return func(o *DBOptions) {
        o.Password = password
    }
}

func NewDBConnection(opts ...DBOption) *DBConnection {
    options := &DBOptions{
        Host:     \"localhost\",
        Port:     3306,
        Username: \"root\",
        Password: \"\",
    }

    for _, opt := range opts {
        opt(options)
    }

    return &DBConnection{
        host:     options.Host,
        port:     options.Port,
        username: options.Username,
        password: options.Password,
    }
}

func main() {
    conn := NewDBConnection(
        WithHost(\"example.com\"),
        WithPort(5432),
        WithUsername(\"admin\"),
        WithPassword(\"password\"),
    )

    fmt.Println(conn)
}

在上述示例中，我们定义了一个DBOptions结构体，用于存储数据库连接的配置选项。然后，我们定义了一系列的选项函数，如WithHost、WithPort等，用于设置DBOptions的属性。最后，我们通过NewDBConnection函数创建DBConnection对象，并使用选项函数进行配置。

示例代码2：使用Options模式创建HTTP请求对象

package main

import \"fmt\"

type RequestOptions struct {
    Method  string
    URL     string
    Headers map[string]string
}

type RequestOption func(*RequestOptions)

func WithMethod(method string) RequestOption {
    return func(o *RequestOptions) {
        o.Method = method
    }
}

func WithURL(url string) RequestOption {
    return func(o *RequestOptions) {
        o.URL = url
    }
}

func WithHeaders(headers map[string]string) RequestOption {
    return func(o *RequestOptions) {
        o.Headers = headers
    }
}

func NewHTTPRequest(opts ...RequestOption) *RequestOptions {
    options := &RequestOptions{
        Method:  \"GET\",
        URL:     \"\",
        Headers: nil,
    }

    for _, opt := range opts {
        opt(options)
    }

    return options
}

func main() {
    req := NewHTTPRequest(
        WithMethod(\"POST\"),
        WithURL(\"https://example.com/api\"),
        WithHeaders(map[string]string{
            \"Content-Type\": \"application/json\",
            \"Authorization\": \"Bearer token\",
        }),
    )

    fmt.Println(req)
}

在上述示例中，我们定义了一个RequestOptions结构体，用于存储HTTP请求的配置选项。然后，我们定义了一系列的选项函数，如WithMethod、WithURL等，用于设置RequestOptions的属性。最后，我们通过NewHTTPRequest函数创建RequestOptions对象，并使用选项函数进行配置。

建造者模式

建造者模式通过定义一个建造者类型，将对象的构建过程分解为一系列的步骤，使得用户可以按照自己的需求逐步构建对象。

示例代码3：使用建造者模式创建电脑对象

```go
package main

import \"fmt\"

type Computer struct {
CPU string
Memory string
Disk string
}

type ComputerBuilder struct {
computer *Computer
}

func NewComputerBuilder() *ComputerBuilder {
return &ComputerBuilder{
computer: &Computer{},
}
}

func (b ComputerBuilder) SetCPU(cpu string) ComputerBuilder {
b.computer.CPU = cpu
return b
}

func (b ComputerBuilder) SetMemory(memory string) ComputerBuilder {
b.computer.Memory = memory
return b
}

func (b ComputerBuilder) SetDisk(disk string) ComputerBuilder {
b.computer.Disk = disk