go如何使用cobra启动项目

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

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)
	}
}

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

var name string

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

go run main.go export -n=hello

├── api
│   └── service.go
├── cmd
│   ├── root.go
│   └── start.go
├── config
│   └── config.go
├── etc
│   ├── application.dev.yml
│   └── application.prod.yml
├── main.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)
	}
}

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
}

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
}

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()
}

port: 9000
salt: abcdef

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

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