1.3 建造者模式

其实在 Golang 中对于创建类参数比较多的对象的时候，我们常见的做法是必填参数直接传递，可选参数通过传递可变的方法进行创建。

package builder

import "fmt"

const (
    defaultMaxTotal = 10 defaultMaxIdle = 9 defaultMinIdle = 1
)

// ResourcePoolConfig resource pool
type ResourcePoolConfig struct {
    name string
    maxTotal int
    maxIdle int
    minIdle int
}

// ResourcePoolConfigBuilder 用于构建 ResourcePoolConfig
type ResourcePoolConfigBuilder struct {
    name string
    maxTotal int
    maxIdle int
    minIdle int
}

// SetName SetName
func(b * ResourcePoolConfigBuilder) SetName(name string) error {
    if name == "" {
        return fmt.Errorf("name can not be empty")
    }
    b.name = name
    return nil
}

// SetMinIdle SetMinIdle
func(b * ResourcePoolConfigBuilder) SetMinIdle(minIdle int) error {
    if minIdle < 0 {
        return fmt.Errorf("max tatal cannot < 0, input: %d", minIdle)
    }
    b.minIdle = minIdle
    return nil
}

// SetMaxIdle SetMaxIdle
func(b * ResourcePoolConfigBuilder) SetMaxIdle(maxIdle int) error {
    if maxIdle < 0 {
        return fmt.Errorf("max tatal cannot < 0, input: %d", maxIdle)
    }
    b.maxIdle = maxIdle
    return nil
}

// SetMaxTotal SetMaxTotal
func(b * ResourcePoolConfigBuilder) SetMaxTotal(maxTotal int) error {
    if maxTotal <= 0 {
        return fmt.Errorf("max tatal cannot <= 0, input: %d", maxTotal)
    }
    b.maxTotal = maxTotal
    return nil
}

// Build Build
func(b * ResourcePoolConfigBuilder) Build()( * ResourcePoolConfig, error) {
    if b.name == "" {
        return nil, fmt.Errorf("name can not be empty")
    }

    // 设置默认值
    if b.minIdle == 0 {
        b.minIdle = defaultMinIdle
    }

    if b.maxIdle == 0 {
        b.maxIdle = defaultMaxIdle
    }

    if b.maxTotal == 0 {
        b.maxTotal = defaultMaxTotal
    }

    if b.maxTotal < b.maxIdle {
        return nil, fmt.Errorf("max total(%d) cannot < max idle(%d)", b.maxTotal, b.maxIdle)
    }

    if b.minIdle > b.maxIdle {
        return nil, fmt.Errorf("max idle(%d) cannot < min idle(%d)", b.maxIdle, b.minIdle)
    }

    return &ResourcePoolConfig {
        name: b.name,
        maxTotal: b.maxTotal,
        maxIdle: b.maxIdle,
        minIdle: b.minIdle,
    }, nil
}

package builder

import (
    "testing"

    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

func TestResourcePoolConfigBuilder_Build(t * testing.T) {
    tests: = [] struct {
        name string
        builder * ResourcePoolConfigBuilder
        want * ResourcePoolConfig
        wantErr bool
    } {
        {
            name: "name empty",
            builder: & ResourcePoolConfigBuilder {
                name: "",
                maxTotal: 0,
            },
            want: nil,
            wantErr: true,
        }, {
            name: "maxIdle < minIdle",
            builder: & ResourcePoolConfigBuilder {
                name: "test",
                maxTotal: 0,
                maxIdle: 10,
                minIdle: 20,
            },
            want: nil,
            wantErr: true,
        }, {
            name: "success",
            builder: & ResourcePoolConfigBuilder {
                name: "test",
            },
            want: & ResourcePoolConfig {
                name: "test",
                maxTotal: defaultMaxTotal,
                maxIdle: defaultMaxIdle,
                minIdle: defaultMinIdle,
            },
            wantErr: false,
        },
    }
    for _,
    tt: = range tests {
        t.Run(tt.name, func(t * testing.T) {
            got, err: = tt.builder.Build()
            require.Equalf(t, tt.wantErr, err != nil, "Build() error = %v, wantErr %v", err, tt.wantErr)
            assert.Equal(t, tt.want, got)
        })
    }
}

package builder

import "fmt"

// ResourcePoolConfigOption option
type ResourcePoolConfigOption struct {
    maxTotal int
    maxIdle int
    minIdle int
}

// ResourcePoolConfigOptFunc to set option
type ResourcePoolConfigOptFunc func(option * ResourcePoolConfigOption)

// NewResourcePoolConfig NewResourcePoolConfig
func NewResourcePoolConfig(name string, opts...ResourcePoolConfigOptFunc)( * ResourcePoolConfig, error) {
    if name == "" {
        return nil, fmt.Errorf("name can not be empty")
    }

    option: = & ResourcePoolConfigOption {
        maxTotal: 10,
        maxIdle: 9,
        minIdle: 1,
    }

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

    if option.maxTotal < 0 || option.maxIdle < 0 || option.minIdle < 0 {
        return nil, fmt.Errorf("args err, option: %v", option)
    }

    if option.maxTotal < option.maxIdle || option.minIdle > option.maxIdle {
        return nil, fmt.Errorf("args err, option: %v", option)
    }

    return &ResourcePoolConfig {
        name: name,
        maxTotal: option.maxTotal,
        maxIdle: option.maxIdle,
        minIdle: option.minIdle,
    }, nil
}

package builder

import (
    "testing"

    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

func TestNewResourcePoolConfig(t * testing.T) {
    type args struct {
        name string
        opts[] ResourcePoolConfigOptFunc
    }
    tests: = [] struct {
        name string
        args args
        want * ResourcePoolConfig
        wantErr bool
    } {
        {
            name: "name empty",
            args: args {
                name: "",
            },
            want: nil,
            wantErr: true,
        }, {
            name: "success",
            args: args {
                name: "test",
                opts: [] ResourcePoolConfigOptFunc {
                    func(option * ResourcePoolConfigOption) {
                        option.minIdle = 2
                    },
                },
            },
            want: & ResourcePoolConfig {
                name: "test",
                maxTotal: 10,
                maxIdle: 9,
                minIdle: 2,
            },
            wantErr: false,
        },
    }
    for _, tt: = range tests {
        t.Run(tt.name, func(t * testing.T) {
            got, err: = NewResourcePoolConfig(tt.args.name, tt.args.opts...)
            require.Equalf(t, tt.wantErr, err != nil, "error = %v, wantErr %v", err, tt.wantErr)
            assert.Equal(t, tt.want, got)
        })
    }
}