gin

上下文设置变量

package main

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

func MiddleWare() (gin.HandlerFunc){
    return func(c *gin.Context) {
        t:=time.Now()
        fmt.Println("中间件开始执行了")
        //设置变量到上下文
        m1:=make(map[string]interface{},0)
        m1["age"]=22
        m1["name"]="jack"

        c.Set("request",m1)
        status:=c.Writer.Status()
        fmt.Println("中间件执行完毕",status)
        t2:=time.Since(t)
        fmt.Println("time",t2)

    }
}

func main(){
    //创建路由、、、、
    //默认使用中间件logger(),recovery()
    r:=gin.Default()
    //注册中间件
    r.Use(MiddleWare())
    {
        r.GET("/ce", func(c *gin.Context) {
            //取值
            req,_:=c.Get("request")
            fmt.Println("requeset=",req)
            //页面接收
        })
    }
    r.Run(":8088")
}

局部中间件

package main

import (
    "fmt"
    "time"

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

// 定义中间
func MiddleWare() gin.HandlerFunc {
    return func(c *gin.Context) {
        t := time.Now()
        fmt.Println("中间件开始执行了")
        // 设置变量到Context的key中，可以通过Get()取
        c.Set("request", "中间件")
        // 执行函数
        c.Next()
        // 中间件执行完后续的一些事情
        status := c.Writer.Status()
        fmt.Println("中间件执行完毕", status)
        t2 := time.Since(t)
        fmt.Println("time:", t2)
    }
}

func main() {
    // 1.创建路由
    // 默认使用了2个中间件Logger(), Recovery()
    r := gin.Default()
    // 注册中间件
    r.Use(MiddleWare())
    // {}为了代码规范
    {//MiddleWare(执行前半部分)
        r.GET("/ce",MiddleWare(), func(c *gin.Context) {
            // 取值
            req, _ := c.Get("request")
            fmt.Println("request:", req)
            // 页面接收
            c.JSON(200, gin.H{"request": req})
        })

    }
    r.Run(":8088")
}

session使用

package main

import (
    "fmt"
    "github.com/gorilla/sessions"
    "net/http"
)

// 初始化一个cookie存储对象
// something-very-secret应该是一个你自己的密匙，只要不被别人知道就行
var store = sessions.NewCookieStore([]byte("something-very-secret"))

func main() {
    http.HandleFunc("/save", SaveSession)
    http.HandleFunc("/get", GetSession)
    err := http.ListenAndServe(":8088", nil)
    if err != nil {
        fmt.Println("HTTP server failed,err:", err)
        return
    }
}

func SaveSession(w http.ResponseWriter, r *http.Request) {
    // Get a session. We're ignoring the error resulted from decoding an
    // existing session: Get() always returns a session, even if empty.

    //　获取一个session对象，session-name是session的名字
    session, err := store.Get(r, "session-name")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    // 在session中存储值
    session.Values["foo"] = "bar"
    session.Values[42] = 43
    // 保存更改
    session.Save(r, w)
}
func GetSession(w http.ResponseWriter, r *http.Request) {
    session, err := store.Get(r, "session-name")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    foo := session.Values["foo"]
    fmt.Println(foo)
}

删除

 // 删除
    // 将session的最大存储时间设置为小于零的数即为删除
    session.Options.MaxAge = -1
    session.Save(r, w)

 跨域cors

package middleware

import (
    "net/http"

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

//跨域
func CrossDomain() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 解决跨域
        c.Header("Access-Control-Allow-Origin", c.Request.Header.Get("Origin"))
        c.Header("Access-Control-Allow-Headers", "Content-Type,AccessToken,X-CSRF-Token, Authorization, Token")
        c.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, PATCH, DELETE")
        c.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Content-Type")
        c.Header("Access-Control-Allow-Credentials", "true")
        if c.Request.Method == "OPTIONS" {
            c.AbortWithStatus(http.StatusNoContent)
        }
        c.Next()
    }
}

...