Go 和 JWT 简单的身份验证

我目前正在制作一个API(使用Go)，我正在处理会话部分. 在研究了会话使用的内容之后，我发现JWT真的很有趣.

然而，经过一些教程之后，我不太确定如何使用它.

func main() {

    router := mux.NewRouter().StrictSlash(true)

    router.HandleFunc("/login", login)
    router.HandleFunc("/logout", logout)
    router.HandleFunc("/register", register)

    http.ListenAndServe(":8080", router)

 }

处理完这些请求后，我创建了不同的函数.

func login(w http.ResponseWriter, r *http.Request) {
    /*                                                                                                                                                                                                   
    Here I just have to search in my database (SQL, I know how to do it). If the user is registered, I create a token and give it to him, but how can I do it?                                           
    */
 }

 func logout(w http.ResponseWriter, r *http.Request) {
    /*                                                                                                                                                                                                   
    I get a token and stop/delete it?                                                                                                                                                                    
    */
 }

 func register(w http.ResponseWriter, r *http.Request) {
    /*                                                                                                                                                                                                   
    I search if the user isn't register and then, if it isn't, I create a user in the database (I know how to do it). I connect him but again, how to make a new token?                                  
    */
 }

网上的很多教程似乎真的很难，但我只想要一些简单的东西.我只想要一个句柄包(上面的代码)，它与服务包一起工作，以具有类似于引擎令牌身份验证的东西.

我不太明白的第二点是令牌的保存. 如果用户自己连接，那么什么才是最好的呢？用户每次运行他们的应用程序时，应用程序会自行连接并从保存的信息(用户/密码)中获得新的令牌，还是应用程序只是将令牌永久保存？那么服务器呢，令牌是使用JWT自动管理和保存的，还是必须将其放入我的SQL数据库中呢？

谢谢你的帮助！

EDIT 1

谢谢你！因此，在我阅读了您的答案之后，我将我的代码(token.go)封装为

package services

import (
    "fmt"
    "github.com/dgrijalva/jwt-go"
    "time"
    "../models"
)

var tokenEncodeString string = "something"

func createToken(user models.User) (string, error) {
    // create the token                                                                                                                                                                                  
    token := jwt.New(jwt.SigningMethodHS256)

    // set some claims                                                                                                                                                                                   
    token.Claims["username"] = user.Username;
    token.Claims["password"] = user.Password;
    token.Claims["exp"] = time.Now().Add(time.Hour * 72).Unix()

    //Sign and get the complete encoded token as string                                                                                                                                                  
    return (token.SignedString(tokenEncodeString))
}

func parseToken(unparsedToken string) (bool, string) {
    token, err := jwt.Parse(unparsedToken, func(token *jwt.Token) (interface{}, error) {
            // Don't forget to validate the alg is what you expect:                                                                                                                                      
            if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
                    return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
            }
            return myLookupKey(token.Header["kid"]), nil
    })

    if err == nil && token.Valid {
            return true, unparsedToken
    } else {
            return false, ""
    }
 }

但是，我收到以下错误:"token.go:unfined:myLookupKey" 我在互联网上查找，发现了一个封装的函数，其原型如下:

func ExampleParse(myToken string, myLookupKey func(interface{}) (interface{}, error)) {
 /* same code in my func parseToken() */
}

那么我的功能和这个有什么不同呢？这件怎么用呢？

谢谢！