Go-Gin示例代码

Gin Example

• 路由
• 中间件
• 平滑退出(平滑重启)
• 同步|异步(goroutine)
• WebSocket
• Bind(Query|Form|Json)
• JSONP|JSON|SecureJSON|PureJson
• XML|YAML
• ProtoBuf
• 静态页面渲染
• 文件下载
• Swagger接口文档
• Wire (依赖注入DI)

package main

import (
	"context"
	"flag"
	"fmt"
	_ "gogin/docs"
	"gogin/module"
	"io"
	"io/ioutil"
	"log"
	"net"
	"net/http"
	"os"
	"os/signal"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/golang/protobuf/proto"
	gs "github.com/swaggo/gin-swagger"
	"github.com/swaggo/gin-swagger/swaggerFiles"
)

var (
	server   *http.Server
	listener net.Listener = nil

	graceful = flag.Bool("graceful", false, "listen on fd open 3 (internal use only)")
	message  = flag.String("message", "Hello World", "message to send")
	err      error
)

// 绑定form
type LoginForm struct {
	User     string `form:"user" binding:"required"`
	Password string `form:"password" binding:"required"`
}

// 绑定 JSON
// Methods - Bind, BindJSON, BindXML, BindQuery, BindYAML
// Methods - ShouldBind, ShouldBindJSON, ShouldBindXML, ShouldBindQuery, ShouldBindYAML

// 绑定uri
type Person struct {
	ID   string `uri:"id" binding:"required,uuid"`
	Name string `uri:"name" binding:"required"`
}
type Login struct {
	User     string `form:"user" json:"user" xml:"user"  binding:"required"`
	Password string `form:"password" json:"password" xml:"password" binding:"required"`
}

// swagger-api-doc Swagger接口文档
// @Summary Swagger接口文档
// @Description Swagger接口文档
// @Tags Tags 标签
// @Accept application/json
// @Produce application/json
// @Param Authorization header string false "Bearer 用户令牌"
// @Param object query Login false "查询参数"
// @Security ApiKeyAuth
// @Success 200 {object} Person
// @Router /swagger-api-doc [get]
func main() {
	// basic
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "pong",
		})
	})

	// jsonp
	r.GET("/JSONP", func(c *gin.Context) {
		data := map[string]interface{}{
			"foo": "bar",
		}

		// /JSONP?callback=x
		// 将输出：x({\"foo\":\"bar\"})
		c.JSONP(http.StatusOK, data)
	})

	// http server pusher

	// form bind
	r.POST("/login", func(c *gin.Context) {
		// 你可以使用显式绑定声明绑定 multipart form：
		// c.ShouldBindWith(&form, binding.Form)
		// 或者简单地使用 ShouldBind 方法自动绑定：
		var form LoginForm
		// 在这种情况下，将自动选择合适的绑定
		if c.ShouldBind(&form) == nil {
			if form.User == "user" && form.Password == "password" {
				c.JSON(200, gin.H{"status": "you are logged in"})
			} else {
				c.JSON(401, gin.H{"status": "unauthorized"})
			}
		} else {
			c.JSON(500, gin.H{"status": "request failed"})
		}
	})

	// curl -v localhost:8088/thinkerou/987fbc97-4bed-5078-9f07-9141ba07c9f3
	// curl -v localhost:8088/thinkerou/not-uuid
	// r.GET("/:name/:id", func(c *gin.Context) {
	// 	var person Person
	// 	if err := c.ShouldBindUri(&person); err != nil {
	// 		c.JSON(400, gin.H{"msg": err})
	// 		return
	// 	}
	// 	c.JSON(200, gin.H{"name": person.Name, "uuid": person.ID})
	// })

	// form-post
	r.POST("/form_post", func(c *gin.Context) {
		message := c.PostForm("message")
		nick := c.DefaultPostForm("nick", "anonymous")

		c.JSON(200, gin.H{
			"status":  "posted",
			"message": message,
			"nick":    nick,
		})
	})

	// Query | POST Form
	r.POST("/post", func(c *gin.Context) {

		id := c.Query("id")
		page := c.DefaultQuery("page", "0")
		name := c.PostForm("name")
		message := c.PostForm("message")
		rs := fmt.Sprintf("id: %s; page: %s; name: %s; message: %s", id, page, name, message)
		fmt.Printf(rs)
		c.String(200, rs)

	})

	// JSON response
	// 提供 unicode 实体
	r.GET("/json", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"html": "<b>Hello, world!</b>",
		})
	})

	// 提供字面字符
	r.GET("/purejson", func(c *gin.Context) {
		c.PureJSON(200, gin.H{
			"html": "<b>Hello, world!</b>",
		})
	})

	// 你也可以使用自己的 SecureJSON 前缀
	// r.SecureJsonPrefix(")]}',\n")
	r.GET("/someJSON", func(c *gin.Context) {
		names := []string{"lena", "austin", "foo"}

		// 将输出：while(1);["lena","austin","foo"]
		c.SecureJSON(http.StatusOK, names)
	})

	r.GET("/moreJSON", func(c *gin.Context) {
		// 你也可以使用一个结构体
		var msg struct {
			Name    string `json:"user"`
			Message string
			Number  int
		}
		msg.Name = "Lena"
		msg.Message = "hey"
		msg.Number = 123
		// 注意 msg.Name 在 JSON 中变成了 "user"
		// 将输出：{"user": "Lena", "Message": "hey", "Number": 123}
		c.JSON(http.StatusOK, msg)
	})

	r.GET("/someXML", func(c *gin.Context) {
		c.XML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
	})

	r.GET("/someYAML", func(c *gin.Context) {
		c.YAML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
	})

	// protoBuf
	r.GET("/someProtoBuf", func(c *gin.Context) {
		age := int32(12) //[]int64{int64(1), int64(2)}
		name := "test"
		// protobuf 的具体定义写在 testdata/protoexample 文件中。
		data := &module.User{
			Name: name,
			Age:  age,
		}
		// 请注意，数据在响应中变为二进制数据
		// 将输出被 module.User protobuf 序列化了的数据
		c.ProtoBuf(http.StatusOK, data)
	})

	// pares proto
	r.GET("/paresProto", func(c *gin.Context) {
		resp, err := http.Get("http://localhost:8989/someProtoBuf")
		if err != nil {
			fmt.Println(err)
		} else {
			defer resp.Body.Close()
			body, err := ioutil.ReadAll(resp.Body)
			if err != nil {
				fmt.Println(err)
			} else {
				user := &module.User{}
				proto.UnmarshalMerge(body, user)
				c.String(200, user.String())
			}

		}
	})

	// 渲染页面
	r.LoadHTMLFiles("../web/index.html")
	r.StaticFile("/cws.js", "../web/cws.js")
	r.GET("/html", func(c *gin.Context) {
		c.HTML(200, "index.html", nil)
	})

	// 请求资源-下载文件
	r.GET("/someDataFromReader", func(c *gin.Context) {
		response, err := http.Get("https://raw.githubusercontent.com/gin-gonic/logo/master/color.png")
		if err != nil || response.StatusCode != http.StatusOK {
			c.Status(http.StatusServiceUnavailable)
			return
		}

		reader := response.Body
		contentLength := response.ContentLength
		contentType := response.Header.Get("Content-Type")

		extraHeaders := map[string]string{
			// 下载文件
			// "Content-Disposition": `attachment; filename="gopher.png"`,
		}

		c.DataFromReader(http.StatusOK, contentLength, contentType, reader, extraHeaders)
	})

	// 模拟一些私人数据
	var secrets = gin.H{
		"foo":    gin.H{"email": "[email protected]", "phone": "123433"},
		"austin": gin.H{"email": "[email protected]", "phone": "666"},
		"lena":   gin.H{"email": "[email protected]", "phone": "523443"},
	}

	// 路由组使用 gin.BasicAuth() 中间件
	// gin.Accounts 是 map[string]string 的一种快捷方式
	authorized := r.Group("/admin", gin.BasicAuth(gin.Accounts{
		"foo":    "bar",
		"austin": "1234",
		"lena":   "hello2",
		"manu":   "4321",
	}))

	// /admin/secrets 端点
	// 触发 "localhost:8080/admin/secrets
	authorized.GET("/secrets", func(c *gin.Context) {
		// 获取用户，它是由 BasicAuth 中间件设置的
		user := c.MustGet(gin.AuthUserKey).(string)
		if secret, ok := secrets[user]; ok {
			c.JSON(http.StatusOK, gin.H{"user": user, "secret": secret})
		} else {
			c.JSON(http.StatusOK, gin.H{"user": user, "secret": "NO SECRET :("})
		}
	})

	// 全局中间件  单路由多中间件 路由组嵌套
	// TODO:more

	// 中间件 goroutine
	r.GET("/long_async", func(c *gin.Context) {
		// 创建在 goroutine 中使用的副本
		cCp := c.Copy()
		go func() {
			// 用 time.Sleep() 模拟一个长任务。
			time.Sleep(5 * time.Second)

			// 请注意您使用的是复制的上下文 "cCp"，这一点很重要
			log.Println("Done! in path " + cCp.Request.URL.Path)
		}()
	})

	r.GET("/long_sync", func(c *gin.Context) {
		// 用 time.Sleep() 模拟一个长任务。
		time.Sleep(5 * time.Second)

		// 因为没有使用 goroutine，不需要拷贝上下文
		log.Println("Done! in path " + c.Request.URL.Path)
	})

	// swagger api doc
	r.GET("/swagger/*any", gs.WrapHandler(swaggerFiles.Handler))

	uf, e := UserLoader()
	fmt.Println(uf, e)

	// 禁用控制台颜色，将日志写入文件时不需要控制台颜色。
	// gin.DisableConsoleColor()

	// 记录到文件。
	f, _ := os.Create("gin.log")
	gin.DefaultWriter = io.MultiWriter(f)

	// 如果需要同时将日志写入文件和控制台，请使用以下代码。
	// gin.DefaultWriter = io.MultiWriter(f, os.Stdout)

	// 平滑关机
	r.GET("/", func(c *gin.Context) {
		time.Sleep(5 * time.Second)
		c.String(http.StatusOK, "Welcome Gin Server")
	})

	srv := &http.Server{
		Addr:    ":8989",
		Handler: r,
	}

	go func() {
		// 服务连接
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("listen: %s\n", err)
		}
	}()

	// 等待中断信号以优雅地关闭服务器（设置 5 秒的超时时间）
	quit := make(chan os.Signal)
	signal.Notify(quit, os.Interrupt)

	sig := <-quit
	log.Println(sig)
	log.Println("Shutdown Server ...")

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	if err := srv.Shutdown(ctx); err != nil {
		log.Fatal("Server Shutdown:", err)
	}
	log.Println("Server exiting")

	// r.Run(":8989") // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
}