如何根据项目类型选择合适的golang框架？

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {
        c.String(200, "Hello World")
    })
    r.Run()
}

package main

import (
    "context"
    "log"
    "net"

    helloworldpb "github.com/grpc/grpc-go/examples/helloworld/helloworld"
    "google.golang.org/grpc"
)

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    helloworldpb.RegisterGreeterServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

package main

import (
    "fmt"

    "github.com/spf13/cobra"
)

func main() {
    var cmdEcho = &cobra.Command{
        Use:   "echo",
        Short: "Echo arguments",
        Run: func(cmd *cobra.Command, args []string) {
            fmt.Println(args)
        },
    }
    rootCmd := &cobra.Command{Use: "cobra"}
    rootCmd.AddCommand(cmdEcho)
    rootCmd.Execute()
}

package buffalo

import (
    "fmt"
    "os"
    "strconv"
    "strings"

    "github.com/pkg/errors"
)

var version = "0.0.0"

// ErrSilent error is used to hush the verbose CLI errors
var ErrSilent = errors.Errorf("")

// CmdRun runs the run method of the command by name.
func CmdRun(args []string) (err error) {
    if version != "" {
        if args[0] != "version" {
            fmt.Printf("Buffalo %s\n", version)
        }
    }

    switch args[0] {
    case "new":
        return NewApp(args[1:])
    case "gen":
        return Gen(args[1:]...)
    case "migrate":
        return Migrate(args[1:]...)
    case "watchers":
        return Watchers(args[1:]...)
    case "version":
        os.Exit(0)
    case "init":
        return Init(args[1:]...)
    case "config":
        return Config(args[1:]...)
    case "help":
        return Help(args[1:]...)
    default:
        return errors.New(fmt.Sprintf("Unknown command %s", args[0]))
    }
}

// CmdString is a custom parsing command that defaults to an empty string
func CmdString(args []string) (string, error) {
    st := ""
    if len(args) > 1 {
        st = strings.Join(args[1:], " ")
    } else if len(args) == 1 && len(args[0]) > 0 {
        st = args[0]
    }

    st = strings.Replace(st, "\"", "", -1)
    return st, nil
}

// CmdBool is a custom parsing command that defaults to false
func CmdBool(args []string) (bool, error) {
    if len(args) > 1 {
        return true, nil
    }

    return false, nil
}

// CmdInt16 is a custom parsing command that defaults to 0
func CmdInt16(args []string) (int16, error) {
    if len(args) > 1 {
        i, err := strconv.ParseInt(args[1], 10, 16)
        if err != nil {
            return 0, err
        }
        return int16(i), nil
    }

    return 0, nil
}

// CmdInt32 is a custom parsing command that defaults to 0
func CmdInt32(args []string) (int32, error) {
    if len(args) > 1 {
        i, err := strconv.ParseInt(args[1], 10, 32)
        if err != nil {
            return 0, err
        }
        return int32(i), nil
    }

    return 0, nil
}

// CmdInt64 is a custom parsing command that defaults to 0
func CmdInt64(args []string) (int64, error) {
    if len(args) > 1 {
        i, err := strconv.ParseInt(args[1], 10, 64)
        if err != nil {
            return 0, err
        }