golang什么软件

Golang是一种编程语言，最初由Google开发。它的特点是高效、可靠和简单，适用于编写各种应用程序。Golang中有丰富的软件库，使得开发者可以快速构建各种应用程序。下面将介绍一些常用的Golang软件及其用途。

1. Gin

Gin是一款快速的HTTP web框架，具有高度优化的性能。它采用Golang的协程机制，可以轻松处理大量的并发请求。 Gin是目前GitHub上最火的Golang框架之一，其代码量也很少，学习和使用十分方便。

    package main

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

    func main() {
        router := gin.Default()
        router.GET("/ping", func(c *gin.Context) {
            c.JSON(200, gin.H{
                "message": "pong",
            })
        })
        router.Run() 
    }

2. GORM

GORM是一款开源的ORM框架，可用于处理Golang中的关系型数据库。它的使用非常方便，支持MySQL、PostgreSQL等数据库。GORM可以让开发者使用简单的代码来操作数据库，不用频繁地编写SQL语句。

    package main

    import (
        "gorm.io/driver/mysql"
        "gorm.io/gorm"
    )

    type User struct {
        gorm.Model
        Name string
        Age  int
    }

    func main() {
        dsn := "root:password@tcp(127.0.0.1:3306)/test_db?charset=utf8mb4&parseTime=True&loc=Local"

        db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
        if err != nil {
            panic("failed to connect database")
        }
        
        //创建表
        db.AutoMigrate(&User{})

        //插入记录
        user := User{Name: "test", Age: 18}
        db.Create(&user)

        //查询记录
        var result User
        db.First(&result, "name = ?", "test")
    }

3. go-micro

go-micro 是一个微服务框架，可以协调不同的服务，提供了微服务的构建、管理和发现相关的功能。它实现了分布式系统中的服务注册、发现、流量控制、负载均衡、链路追踪等功能。

    package main

    import (
        "context"
        "log"

        "github.com/asim/go-micro/v3"
        "github.com/asim/go-micro/v3/server"
    )

    type Greeter struct{}

    func (g *Greeter) Hello(ctx context.Context, req *HelloRequest, rsp *HelloResponse) error {
        rsp.Greeting = "Hello " + req.Name
        return nil
    }

    func main() {
        service := micro.NewService(
        micro.Name("greeter"),
        micro.Version("latest"),
        )

        service.Init()

        err := micro.RegisterHandler(service.Server(), new(Greeter))
        if err != nil {
            log.Fatal(err)
        }

        if err := service.Run(); err != nil {
            log.Fatal(err)
        }
    }

4. go-kit

go-kit是用于微服务和分布式应用程序的工具包，使得这些应用程序变得简单、健壮和可扩展。它将微服务框架分解为可组合的组件，包括进程间通信、服务发现、负载均衡、熔断、日志记录等功能。

    package main

    import (
        "context"
        "fmt"
        "time"

        kitlog "github.com/go-kit/kit/log"
        "github.com/go-kit/kit/log/level"
        "github.com/go-kit/kit/metrics/generic"
        httptransport "github.com/go-kit/kit/transport/http"
        "github.com/gorilla/mux"
    )

    func main() {
        r := mux.NewRouter()

        r.Methods("POST").Path("/sum").Handler(httptransport.NewServer(
            makeSumEndpoint(),
            decodeSumRequest,
            encodeSumResponse,
        ))

        logger := kitlog.NewLogfmtLogger(kitlog.NewSyncWriter(os.Stdout))
        logger = kitlog.With(logger, "timestamp", kitlog.DefaultTimestampUTC)
        logger = kitlog.With(logger, "caller", kitlog.DefaultCaller)

        level.Info(logger).Log("msg", "HTTP", "addr", ":8080")
        errch := make(chan error)

        go func() {
            errch <- http.ListenAndServe(":8080", r)
        }()

        level.Error(logger).Log("exit", <-errch)
    }

    type sumRequest struct {
        A int `json:"a"`
        B int `json:"b"`
    }

    type sumResponse struct {
        V int `json:"v"`
    }

    func makeSumEndpoint() http.Handler {
        return httptransport.NewServer(
            sumEndpoint,
            decodeSumRequest,
            encodeSumResponse,
        )
    }

    func decodeSumRequest(_ context.Context, r *http.Request) (interface{}, error) {
        var req sumRequest
        if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
            return nil, err
        }
        return req, nil
    }

    func encodeSumResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
        return json.NewEncoder(w).Encode(response)
    }

    func sumEndpoint(ctx context.Context, request interface{}) (interface{}, error) {
        req := request.(sumRequest)
        v := req.A + req.B
        return sumResponse{v}, nil
    }