go使用cobra来启动项目

一、基本使用

1、安装依赖包
properties 复制代码
```
go get -u github.com/spf13/cobra@latest
```

2、简单的创建几个命令

go 复制代码

package main

import (
	"github.com/spf13/cobra"
	"os"
)

var rootCmd = &cobra.Command{
	Use:   "api",
	Short: "短的地址",
	Long:  "长的地址",
}

// 命令一
var mockCmd = &cobra.Command{
	Use:   "mock",
	Short: "mock短的",
	Long:  "mock长的",
}

// 命令二
var exportCmd = &cobra.Command{
	Use:   "export",
	Short: "export短的",
	Long:  "export长的",
}

func main() {
	rootCmd.AddCommand(mockCmd)
	rootCmd.AddCommand(exportCmd)
	err := rootCmd.Execute()
	if err != nil {
		os.Exit(1)
	}
}

3、运行上面的代码

properties 复制代码

go run main.go mock ---> 输出mock长的
go run main.go export --> export长的

4、常见的字段说明
- PersistentPreRunE执行之前，且在任何子命令运行之前都会调用
- PersistentPostRun执行之后,且在所有子命令执行后都会调用
- RunE当命令的主要逻辑执行时触发，即命令的核心功能实现

5、加载外面传递的参数

先定义接收的变量
go 复制代码
```
var name string
```

使用命名接收外面的数据

go 复制代码

func init() {
	rootCmd.PersistentFlags().StringVarP(&name, "name", "n", "", "外部传递值进来")
}

运行命令
go 复制代码
```
go run main.go export -n=hello
```

二、实现项目中开发使用

1、比如我们日常gin项目开发

properties 复制代码

├── api
│   └── service.go
├── cmd
│   ├── root.go
│   └── start.go
├── config
│   └── config.go
├── etc
│   ├── application.dev.yml
│   └── application.prod.yml
├── main.go

2、cmd/root.go的文件

go 复制代码

package cmd

import (
	"fmt"
	"gin-admin-api/test251119/config"
	"github.com/spf13/cobra"
	"os"
)

var (
	cfgFile string
	cfg     *config.Config
)
var rootCmd = &cobra.Command{
	Use:   "cmd",
	Short: "gin项目开发启动",
	Long:  "gin项目开发启动",
	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
		if cmd.Name() == "help" {
			return nil
		}
		// 加载配置文件
		var err error
		cfg, err = config.Load(cfgFile)
		if err != nil {
			return fmt.Errorf("加载配置文件失败: %w", err)
		}
		return nil
	},
	PersistentPostRun: func(cmd *cobra.Command, args []string) {
		// TODO 可以做数据库的关闭
	},
}

func init() {
	rootCmd.PersistentFlags().StringVarP(&cfgFile, "etc", "c", "etc/application.dev.yml", "请输入启动的配置文件")
}
func Execute() {
	rootCmd.AddCommand(cmdStart)
	err := rootCmd.Execute()
	if err != nil {
		os.Exit(1)
	}
}

3、cmd/start.go文件

go 复制代码

package cmd

import (
	"fmt"
	"gin-admin-api/test251119/api"
	"github.com/spf13/cobra"
	"os"
)

var cmdStart = &cobra.Command{
	Use:   "start",
	Short: "启动项目",
	Long:  "启动项目",
	Run: func(cmd *cobra.Command, args []string) {
		if err := startDaemon(); err != nil {
			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
			os.Exit(1)
		}
	},
}

func startDaemon() error {
	server := api.NewServer(cfg)
	err := server.ListenAndServe()
	return err
}

4、config/config.go文件内容

go 复制代码

package config

import (
	"fmt"
	"github.com/spf13/viper"
	"os"
	"path/filepath"
)

type Config struct {
	Port int `mapstructure:"port"` // 启动端口
}

// Load loads configuration from file
func Load(cfgFile string) (*Config, error) {
	v := viper.New()
	if cfgFile != "" {
		v.SetConfigFile(cfgFile)
	} else {
		configDir := "./etc"
		if _, err := os.Stat(configDir); os.IsNotExist(err) {
			if err := os.MkdirAll(configDir, 0755); err != nil {
				return nil, fmt.Errorf("创建目录失败: %w", err)
			}
		}
		v.AddConfigPath(configDir)
		v.SetConfigName("application.dev")
		v.SetConfigType("yml")

		configPath := filepath.Join(configDir, "application.dev.yml")
		if _, err := os.Stat(configPath); os.IsNotExist(err) {
			fmt.Println("Config file not found, creating default config:", configPath)
			// Copy example file if it exists
			examplePath := filepath.Join(configDir, "application.dev.example")
			if _, err := os.Stat(examplePath); err == nil {
				if exampleData, err := os.ReadFile(examplePath); err == nil {
					if err := os.WriteFile(configPath, exampleData, 0644); err != nil {
						fmt.Printf("写入默认配置文件失败: %v\n", err)
					} else {
						fmt.Println("读取默认配置文件 成功")
					}
				}
			}
		}
	}
	// 设置默认值
	v.SetDefault("port", ":8080")

	if err := v.ReadInConfig(); err != nil {
		return nil, fmt.Errorf("reading config file: %w", err)
	}
	fmt.Println("Using config file:", v.ConfigFileUsed())

	var config Config
	if err := v.Unmarshal(&config); err != nil {
		return nil, fmt.Errorf("unmarshaling config: %w", err)
	}
	return &config, nil
}

5、api/service.go文件内容

go 复制代码

package api

import (
	"fmt"
	"gin-admin-api/test251119/config"
	"github.com/gin-gonic/gin"
	"net/http"
)

type Server struct {
	server *http.Server
	router *gin.Engine
	config *config.Config
}

// NewServer 创建新的 Server 实例
func NewServer(cfg *config.Config) *Server {
	gin.SetMode(gin.DebugMode)
	router := gin.Default()
	router.Use(gin.Recovery())

	// 创建 HTTP 服务器
	srv := &http.Server{
		Addr:    fmt.Sprintf(":%d", cfg.Port),
		Handler: router,
	}

	return &Server{
		server: srv,
		router: router,
		config: cfg,
	}
}

// ListenAndServe 启动服务并监听端口
func (s *Server) ListenAndServe() error {
	fmt.Printf("服务启动:http://localhost:%d\n", s.config.Port)
	// 启动服务并修复端口格式
	return s.server.ListenAndServe()
}

6、application.dev.yml文件
yaml 复制代码
```
port: 9000
salt: abcdef
```

7、启动文件main.go

go 复制代码

package main

import "gin-admin-api/test251119/cmd"

func main() {
	cmd.Execute()
}

8、启动

properties 复制代码

go run main.go start  默认使用dev文件
go run main.go start -c etc/application.prod.yml