深入理解Golang 编程思维和工程实战

一个更为优雅的构造函数的实现方式参考：https://commandcenter.blogspot.com/2014/01/self-referential-functions-and-design.html通过这个方式可以方便构造不同对象，同时避免了大量重复代码*/packagemainimport ("fmt""time""golang.org/x/net/context")
type Cluster struct {opts options}
type options struct {connectionTimeout time.DurationreadTimeout       time.DurationwriteTimeout      time.DurationlogError          func(ctx context.Context, err error)}
// 通过一个选项实现为一个函数指针来达到一个目的：设置选项中的数据的状态// Golang函数指针的用法type Option func(c *options)
// 设置某个参数的一个具体实现，用到了闭包的用法。// 不仅仅只是设置而采用闭包的目的是为了更为优化，更好用，对用户更友好func LogError(f func(ctx context.Context, err error)) Option {return func(opts *options) {opts.logError = f}}
// 对关键数据变量的赋值采用一个方法来实现而不是直接设置func ConnectionTimeout(d time.Duration) Option {return func(opts *options) {opts.connectionTimeout = d}}func WriteTimeout(d time.Duration) Option {return func(opts *options) {opts.writeTimeout = d}}func ReadTimeout(d time.Duration) Option {return func(opts *options) {opts.readTimeout = d}}// 构造函数具体实现，传入相关Option，new一个对象并赋值// 如果参数很多，也不需要传入很多参数，只需要传入opts ...Option即可func NewCluster(opts ...Option) *Cluster {clusterOpts := options{}for _, opt := range opts {// 函数指针的赋值调用opt(&clusterOpts)}cluster := new(Cluster)cluster.opts=clusterOptsreturn cluster}funcmain(){// 前期储备，设定相关参数commonsOpts := []Option{ConnectionTimeout(1 * time.Second),ReadTimeout(2 * time.Second),WriteTimeout(3 * time.Second),LogError(func(ctx context.Context, err error) {}),}// 终极操作，构造函数cluster:=NewCluster(commonsOpts...)// 测试验证fmt.Println(cluster.opts.connectionTimeout)fmt.Println(cluster.opts.writeTimeout)}

type Cluster struct {   opts options}func NewCluster(opts ...Option) *Cluster {   ....
cluster := new(Cluster)cluster.opts = clusterOpts
return cluster}

package mainimport ("fmt")
// 【基类】//定义一个最基础的struct类MsgModel，里面包含一个成员变量msgIdtype MsgModel struct {msgId   intmsgType int}
// MsgModel的一个成员方法，用来设置msgIdfunc (msg *MsgModel) SetId(msgId int) {msg.msgId = msgId}
func (msg *MsgModel) SetType(msgType int) {msg.msgType = msgType}
//【子类】// 再定义一个struct为GroupMsgModel，包含了MsgModel，即组合，但是并没有给定MsgModel任何名字，因此是匿名组合type GroupMsgModel struct {MsgModel
// 如果子类也包含一个基类的一样的成员变量，那么通过子类设置和获取得到的变量都是基类的msgId int}
func (group *GroupMsgModel) GetId() int {return group.msgId}
/*func (group *GroupMsgModel) SetId(msgId int) {group.msgId = msgId}*/func main() {group := &GroupMsgModel{}
group.SetId(123)group.SetType(1)
fmt.Println("group.msgId =", group.msgId, "\tgroup.MsgModel.msgId =", group.MsgModel.msgId)fmt.Println("group.msgType =", group.msgType, "\tgroup.MsgModel.msgType =", group.MsgModel.msgType)}

 interface {    Persist(context context.Context, msg interface{}) bool    PersistOnSensitive(context context.Context, session_type, level, SensitiveStatus int32, msg interface{}) bool}

定义一个struct用来实现接口类型typemsgModelImplstruct{}定义一个变量MsgModelImpl等于msgModelImpl，相当于可以通过MsgModelImpl来调用msgModelImpl的成员var MsgModelImpl = msgModelImpl{}
实现接口的两个方法func (m msgModelImpl) Persist(context context.Context, msgIface interface{}) bool {// 具体实现省略}
func (m msgModelImpl) UpdateDbContent(context context.Context, msgIface interface{}) bool {// 具体实现省略}

type msgService struct {   msgModel MsgModel}

将上述已经实现接口类型的类型(MsgModelImpl) 赋值给此变量(此变量并且要是包含了接口类型的类型), 然后这个变量就可以供外部调用var  MsgService = msgService{        msgModel:  MsgModelImpl,}

package model
// 定义一个基础modeltype MsgModel interface {Persist(context context.Context, msg interface{}) boolUpdateDbContent(context context.Context, msgIface interface{}) boolGetList(context context.Context, uid, peerId, sinceMsgId, maxMsgId int64, count int) (interface{}, bool)]

package msgtypemsgModelImplstruct{}var MsgModelImpl = msgModelImpl{}
func (m msgModelImpl) Persist(context context.Context, msgIface interface{}) bool {   // 具体实现}
func (m msgModelImpl) UpdateDbContent(context context.Context, msgIface interface{}) bool {//具体实现}
func GetList(context context.Context, uid, peerId, sinceMsgId, maxMsgId int64, count int) (interface{}, bool)]{    // 具体实现}

package service
// 定义一个msgService struct包含了model里面的UserModel和MsgModel两个modeltype msgService struct {  userModel  model.UserModel  msgModel   model.MsgModel}
// 定义一个MsgService的变量，并初始化，这样通过MsgService，就能引用并访问model的所有方法var (    MsgService = msgService{    userModel:      user.UserModelImpl,    msgModel:       msg.MsgModelImpl,  })

import service
service.MsgService.Persist(ctx, xxx)

import   "github.com/dropbox/godropbox/singleton"
var SingleService = singleton.NewSingleton(func() (interface{}, error) {  return &singleMsgProxy{    MsgModel: msg.MsgModelImpl,  }, nil})

$ tree  -d  -L 2├── build├── cmd│   ├── apply│   └── check├── conf├── config├── docs├── pkg│   ├── apply│   ├── check│   ├── files│   ├── k8s│   └── options└── vendor

kubectl apply  -f  进行部署kubectl delete -f  删除部署kubectl get pod    获取 Pod

$ ./exampleUsage:  example[command]
Available Commands:  apply       apply request by json file  check       check request validity by json file  help        Help about any command
Flags:      --config string   config file[/.xx.yaml] (default "none")  -h, --help            help for example      --mode string     mode[cpu  or all] (default "cpu")
Use "example[command] --help" for more information about a command.

package main
import (  log "github.com/sirupsen/logrus"  "github.com/spf13/cobra"  "github.com/spf13/pflag""os"  "example/cmd/apply"  "example/cmd/check"  "example/config")func main() {  var cmdCheck = check.NewVPARequestCheck()  var cmdApply = apply.NewVPARequestApply()
  var rootCmd = &cobra.Command{Use: "example"}
  flags := rootCmd.PersistentFlags()  addFlags(flags)
  rootCmd.AddCommand(cmdApply, cmdCheck)  if err := rootCmd.Execute(); err != nil {    panic(err)  }}
func addFlags(flags *pflag.FlagSet) {  flags.StringVar(&config.Cfg.KubeConfig, "config", "none", "config file[/.xx.yaml]")  flags.StringVar(&config.Cfg.Mode, "mode", "cpu", "mode[cpu  or all]")}

package check
import ("fmt"  log "github.com/sirupsen/logrus""github.com/spf13/cobra""example/config""example/pkg/check""example/pkg/files")
type RequestCheckOptions struct {  configPath string}
func NewRequestCheckOptions() *RequestCheckOptions {  o := &RequestCheckOptions{}
return o}
func NewVPARequestCheck() *cobra.Command {  o := NewRequestCheckOptions()  cmd := &cobra.Command{    Use:   "check [json file]",    Short: "check request validity by json file",    Long:  "check request by new request json file",    Args:  cobra.MinimumNArgs(1),    RunE: func(c *cobra.Command, args []string) error {if err := o.Run(args); err != nil {return err      }return nil    },  }
return cmd}
apply 命令如下，具体 apply 相关的 Run 方法忽略：package apply
import ("fmt""github.com/spf13/cobra""example/pkg/apply""example/pkg/files")
type RequestApplyOptions struct {  configPath string}
func NewRequestApplyOptions() *RequestApplyOptions {  o := &RequestApplyOptions{}
return o}
func NewVPARequestApply() *cobra.Command {  o := NewRequestApplyOptions()
  cmd := &cobra.Command{    Use:   "apply [json file]",    Short: "apply request by json file",    Long:  "apply request by new request json file",    Args:  cobra.MinimumNArgs(1),    RunE: func(c *cobra.Command, args []string) error {if err := o.Run(args); err != nil {return err      }return nil    },}return cmd}