go如何使用cobra启动项目

目录

• 一、基本使用
• 二、实现项目中开发使用

1、安装依赖包

go get -u github.com/spf13/cobra@latest

2、简单的创建几个命令

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、运行上面的代码

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

4、常见的字段说明

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

5、加载外面传递的参数

先定义接收的变量

var name string

使用命名接收外面的数据

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

运行命令

go run main.go export -n=hello

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

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

2、cmd/root.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文件

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: %vn", err)
			os.Exit(1)
		}
	},
}
func startDaemon() error {
	server := api.NewServer(cfg)
	err := server.ListenAndServe()
	return err
}

4、config/config.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("写入默认配置文件失败: %vn", 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文件内容

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:%dn", s.config.Port)
	// 启动服务并修复端口格式
	return s.server.ListenAndServe()
}

6、application.dev.yml文件

port: 9000
salt: abcdef

7、启动文件main.go

package main
import "gin-admin-api/test251119/cmd"
func main() {
	cmd.Execute()
}

8、启动

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

到此这篇关于go使用cobra来启动项目的文章就介绍到这了,更多相关go cobra启动项目内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

您可能感兴趣的文章:

• Golang使用cobra实现命令行程序的示例代码
• Go语言命令行参数及cobra使用方法
• golang cobra使用chatgpt qdrant实现ai知识库
• Go语言使用Cobra实现强大命令行应用
• Go cobra库使用教程
• 玩转Go命令行工具Cobra
• go Cobra命令行工具入门教程
• 在 Golang 中使用 Cobra 创建 CLI 应用