前文再续，上一回我们完成了用户的登录逻辑，将之前用户管理模块中添加的用户账号进行账号和密码的校验，过程中使用图形验证码强制进行人机交互，防止账号的密码被暴力破解。本回我们需要为登录成功的用户生成Token，并且通过Iris的中间件(Middleware)进行鉴权操作。

Iris模板复用

在生成Token之前，首先我们需要对项目的模板进行优化改造，目前存在的页面模板有三块，分别是：首页模板(index.html)、登录页模板(signin.html)、后台用户管理页模板(/admin/user.html)，虽然页面并不多，但不难发现，有很多重复的代码，比方说，首页模板和登录页模板都有公共的头部导航菜单，没必要每个模板都写一遍相同的代码，再比如，三块模板都会有axios的封装逻辑，也没必要三块模板封装三次，除此之外，以后模板多了，不做复用，就会出现维护困难的问题。

首先提取页面模板的公共部分，比如头部导航，在views目录建立header.html:

随后，在需要头部导航的模板进行引入操作，比如修改signin.html:

${ render "header.html" }

注意，使用${}是为了避免和前端的Vue.js标签冲突。

同样地，将封装axios.js逻辑单独抽取出来myaxios.html:

然后在需要的地方进行引入操作：

${ render "myaxios.html" }

如此，我们只需要维护模板的公共部分即可。

修改后，项目的结构如下：

.
  README.md
  assets
      css
          style.css
      js
          axios.js
          vue.js
  database
      database.go
  favicon.ico
  go.mod
  go.sum
  handler
      admin.go
      user.go
  main.go
  model
      model.go
  mytool
      mytool.go
  tmp
      runner-build
  views
      admin
          user.html
      admin_header.html
      header.html
      index.html
      myaxios.html
      signin.html
      test.html

JWT生成逻辑

JSON Web Token (JWT)是一个互联网应用的开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息，这种信息可以被验证和信任，因为它是数字签名的。

说白了，登录成功以后，生成一个 JSON 对象，返回给前端，就像下面这样：

{
"uid":1
}

这之后，用户与服务端通信的时候，所有请求都要带着这个JSON 对象。服务器完全只靠这个对象认定用户身份。为了防止JSON对象被篡改，服务器在生成这个对象的时候，会加上签名，变成这种模样：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVaWQiOjEsImlhdCI6MTY2MTg0MjYxMCwiZXhwIjoxNjYxODQ1NjEwfQ.BXK9awvVCk7L3JAnDGt9z6U9TOjPCpI0AcHRu1eq_mo

这玩意就是普遍意义上的Token，俗称“令牌”。

在我们的项目中，需要为登录校验通过的账号生成Token，首先安装jwt包：

go get -u github.com/kataras/iris/v12/middleware/jwt

随后修改本地的工具包mytool.jwt:

package mytool

import (
	"crypto/md5"
	"fmt"
	"io"
	"time"

	"github.com/dchest/captcha"
	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/middleware/jwt"
)


var SigKey = []byte("signature_hmac_secret_shared_key")

type PlayLoad struct {
	Uid uint
}

func GenerateToken(uid uint) string {

	signer := jwt.NewSigner(jwt.HS256, SigKey, 50*time.Minute)
	claims := PlayLoad{Uid: uid}

	token, err := signer.Sign(claims)
	if err != nil {
		fmt.Println(err)

	}

	s := string(token)

	return s

}

众所周知，Token由三部分组成：头部、载荷以及秘钥。这里SigKey字符为签名秘钥，PlayLoad结构体为载荷信息，这里通过签名生成一个字符格式的token，注意返回前端时，需要强转为字符串。

需要注意的是，生成签名时使用的是HS256算法，同时为了确保安全性，token设置生命周期，这里为50分钟。

随后修改用户登录逻辑，将生成好的token返回给前端：

//登录动作
func Signin(ctx iris.Context) {

	ret := make(map[string]interface{}, 0)

	cid := ctx.PostValue("cid")
	code := ctx.PostValue("code")

	if captcha.VerifyString(cid, code) == false {

		ret["errcode"] = 2
		ret["msg"] = "登录失败,验证码错误"
		ctx.JSON(ret)
		return

	}

	db := database.Db()
	defer func() {
		_ = db.Close()
	}()

	Username := ctx.PostValue("username")
	Password := ctx.PostValue("password")

	user := &model.User{}

	db.Where(&model.User{Username: Username, Password: mytool.Make_password((Password))}).First(&user)

	if user.ID == 0 {

		ret["errcode"] = 1
		ret["msg"] = "登录失败,账号或者密码错误"
		ctx.JSON(ret)
		return

	}

	token := mytool.GenerateToken(user.ID)

	fmt.Println(token)

	ret["errcode"] = 0
	ret["msg"] = "登录成功"
	ret["username"] = user.Username
	ret["token"] = token
	ctx.JSON(ret)

}

前端接收的返回值为：

{
    "errcode": 0,
    "msg": "登录成功",
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVaWQiOjEsImlhdCI6MTY2MTg0MzI5MSwiZXhwIjoxNjYxODQ2MjkxfQ.547z3nv4qj2-UeHTzfeG_qSsnFZD2DFyCP9gNZ-QiHA",
    "username": "123"
}

随后前端收到token后，将其存储localstorage，然后跳转到后台页面：

//登录请求
                signin:function(){


                    this.myaxios("http://localhost:5000/signin/","post",{"username":this.username,"password":this.password,"cid":this.cid,"code":this.code}).then(data => {
                        console.log(data)
                        alert(data.msg);

                        localStorage.setItem("token",data.token);

                        window.location.href = "/admin/user/"

                    });

                }

localStorage存储是永久的，如果对安全性要求较高，可以采用sessionStorage，token生命周期就会跟随浏览器进程，但之前设置的token生命周期就没意义了，各有利弊，各自权衡。

中间件(Middleware)鉴权

所谓中间件，是一类提供系统软件和应用软件之间连接、便于软件各部件之间的沟通的软件，应用软件可以借助中间件在不同的技术架构之间共享信息与资源。

说白了，就是在所有需要鉴权的接口前面加一层逻辑，便于批量管理和控制：

verifier := jwt.NewVerifier(jwt.HS256, mytool.SigKey)
	

	verifyMiddleware := verifier.Verify(func() interface{} {

		return new(mytool.PlayLoad)
	})

这里声明中间件变量verifyMiddleware，该变量会返回一个载荷结构体对象。

随后，为所有的后台接口、包括后台模板添加中间件：

adminhandler := app.Party("/admin")
	

	adminhandler.Use(verifyMiddleware)

	adminhandler.Get("/userlist/", handler.Admin_userlist)
	adminhandler.Delete("/user_action/", handler.Admin_userdel)
	adminhandler.Put("/user_action/", handler.Admin_userupdate)
	adminhandler.Post("/user_action/", handler.Admin_useradd)
	adminhandler.Get("/user/", handler.Admin_user_page)

如此，所有后台操作都需要中间件的鉴权操作。

换句话说，如果请求地址中没有token或者token不合法，就不会返回正常数据。

访问：http://localhost:5000/admin/user 如图所示：

如果带着token:

当然了，之后所有的后台请求都需要携带token，所以改造上面封装的myaxios.html:

藉此，每个后端请求都会携带token。

结语

JWT形式的认证体系将用户状态分散到了客户端中，相比于服务端的session存储，可以明显减轻服务端的内存压力，此外，使用Iris中间件鉴权的方式有助于提高代码的重用性，也更便于维护，更加优雅。该项目已开源在Github：https://github.com/zcxey2911/IrisBlog ，与君共觞，和君共勉。