• 我们知道，http是无状态的，即每次http请求对于服务器来说都是新用户，那么我们怎么解决登录的问题呢？

cookie

• 最早我们可以使用cookie，即一个用户第一次请求的时候，是没有cookie的，这个时候呢，服务器会自动生成一个session_id存放到cookie里面去，也就是说浏客户端的cookie，服务器不仅可以读，而且可以写，正是基于此我们就可以实现用户登录的功能。比如我们首次访问https://www.acurd.com
• 我们第二次再访问

go操作session

go并不像php那样原生就支持session，我们可以根据自己的需求实现一个session库，也可以使用第三方的库，这也再次说明了session并不是什么神秘的技术，而是基于服务端对客户端cookie的读写来实现的。 这里我们使用第三方库来演示一下

package main

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

var store = sessions.NewCookieStore([]byte("secret-key"))

// 自定义一个账户和密码
var name, pwd = "acurd", "acurdpwd"

func LoginHandler(w http.ResponseWriter, r *http.Request) {

	//获取session
	session, _ := store.Get(r, "session_id")

	//打印session信息
	fmt.Printf("%+v", session.Values)
	if !session.IsNew {
		fmt.Fprintf(w, "<h1>你已经登录了</h1>")
		return
	}

	r.ParseForm()       // 解析参数，默认是不会解析的
	fmt.Println(r.Form) // 这些信息是输出到服务器端的打印信息
	//有的话校验登录
	username := r.FormValue("username")
	password := r.FormValue("password")
	if username == name && password == pwd {
		session.Values["username"] = username
		// 将session保存
		err := session.Save(r, w)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		fmt.Fprintf(w, "<h1>登录成功</h1>")

		return
	}
	//没有的话提示输入用户名密码
	fmt.Fprintf(w, "<h1>用户名或密码失败</h1>")
}

func main() {
	// 创建路由
	r := mux.NewRouter()
	r.HandleFunc("/login", LoginHandler)
	err := http.ListenAndServe(":8002", r)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}
}

缺点

cookie+session这种方式的缺点

• 依赖cookie实现，所以客户端不能禁用cookie
• cookie可能被截获，别人利用我们的cookie信息就可以跳过登录验证
• session是如果是存储在服务器内存的话，当我们跨服务器访问的时候，不能识别登录状态
• 如果用户量很大的话，session占用的服务器内存也就越大。

Token

• 基于Token的认证是近几年非常流行的认证方式。基于token的认证中，最常用的是JSON Web Tokens,即JWT（JSON Web Token的缩写）,这种方式摒弃了传统的基于cookie和session的登录认证，可以实现跨域认证。

JWT

jwt登录的流程

• 第一次请求使用 用户名+密码完成登录
• 登录成功颁发token，token里面可以有你自定义的一些信息，比如用户名，用户id，会被加密后返回给前端
• 前端保留此token，每次请求的时候带上该token，后端解析后就可以读取token里的用户名和用户id
• 只要服务端使用的是同一个秘钥，token都会被解析成功，也就是说解决了跨域登录的问题。

jwt的数据结构

我们先来看一个token长什么样子，比如这个eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVc2VybmFtZSI6ImFjdXJkIiwiVWlkIjoxMiwic3ViIjoiVG9rZW4iLCJleHAiOjE2ODc4Njk2NjYsImlhdCI6MTY4Nzg2NjA2Nn0._hIRJDrLV8co1gZPKKxG2AyMVFRapl-nt-Kqbb-r8bg,我们看到这个token被.分割成了三部分，那么这三部分代表什么含义呢？我们先来还原一下这三部分怎么来的

• 第一部分eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9是对算法和type的加密，加密算法是base64.urlencode，相关代码如下：

func TestDemoTwo28(t *testing.T) {

	type JWTHeader struct {
		Alg string `json:"alg"`
		Typ string `json:"typ"`
	}
	header := JWTHeader{
		Alg: "HS256",
		Typ: "JWT",
	}
	headerBytes, _ := json.Marshal(header)
	headerBase64 := base64.RawURLEncoding.EncodeToString(headerBytes) // 对字节数组进行 Base64 编码
	fmt.Println(headerBase64)                                         // 输出编码后的 JWT Header

}

执行结果是一模一样的

• 第二部分eyJVc2VybmFtZSI6ImFjdXJkIiwiVWlkIjoxMiwic3ViIjoiVG9rZW4iLCJleHAiOjE2ODc4Njk2NjYsImlhdCI6MTY4Nzg2NjA2Nn0其实也是base64.urlencode加密得来的，加密的对象就是我们存储的数据，咱们可以用解码的方式解析一下看看

相关代码如下

func TestDemoTwo28(t *testing.T) {
	str := "eyJVc2VybmFtZSI6ImFjdXJkIiwiVWlkIjoxMiwic3ViIjoiVG9rZW4iLCJleHAiOjE2ODc4Njk2NjYsImlhdCI6MTY4Nzg2NjA2Nn0"
	decodeString, _ := base64.RawURLEncoding.DecodeString(str)
	fmt.Printf("%s", string(decodeString))
}

执行结果如下

通过第一部分和第二部分我们看到了，这是一种可逆的加密，所以不要放重要数据（也可以再次对payload的数据对称加密，保证数据不外泄），比如登录密码，手机号。接下来看第三部分。这里我贴一份可逆加密的代码

package main

import (
	"crypto/aes"
	"crypto/cipher"
	"encoding/base64"
	"encoding/hex"
	"fmt"
)

func main() {
	// 原始数据
	source := "Hello, world!"
	fmt.Println("原文：", source)

	// 密钥，必须是 16、24 或 32 字节
	key := "example key 1234"

	// 加密
	encryptCode := AESEncrypt([]byte(source), []byte(key))
	fmt.Println("密文（byte）：", encryptCode)

	// 使用 hex 编码打印
	fmt.Println("密文（hex）：", hex.EncodeToString(encryptCode))

	// 使用 base64 编码打印
	fmt.Println("密文（base64）：", base64.StdEncoding.EncodeToString(encryptCode))

	// 解密
	decryptCode := AESDecrypt(encryptCode, []byte(key))
	fmt.Println("解密后的原文：", string(decryptCode))
}

// AESEncrypt 使用 AES 加密数据
func AESEncrypt(data, key []byte) []byte {
	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}
	ciphertext := make([]byte, aes.BlockSize+len(data))
	iv := ciphertext[:aes.BlockSize]
	stream := cipher.NewCFBEncrypter(block, iv)
	stream.XORKeyStream(ciphertext[aes.BlockSize:], data)
	return ciphertext
}

// AESDecrypt 使用 AES 解密数据
func AESDecrypt(data, key []byte) []byte {
	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}
	if len(data) < aes.BlockSize {
		panic("ciphertext too short")
	}
	iv := data[:aes.BlockSize]
	data = data[aes.BlockSize:]
	stream := cipher.NewCFBDecrypter(block, iv)
	stream.XORKeyStream(data, data)
	return data
}

• 第三部分_hIRJDrLV8co1gZPKKxG2AyMVFRapl-nt-Kqbb-r8bg 这个数值是怎么来的呢？就是基于前两段的值+秘钥计算得来，具体算法如下HMACSHA256( base64UrlEncode(header) + "." +base64UrlEncode(payload), secret )，这一部分才是校验我们数据的准确性，比如数据是否早到篡改。

我们可以通过https://jwt.io/更直观的观察结果 这个时候，是不是上来就是一句卧槽，原来token是可以被解析的，那我的token岂不是不安全，说的对，token只是实现登录认证，并不保证你的数据不外泄，所以我们不能把重要的信息放到token里面去。但是如果你篡改了数据，伪造登录，由于别人没有你的秘钥，导致第三段校验失败，就可以拦截非法登录了。

其实了解了jwt的实现机制，我们自己也可以定义一套自己的token机制来实现登录功能。 下面我们来看一下别人已经造好的轮子是怎么用的。

使用jwt实现登录功能

我们使用go的第三方包来实现jwt登录功能

怎么找包

怎么找包要认真说，还真是一个技术活，你要是网上随便搜一个，那么第一安全性，可靠性都可能会有问题，更别谈后期的维护了。那么一般我们怎么找包呢？github上面通过 语言+关键词来搜索，一般使用star最多的就行了，比如我们在github 搜 go jwt 我们看到第一个和第二个其实是一个仓库，所以我们使用github.com/golang-jwt/jwt/v5这个包

• 下面是jwt登录功能的相关代码

package main

import (
	"fmt"
	"github.com/golang-jwt/jwt/v5"
	"github.com/gorilla/mux"
	"log"
	"net/http"
	"time"
)

// 定义自己的秘钥 所有的服务必须用一个秘钥才能正确解析token
var privateKey = []byte("my_secret_key")

// 自定义一个账户和密码 用户uid 这里简单举个例子,一般是去数据库校验
var name, pwd, uid = "acurd", "acurdpwd", 12

// UserClaims 我们声明一个结构体,里面包含我们想要保存的信息
type UserClaims struct {
	Username             string
	Uid                  int64
	jwt.RegisteredClaims // 内嵌标准的声明
}

// GenToken 生成token
func GenToken(username string, uid int64) (string, error) {
	//初始化结构体
	claims := UserClaims{
		Uid:      uid,
		Username: username,
		RegisteredClaims: jwt.RegisteredClaims{
			//设置过期时间
			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Second * 3600)),
			//颁发时间
			IssuedAt: jwt.NewNumericDate(time.Now()),
			//主题
			Subject: "Token",
		},
	}
	//生成token  使用hs256 加密 结构体,然后再用秘钥对其做数字签名
	return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(privateKey)
}

// 解析token
func parseToken(tokenString string) (*UserClaims, error) {
	claims := new(UserClaims)
	token, err := jwt.ParseWithClaims(tokenString, claims, keyFunc)
	//建议token是否有效
	if token.Valid {
		return claims, nil
	}
	return nil, err
}
func keyFunc(token *jwt.Token) (interface{}, error) {
	return privateKey, nil
}

func LoginHandler(w http.ResponseWriter, r *http.Request) {

	//限制post提交
	if r.Method != "POST" {
		fmt.Fprintf(w, "<h1>非法登录</h1>")
		return
	}

	//获取token
	auth := r.Header.Get("Authorization")
	if len(auth) > 0 { //刺入还可以加入对
		//打印token信息
		fmt.Println(auth)
		//校验token
		claims, err := parseToken(auth)
		if err != nil {
			fmt.Fprintf(w, "<h1>解析token失败</h1>")
			return
		}
		//
		fmt.Fprintf(w, "<h1>您已经登录了</h1>相关token解析如下:%+v", claims)
		return
	}

	r.ParseForm()       // 解析参数，默认是不会解析的
	fmt.Println(r.Form) // 这些信息是输出到服务器端的打印信息
	//有的话校验登录
	username := r.FormValue("username")
	password := r.FormValue("password")
	if username == name && password == pwd {
		// 生成token并返回
		token, err := GenToken(username, int64(uid))
		if err != nil {
			fmt.Fprintf(w, "<h1>生成token失败</h1>")
		}
		// 将token保存
		fmt.Fprintf(w, "<h1>登录成功</h1>请保存好你的token:%s", token)
		return
	}
	//没有的话提示输入用户名密码
	fmt.Fprintf(w, "<h1>用户名或密码失败</h1>")
}

func main() {
	// 创建路由
	r := mux.NewRouter()
	r.HandleFunc("/login", LoginHandler)
	err := http.ListenAndServe(":8002", r)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}
}

• 我们运行一下上面的代码 第一次获取到token
• 第二次带token请求
• 如果修改里面的任意一个字符

jwt的刷新机制

场景1:我们用QQ或者微信，不可能每打开一次都执行一次登录操作，而是好长时间不用，比如一个月没有打开QQ，那么你再次打开QQ，可能就需要登录了，但是如果你经常打开QQ，可能好几个月都不需要登录，那么这是怎么实现的呢？

场景2：你设计了一套jwt的登录系统，token有效期是60分钟，用户在58分钟的时候打开了网页，在61分钟的时候点击提交，发现自己被退出登录了，你说用户气不气？

refresh_token

基于上面的两种场景，我们提出来refresh_token的机制，其实就是多了一个刷新token的触发机制，第一次登录的时候，我们给用户颁发两个token ，一个access_token，有效期比较短，比如是4小时，还有一个refresh_token ，就是刷新token，假设有效期是24小时。

• 第一次登录，我们返回access_token和refresh_token
• 后面的请求，我们校验access_token是否过期，没过期的放行通过，过期的话就要校验refresh_token是否过期，如果没有过期，则拿着refresh_token 下发新的access_token和新的refresh_token（下发新的refresh_token是为了避免活跃用户的频繁登录，比如24小时内只要用户登录过，就不会弹出登录窗口。具体根据业务看）。如果两个token都过期了，则重新登录。
• 相关代码如下

package main

import (
	"fmt"
	"github.com/golang-jwt/jwt/v5"
	"github.com/gorilla/mux"
	"log"
	"net/http"
	"time"
)

// 定义自己的秘钥 所有的服务必须用一个秘钥才能正确解析token
var privateKey = []byte("my_secret_key")

// 自定义一个账户和密码 用户uid 这里简单举个例子,一般是去数据库校验
var name, pwd, uid = "acurd", "acurdpwd", 12

// UserClaims 我们声明一个结构体,里面包含我们想要保存的信息
type UserClaims struct {
	Username             string
	Uid                  int64
	jwt.RegisteredClaims // 内嵌标准的声明
}

// RefreshClaims 用来生成refresh token
type RefreshClaims struct {
	jwt.RegisteredClaims // 内嵌标准的声明
}

// GenToken 生成token
func GenToken(username string, uid int64) (string, error) {
	//初始化结构体
	claims := UserClaims{
		Uid:      uid,
		Username: username,
		RegisteredClaims: jwt.RegisteredClaims{
			//设置过期时间
			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Second * 30)),
			//颁发时间
			IssuedAt: jwt.NewNumericDate(time.Now()),
			//主题
			Subject: "Token",
		},
	}
	//生成token  使用hs256 加密 结构体,然后再用秘钥对其做数字签名
	return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(privateKey)
}

// 解析token
func parseToken(tokenString string) (*UserClaims, error) {
	claims := new(UserClaims)
	_, err := jwt.ParseWithClaims(tokenString, claims, keyFunc)
	return claims, err
}
func keyFunc(token *jwt.Token) (interface{}, error) {
	return privateKey, nil
}

// GenRefreshToken 生成token
func GenRefreshToken() (string, error) {
	//初始化结构体
	claims := UserClaims{
		RegisteredClaims: jwt.RegisteredClaims{
			//设置过期时间
			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Second * 3600)),
			//颁发时间
			IssuedAt: jwt.NewNumericDate(time.Now()),
			//主题
			Subject: "RefreshToken",
		},
	}
	//生成token  使用hs256 加密 结构体,然后再用秘钥对其做数字签名
	return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(privateKey)
}

// 解析token
func parseRefreshToken(tokenString string) (*RefreshClaims, error) {
	claims := new(RefreshClaims)
	token, err := jwt.ParseWithClaims(tokenString, claims, keyFunc)
	//建议token是否有效
	if token.Valid {
		return claims, nil
	}
	return nil, err
}

func LoginHandler(w http.ResponseWriter, r *http.Request) {

	//限制post提交
	if r.Method != "POST" {
		fmt.Fprintf(w, "<h1>非法登录</h1>")
		return
	}

	//获取token
	auth := r.Header.Get("Authorization")
	tokenRefresh := r.Header.Get("AuthorizationRef")
	fmt.Println(auth)
	fmt.Println(tokenRefresh)
	if len(auth) > 0 {
		// 解析refresh token
		claimsR, err := parseRefreshToken(tokenRefresh)
		if err != nil {
			fmt.Fprintf(w, "token 错误或过期%s", err)
			return
		}
		fmt.Printf("claimsR %v", claimsR)
		//解析token
		claims, err := parseToken(auth)
		fmt.Printf("claims %+v  err:%v", claims, err)
		//token未过期
		if claims != nil && !claims.Expired() {
			fmt.Fprintf(w, "<h1>您已经登录了</h1>相关token解析如下:%+v", claims)
			return
		}
		token, _ := GenToken(claims.Username, int64(uid))
		refreshToken, _ := GenRefreshToken()
		// 将token保存
		fmt.Fprintf(w, "<h1>已经更新token</h1>请保存好你的token:%s;refreshToken:%s", token, refreshToken)
		return
	}

	r.ParseForm()       // 解析参数，默认是不会解析的
	fmt.Println(r.Form) // 这些信息是输出到服务器端的打印信息
	//有的话校验登录
	username := r.FormValue("username")
	password := r.FormValue("password")
	if username == name && password == pwd {
		// 生成token并返回
		token, _ := GenToken(username, int64(uid))
		refreshToken, _ := GenRefreshToken()
		// 将token保存
		fmt.Fprintf(w, "<h1>登录成功</h1>请保存好你的token:%s;refreshToken:%s", token, refreshToken)
		return
	}
	//没有的话提示输入用户名密码
	fmt.Fprintf(w, "<h1>用户名或密码失败</h1>")
}

// Expired 检查自定义的token结构体是否过期
func (token *UserClaims) Expired() bool {

	fmt.Println(time.Now().Unix())
	fmt.Println(token.ExpiresAt.Unix())
	return time.Now().Unix() > token.ExpiresAt.Unix()
}

func main() {
	// 创建路由
	r := mux.NewRouter()
	r.HandleFunc("/login", LoginHandler)
	err := http.ListenAndServe(":8002", r)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}
}

jwt的缺点

由于jwt是无状态的，而且token是在登录时生成的，所以会有以下两个问题

• 数据更新的问题，如果用户信息发生变更，但是token解析的还是老数据
• token一旦签发无法收回和废弃。