Gin框架学习（三）

已于 2022-04-15 15:30:12 修改
阅读量2.4k 收藏 2
点赞数 1
分类专栏： gin框架 web开发 文章标签： golang 开发语言 后端
于 2022-03-25 10:20:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54129105/article/details/123727309
版权

Gin框架基础

学习思维导图

Gin框架思维导图

提高篇

自定义中间件

Logger日志
package main

import (
    "github.com/gin-gonic/gin"
)
func hello(c *gin.Context) {
    c.JSON(200, "ok")
}
func main() {
    r := gin.New()
    r.Use(gin.Logger())   //日志信息：启动服务请求curl http://localhost:8080/hello
    r.GET("/hello", hello)  
    r.Run()
}
JWT的认证中间件（鉴权）
// 定义一个JWTAuth的中间件
func JWTAuth() gin.HandlerFunc {
	return func(c *gin.Context) {
		// 通过http header中的token解析来认证
		token := c.Request.Header.Get("token")
		if token == "" {
			c.JSON(http.StatusOK, gin.H{
				"status": -1,
				"msg":    "请求未携带token，无权限访问",
				"data":   nil,
			})
			c.Abort()
			return
		}
		log.Print("get token: ", token)
		// 初始化一个JWT对象实例，并根据结构体方法来解析token
		j := NewJWT()
		// 解析token中包含的相关信息(有效载荷)
		claims, err := j.ParserToken(token)
		if err != nil {
			// token过期
			if err == TokenExpired {
				c.JSON(http.StatusOK, gin.H{
					"status": -1,
					"msg":    "token授权已过期，请重新申请授权",
					"data":   nil,
				})
				c.Abort()
				return
			}
			// 其他错误
			c.JSON(http.StatusOK, gin.H{
				"status": -1,
				"msg":    err.Error(),
				"data":   nil,
			})
			c.Abort()
			return
		}
		// 将解析后的有效载荷claims重新写入gin.Context引用对象中
		c.Set("claims", claims)
	}
}
CORS跨域
func CORSMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
        c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
        c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
        c.Writer.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT")
        if c.Request.Method == "OPTIONS" {
            c.AbortWithStatus(204)
            return
        }
        c.Next()
    }
}

登录中间件

main.go

package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/gin-gonic/gin"
    "github.com/zhuge20100104/gin_session/gsession"
)

func main() {
    r := gin.Default()
    mgrObj, err := gsession.CreateSessionMgr(gsession.Redis, "localhost:6379")
    if err != nil {
        log.Fatalf("Create manager obj failed, err: %v\n", err)
        return
    }
    sm := gsession.SessionMiddleware(mgrObj, gsession.Options{
        Path:     "/",
        Domain:   "127.0.0.1",
        MaxAge:   120,
        Secure:   false,
        HttpOnly: true,
    })
    r.Use(sm)
    r.GET("/incr", func(c *gin.Context) {
        session := c.MustGet("session").(gsession.Session)
        fmt.Printf("%#v\n", session)
        var count int
        v, err := session.Get("count")
        if err != nil {
            log.Printf("get count from session failed, err: %v\n", err)
            count = 0
        } else {
            count = v.(int)
            count++
        }
        session.Set("count", count)
        session.Save()
        c.String(http.StatusOK, "count:%v", count)
    })
    r.Run()
}

session.go

package gsession

import (
    "fmt"
    "log"

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

type SessionMgrType string

const (
    // SessionID在cookie里面的名字
    SessionCookieName = "session_id"
    // Session对象在Context里面的名字
    SessionContextName                = "session"
    Memory             SessionMgrType = "memory"
    Redis              SessionMgrType = "redis"
)

// Session 接口
type Session interface {
    // 获取Session对象的ID
    ID() string
    // 加载redis数据到 session data
    Load() error
    // 获取key对应的value值
    Get(string) (interface{}, error)
    // 设置key对应的value值
    Set(string, interface{})
    // 删除key对应的value值
    Del(string)
    // 落盘数据到redis
    Save()
    // 设置Redis数据过期时间,内存版本无效
    SetExpired(int)
}

// SessionMgr Session管理器对象
type SessionMgr interface {
    // 初始化Redis数据库连接
    Init(addr string, options ...string) error
    // 通过SessionID获取已经初始化的Session对象
    GetSession(string) (Session, error)
    // 创建一个新的Session对象
    CreateSession() Session
    // 使用SessionID清空一个Session对象
    Clear(string)
}

// Options Cookie对应的相关选项
type Options struct {
    Path   string
    Domain string
    // Cookie中的SessionID存活时间
    // MaxAge=0 means no 'Max-Age' attribute specified.
    // MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'.
    // MaxAge>0 means Max-Age attribute present and given in seconds.
    MaxAge   int
    Secure   bool
    HttpOnly bool
}

func CreateSessionMgr(name SessionMgrType, addr string, options ...string) (sm SessionMgr, err error) {
    switch name {
    case Memory:
        sm = NewMemSessionMgr()
    case Redis:
        sm = NewRedisSessionMgr()
    default:
        err = fmt.Errorf("unsupported %v\n", name)
        return
    }
    err = sm.Init(addr, options...)
    return
}

func SessionMiddleware(sm SessionMgr, options Options) gin.HandlerFunc {
    return func(c *gin.Context) {
        var session Session
        // 尝试从cookie获取session ID
        sessionID, err := c.Cookie(SessionCookieName)
        if err != nil {
            log.Printf("get session_id from cookie failed, err:%v\n", err)
            session = sm.CreateSession()
            sessionID = session.ID()
        } else {
            log.Printf("SessionId: %v\n", sessionID)
            session, err = sm.GetSession(sessionID)
            if err != nil {
                log.Printf("Get session by %s failed, err: %v\n", sessionID, err)
                session = sm.CreateSession()
                sessionID = session.ID()
            }
        }

        session.SetExpired(options.MaxAge)
        c.Set(SessionContextName, session)
        c.SetCookie(SessionCookieName, sessionID, options.MaxAge, options.Path, options.Domain, options.Secure, options.HttpOnly)
        defer sm.Clear(sessionID)
        c.Next()
    }
}

memory.go

package gsession

import (
    "fmt"
    "sync"
    uuid "github.com/satori/go.uuid"
)
// memSession 内存对应的Session对象
type memSession struct {
    // 全局唯一标识的session id对象
    id string
    // session数据
    data map[string]interface{}
    // session过期时间
    expired int
    // 读写锁，支持多线程
    rwLock sync.RWMutex
}
func NewMemSession(id string) *memSession {
    return &memSession{
        id:   id,
        data: make(map[string]interface{}, 8),
    }
}
func (m *memSession) ID() string {
    return m.id
}
func (m *memSession) Load() (err error) {
    return
}
func (m *memSession) Get(key string) (value interface{}, err error) {
    m.rwLock.RLock()
    defer m.rwLock.RUnlock()
    value, ok := m.data[key]
    if !ok {
        err = fmt.Errorf("Invalid key")
        return
    }
    return
}
func (m *memSession) Set(key string, value interface{}) {
    m.rwLock.Lock()
    defer m.rwLock.Unlock()
    m.data[key] = value
}
func (m *memSession) Del(key string) {
    m.rwLock.Lock()
    defer m.rwLock.Unlock()
    delete(m.data, key)
}
func (m *memSession) Save() {
    return
}
func (m *memSession) SetExpired(expired int) {
    m.expired = expired
}
// MemSessionMgr 内存Session管理器
type MemSessionMgr struct {
    session map[string]Session
    rwLock  sync.RWMutex
}
// NewMemSessionMgr MemSessionMgr类构造函数
func NewMemSessionMgr() *MemSessionMgr {
    return &MemSessionMgr{
        session: make(map[string]Session, 1024),
    }
}
func (m *MemSessionMgr) Init(addr string, options ...string) (err error) {
    return
}
// GetSession get the session by session id
func (m *MemSessionMgr) GetSession(sessionID string) (sd Session, err error) {
    m.rwLock.RLock()
    defer m.rwLock.RUnlock()
    sd, ok := m.session[sessionID]
    if !ok {
        err = fmt.Errorf("Invalid session id")
        return
    }
    return
}
func (m *MemSessionMgr) CreateSession() (sd Session) {
    sessionID := uuid.NewV4().String()
    sd = NewMemSession(sessionID)
    m.session[sd.ID()] = sd
    return
}
func (m *MemSessionMgr) Clear(sessionID string) {
    m.rwLock.Lock()
    defer m.rwLock.Unlock()
    delete(m.session, sessionID)
}

redis.go

package gsession
import (
    "bytes"
    "encoding/gob"
    "fmt"
    "log"
    "strconv"
    "sync"
    "time"
    "github.com/go-redis/redis"
    uuid "github.com/satori/go.uuid"
)
// redisSession redis session对象
type redisSession struct {
    // redis session id 对象
    id string
    // session 数据对象
    data map[string]interface{}
    // session 数据是否有更新
    modifyFlag bool
    // 过期时间
    expired int
    rwLock  sync.RWMutex
    client  *redis.Client
}
func NewRedisSession(id string, client *redis.Client) (session Session) {
    session = &redisSession{
        id:     id,
        data:   make(map[string]interface{}, 8),
        client: client,
    }
    return
}
func (r *redisSession) ID() string {
    return r.id
}
func (r *redisSession) Load() (err error) {
    data, err := r.client.Get(r.id).Bytes()
    if err != nil {
        log.Printf("get session data from redis by %s failed, err: %v\n", r.id, err)
        return
    }
    dec := gob.NewDecoder(bytes.NewBuffer(data))
    err = dec.Decode(&r.data)
    if err != nil {
        log.Printf("gob decode session data failed, err: %v\n", err)
        return
    }
    return
}
func (r *redisSession) Get(key string) (value interface{}, err error) {
    r.rwLock.RLock()
    defer r.rwLock.RUnlock()
    value, ok := r.data[key]
    if !ok {
        err = fmt.Errorf("invalid key")
        return
    }
    return
}
func (r *redisSession) Set(key string, value interface{}) {
    r.rwLock.Lock()
    defer r.rwLock.Unlock()
    r.data[key] = value
    r.modifyFlag = true
}
func (r *redisSession) Del(key string) {
    r.rwLock.Lock()
    defer r.rwLock.Unlock()
    delete(r.data, key)
    r.modifyFlag = true
}
func (r *redisSession) SetExpired(expired int) {
    r.expired = expired
}
func (r *redisSession) Save() {
    r.rwLock.Lock()
    defer r.rwLock.Unlock()
    if !r.modifyFlag {
        return
    }
    buf := new(bytes.Buffer)
    enc := gob.NewEncoder(buf)
    err := enc.Encode(r.data)
    if err != nil {
        log.Fatalf("gob encode r.data failed, err: %v\n", err)
        return
    }
    r.client.Set(r.id, buf.Bytes(), time.Second*time.Duration(r.expired))
    log.Printf("set data %v to redis.\n", buf.Bytes())
    r.modifyFlag = false
}
// redisSessionMgr redis Session管理器对象
type redisSessionMgr struct {
    session map[string]Session
    rwLock  sync.RWMutex
    client  *redis.Client
}
// NewRedisSessionMgr Redis SessionMgr类构造函数
func NewRedisSessionMgr() *redisSessionMgr {
    return &redisSessionMgr{
        session: make(map[string]Session, 1024),
    }
}
func (r *redisSessionMgr) Init(addr string, options ...string) (err error) {
    var (
        password string
        db       int
    )
    if len(options) == 1 {
        password = options[0]
    }
    if len(options) == 2 {
        password = options[0]
        db, err = strconv.Atoi(options[1])
        if err != nil {
            log.Fatalln("invalid redis DB param")
        }
    }
    r.client = redis.NewClient(&redis.Options{
        Addr:     addr,
        Password: password,
        DB:       db,
    })
    _, err = r.client.Ping().Result()
    if err != nil {
        return
    }
    return nil
}
func (r *redisSessionMgr) GetSession(sessionID string) (sd Session, err error) {
    sd = NewRedisSession(sessionID, r.client)
    err = sd.Load()
    if err != nil {
        return
    }
    r.rwLock.RLock()
    r.session[sessionID] = sd
    r.rwLock.RUnlock()
    return
}
func (r *redisSessionMgr) CreateSession() (sd Session) {
    sessionID := uuid.NewV4().String()
    sd = NewRedisSession(sessionID, r.client)
    r.session[sd.ID()] = sd
    return
}
func (r *redisSessionMgr) Clear(sessionID string) {
    r.rwLock.Lock()
    defer r.rwLock.Unlock()
    delete(r.session, sessionID)
}

后记

喜欢的话可以三连，后续继续更新其他内容，帮忙推一推，感谢观看!

北岛末巷
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
创建Vue 项目 登录注册以及携带token
官方小可爱√的博客
10-31 596
创建Vue 项目 登录注册以及携带token安装 Vue创建vue 项目 安装 Vue npm 安装 ，从node官网下载 node 双击打开，在安装界面一直NEXT； 打开控制命令行程序（CMD）,检查是否正常 node -v npm -v 然后使用 npm 下载 cnpm npm install -g cnpm --registry=https://registry.npm.taobao.org 然后检查cnpm 是否安装成功 vue-cli版本必须是3.0或更高版本 使用
Golang-Gin框架示例二十多个源码
最新发布
04-26
Golang-Gin框架示例二十多个源码，Gin框架应用全面，适合Golang爱好者学习
Go语言--Gin框架的基础了解
qq_63530862的博客
03-08 808
Gin的初步了解
gin框架学习（上） learn from枫枫知道
kingsill的博客
10-13 610
请求头（Request Headers）是 HTTP 请求中包含的一些元数据信息，用于向服务器传递额外的请求参数和属性。请求头通常由键值对（Key-Value pairs）组成，每个键值对表示一个请求头字段和对应的值。Host：指定目标服务器的主机名和端口号。User-Agent：发送请求的用户代理（浏览器、应用程序等）的标识信息。：指定请求体的媒体类型（如 application/json、application/x-www-form-urlencoded 等）。：指定请求体的长度。
GO学习之 协程(goroutine)
qq_19283249的博客
07-31 1957
在 Go 语言中，goroutine 是一种非常轻量的执行单元，有 Go 运行是（runtime）进行调度，不是有固定大小的线程来处理的。与传统线程相比，goroutine的创建和切换开销很小，因此可以创建大量的 goroutine 来并行执行任务，而不会造成太大的系统负担。 * goroutine 更像是一种高效的协程，它在并发编程中提供了轻量且较高的方式来处理并发，而不需要显式地创建和管理线程池。
多线程，到底该设置多少个线程？
weixin_30740581的博客
05-27 807
一、前言 “不好了，线上服务器超时严重，请求非常慢，好像报连接数too many了，怎么办？“小伙伴们在反馈。一般我们的技术老大的处理方式，把连接数和线程池调大点，重启，再观察。 往往这个方式是应急措施，治标不治本，因为不知道问题的原因。 有个严重误区，以为线程池设置太小了，调大点请求就会快了。 今天就带着小伙伴们沟通一下，线程池的大小应该如何合理的设置其大小？ 二、问题 如果有两个任...
Go Web开发进阶实战（gin框架）
01-05
Go Web开发进阶实战（gin框架）课程，适用于Go语言初学者、掌握Go语言基础语法想学习进阶内容。 由在职程序员打造的Go语言实战课程体系，与你分享企业项目开发经验与技巧。真正做到课程有内容、有深度，并且老师讲...
Go Web框架gin的入门教程
09-20
### 安装gin框架 安装gin非常简单，只需通过`go get`命令即可： ```bash go get github.com/gin-gonic/gin ``` 安装完成后，你就可以在项目中导入并使用gin库了。 ### 简单示例 下面是最基本的gin应用示例，它创建...
gin-source-learn:Gin框架源码学习
03-23
Gin Web框架 Gin是用Go（Golang）编写的Web框架。 它具有类似于martini的API，性能更高，由于使用了速度提高了40倍。 如果您需要性能和良好的生产率，您会爱上Gin的。 内容 安装 要安装Gin软件包，您需要安装Go并...
毕业设计 基于 gin 框架和 Vue 框架搭建的前后端分离区块链论坛源码+详细文档+全部资料（高分项目）.zip
04-17
毕业设计 基于 gin 框架和 Vue 框架搭建的前后端分离区块链论坛源码+详细文档+全部资料（高分项目）.zip毕业设计 基于 gin 框架和 Vue 框架搭建的前后端分离区块链论坛源码+详细文档+全部资料（高分项目）.zip毕业...
golang学习之--限制程序中协程执行的数量上限【转载】
cyb_17302190874的博客
08-26 828
package main import ( "fmt" "strconv" "time" ) var ( maxRoutineNum = 10 ) // 模拟下载页面的方法 func download(url string, ch chan int) { fmt.Println("download from ", url) // 休眠两秒模拟下载页面 time.Sleep(2 * 1e9) // 下载完成则从ch推出数据 <...
gin 协程并发导致服务停止
wwhhff11
01-03 5538
问题代码：func load(c *gin.Context){ go func(c *gin.Context){ c.GetString(....) }(c) go func(c *gin.Context){ c.Set(...) }(c) }导致服务偶发性停止，对外表现为某段时间，某台实例服务全部不可用。 查看日志： fatal
http协议与gin
weixin_42873876的博客
11-10 724
socket编程与tcp 由于tcp/ip协议都封装在操作系统的底层上，为了避免应用层直接去调用操作系统的方法，所以操作系统提供了一个socket接口,应用层去调用这个接口，而socket接口又分为tcpSocket和udpSocket,可以理解为socket其实就是应用层和传输层的一个门面,调用socket方法只是去调用我们tcp/udp协议的传输 tcp特点: 可靠传输(校验和，超时重试机制,流量控制,拥塞控制) 面向字节流 三次握手，四次挥手 go的socket编程 server端: func
go+mysql+redis+vue3简单聊室，第4弹：gin的websocket通讯和多go程任务处理
u012830303的博客
07-14 1572
前面我们使用gin的路由实现了常规的http请求，但是聊天是基于websocket的，我们需要建立一个新路由，用于接收websocket请求。websocket的建立是基于http的，一开始需要通过http建立联系，所以我们是可以通过http路由监听到websocket请求的，然后判断请求类型，是websokcet的话，就建立真正的websocket服务gin处理websocket就是用上述方式进行的。修改routes/route.go,如下 在go中，一个http请求就是一个协程，代码执行结束后该协程就结
GO 语言 gin 第14篇 使用Gin 运行多个服务
sss996的博客
07-05 3517
运行服务的返回类型为 ：http.Handler 。gin.New(),gin.Default() 返回的就是此类型。 使用&http.Server{....} 设置服务参数 使用g.Go(func () error{ return server.ListenAndServe()}) 开启一个服务。 package main import ( "github.com/Unknw...
Gin框架日常使用--高频api使用示例
rickiyang的博客
06-16 3799
Go web框架目前有很多，Beego，Gin，Iris，Revel等等。目前国内使用量比较多的是前两个，鉴于Beego的源码一直被人吐槽并且Beego使用起来太过于臃肿，框架本身构造的大而全，很多功能不一定会是你想要的这些原因，我们着重关注Gin框架的使用。Gin没有像Beego那样什么都做，它只专注于web请求的封装，如果你想做缓存，想连接数据库等等还需要使用别的框架或者使用原生的API。 G...
go实战：web框架gin的使用（十三）：多参数绑定
美丽的泡沫
05-23 3101
注意啊，代码中使用的是Any，可以尽量获取任意参数，执行看效果我们再来看下控制台输出
go的web框架gin的使用（十）：日志
热门推荐
美丽的泡沫
05-22 1万+
先上代码代码解说：gin.DisableConsoleColor()，关掉控制台颜色，这波操作666，至于为啥作者想到这？我也好奇，难道提升性能（作者的解释是）
iris框架和gin框架对比
07-15
Iris框架和Gin框架是两个流行的Go语言Web框架，它们都有各自的特点和优势。 1. 性能：Gin框架在性能方面表现出色，相比之下，Iris框架的性能稍逊一筹。Gin框架使用了httprouter作为默认的路由处理器，而Iris框架则使用了自己实现的高性能路由器。 2. 学习曲线：Gin框架相对来说更容易学习和上手，它的API设计简洁明了，文档也相对完善。而Iris框架则提供了更多的功能和扩展选项，学习曲线相对较陡峭。 3. 功能丰富：Iris框架提供了更多的功能和中间件选项，例如Websocket支持、自定义错误处理、请求缓存等。Gin框架则更加轻量级，只提供了基本的路由、中间件和上下文处理等核心功能。 4. 社区支持：Gin框架拥有更大的社区支持，拥有更多的开源项目和插件可供选择。Iris框架相对较新，社区规模相对较小，但也在不断发展壮大。 总体而言，如果对性能有较高要求且追求简洁的API设计，可以选择Gin框架；如果需要更多功能和灵活性，并且愿意花更多时间学习和掌握，可以选择Iris框架。选择哪个框架取决于项目需求和个人偏好。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北岛末巷

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值