1. 首页
  2. 主题
  3. Go语言
MartiniGo

用Go写后台系统API--记录心得

MartiniGo · 2018-11-04 23:24:55 · 14930 次点击 · 大约8小时之前 开始浏览    置顶
这是一个创建于 2018-11-04 23:24:55 的主题，其中的信息可能已经有所发展或是发生改变。
第一次，站长亲自招 Gopher 了>>>

Go写后台API

项目很渣，大佬可以提意见~~

技术栈

用的gin框架，登录验证使用jwt-go，权限管理是casbin，数据库使用mongodb

为什么要写这篇文章

因为想记录自己踩的坑，顺便记录心得。然后关于casbin这个库的使用资料很少,对于新手来说很难看明白，大神那肯定刷一遍就懂了。

正题

go操作mongodb 使用mgo这个包。因为项目不考虑并发 ，如果项目并发很高，我这样写肯定是不行的不建议参考，因为Session 会被全局使用，当在实际的程序中，我们可以开启goroutine 来处理每个连接，多个goroutine 可以通过 session.Clone() 来创建或复用连接，使用完成之后通过 session.Close() 来关闭这个连接。mongodb默认连接是4096，如果session使用后不close( )很容易堵塞。回到正题，将mgo的操作封装一下 ，名字为什么叫mongoose因为node有个操作mongo的叫这个还挺喜欢这个名字就用了。

package mongoose

import (
    "fmt"
    "log"

    "gopkg.in/mgo.v2"
)

//定义MongoDB 连接字符串
const (
    host   = "localhost:27017"
    source = "leaseapp"
    user   = "martin"
    pass   = "123456"
)

// 定义mongo session
var globalS *mgo.Session
var MongoUrl = host + "/" + source

//初始化连接MongoDB
func init() {
    dialInfo := &mgo.DialInfo{
        Addrs:    []string{host},
        Source:   source,
        Username: user,
        Password: pass,
    }
    session, err := mgo.DialWithInfo(dialInfo)
    if err != nil {
        log.Fatalln("create session error", err)
    }
    fmt.Println("MongoDB Connect")
    globalS = session
}

//连接MongoDB 返回一个session会话和一个集合c
func connect(db, collection string) (*mgo.Session, *mgo.Collection) {
    s := globalS.Copy()
    c := s.DB(db).C(collection)
    return s, c
}

//插入
func Insert(db, collection string, docs ...interface{}) error {
    ms, c := connect(db, collection)
    defer ms.Close()
    return c.Insert(docs...)
}

//查找某一个函数
func FindOne(db, collection string, query, selector, result interface{}) error {
    ms, c := connect(db, collection)
    defer ms.Close()
    return c.Find(query).Select(selector).One(result)
}

//是否存在
func IsExist(db, collection string, query interface{}) bool {
    ms, c := connect(db, collection)
    defer ms.Close()
    count, _ := c.Find(query).Count()
    return count > 0
}

//查找所有
func FindAll(db, collection string, query, selector, result interface{}) error {
    ms, c := connect(db, collection)
    defer ms.Close()
    return c.Find(query).Select(selector).All(result)
}

//更新
func Update(db, collection string, query, update interface{}) error {
    ms, c := connect(db, collection)
    defer ms.Close()
    return c.Update(query, update)
}

//删除
func Remove(db, collection string, query interface{}) error {
    ms, c := connect(db, collection)
    defer ms.Close()
    return c.Remove(query

然后写一下JWT ，JWT(Jason Web Token) 包含三部分 头部，载荷(Claims或Payload) ，签证，载荷里我们是可以放权限的。

//JWT签名结构
type JWT struct {
    SigningKey []byte
}
//载荷
type Customclaims struct {
    Empname string `json:"empname"`
    Phone   string `json:"phone"`
    Role    string `json:"role"`
    jwt.StandardClaims
}

然后写创建token 解析token 刷新token

//创建Token
func (j *JWT) CreateToken(claims Customclaims) (string, error) {
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString(j.SigningKey)
}

//解析token
func (j *JWT) ParseToken(tokenString string) (*Customclaims, error) {
    token, err := jwt.ParseWithClaims(tokenString, &Customclaims{}, func(token *jwt.Token) (interface{}, error) {
        return j.SigningKey, nil
    })
    if err != nil {
        if ve, ok := err.(*jwt.ValidationError); ok {
            if ve.Errors&jwt.ValidationErrorMalformed != 0 {
                return nil, TokenMalformed
            } else if ve.Errors&jwt.ValidationErrorExpired != 0 {
                // Token is expired
                return nil, TokenExpired
            } else if ve.Errors&jwt.ValidationErrorNotValidYet != 0 {
                return nil, TokenNotValidYet
            } else {
                return nil, TokenInvalid
            }
        }
    }
    if claims, ok := token.Claims.(*Customclaims); ok && token.Valid {
        return claims, nil
    }
    return nil, TokenInvalid
}

//更新Token
func (j *JWT) RefreshToken(tokenString string) (string, error) {
    jwt.TimeFunc = func() time.Time {
        return time.Unix(0, 0)
    }
    token, err := jwt.ParseWithClaims(tokenString, &Customclaims{}, func(token *jwt.Token) (interface{}, error) {
        return j.SigningKey, nil
    })
    if err != nil {
        return "", err
    }
    if claims, ok := token.Claims.(*Customclaims); ok && token.Valid {
        jwt.TimeFunc = time.Now
        claims.StandardClaims.ExpiresAt = time.Now().Add(1 * time.Hour).Unix()
        return j.CreateToken(*claims)
    }

    return "", TokenInvalid
}

`

最后一步就是写个验证token 的中间件

// JWTAuth 中间件，检查token
func JWTAuth() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.Request.Header.Get("token")
        if token == "" {
            c.JSON(http.StatusOK, gin.H{
                "status": -1,
                "msg":    "请求未携带token，无权限访问",
            })
            c.Abort()
            return
        }

        log.Print("get token: ", token)

        j := NewJWT()
        // parseToken 解析token包含的信息
        claims, err := j.ParseToken(token)
        if err != nil {
            if err == TokenExpired {
                c.JSON(http.StatusOK, gin.H{
                    "status": -1,
                    "msg":    "授权已过期",
                })
                c.Abort()
                return
            }
            c.JSON(http.StatusOK, gin.H{
                "status": -1,
                "msg":    err.Error(),
            })
            c.Abort()
            return
        }
        // 继续交由下一个路由处理,并将解析出的信息传递下去
        c.Set("claims", claims)
    }
}

然后搞model吧。首先弄个员工的model，员工肯定有增删改和查找，就简单先弄个增加和查找。有了查找在登录的时候可以直接通过用户名验证用户是否存在然后在进一步验证。

const (
    db         = "leaseapp"
    collection = "EmployeeModel"
)

type Employee struct {
    ID       bson.ObjectId `json:"id" bson:"_id"`
    Phone    string        `json:"phone" bson:"phone"`
    Password string        `json:"-" bson:"passoword"`
    EmpName  string        `json:"empname" bson:"empname"`
    Role     string        `json:"role" bson:"role"`
}

//新增用户
func (e *Employee) AddEmployee(emp Employee) error {
    return mongoose.Insert(db, collection, emp)
}

//查找用户
func (e *Employee) FindUserByPhone(phone string) (Employee, error) {
    var result Employee
    err := mongoose.FindOne(db, collection, bson.M{
        "phone": phone,
    }, nil, &result)
    return result, err
}

这里就差不多了。然后我们可以把得到的员工模型的数据塞进claims里面生成我们的token。然后登陆成功后我们返回一个token 和员工的一些信息

type LoginResult struct {
    Token string `json:"token"`
    model.Employee
}

//生成token
func GenerateToken(c *gin.Context, emp model.Employee) {
    j := &jwt.JWT{
        []byte("martin"),
    }
    claims := jwt.Customclaims{
        emp.EmpName,
        emp.Phone,
        emp.Role,
        jwtgo.StandardClaims{
            NotBefore: int64(time.Now().Unix() - 1000), //签名生效时间
            ExpiresAt: int64(time.Now().Unix() + 3600), //签名过期时间 一小时
            Issuer:    "martin",                        //签名发行者
        },
    }
    token, err := j.CreateToken(claims)
    if err != nil {
        c.JSON(http.StatusOK, gin.H{
            "status": -1,
            "msg":    err.Error(),
        })
    }
    log.Println(token)
    data := LoginResult{
        Token:    token,
        Employee: emp,
    }
    c.JSON(http.StatusOK, gin.H{
        "status": 0,
        "msg":    "登录成功",
        "data":   data,
    })
    return
}

差不多了。在写api的部分。负责添加员工 和登陆验证，首先得加个员工，不然怎么登陆。这里用bcrypt这个包来加密。注意的是加密后的类型是[]byte类型。mongodb是不支持这个类型的，所以要转一下string。后面再我们登录验证的时候也要注意这个问题就好了

func AddEmployee(c *gin.Context) {
    phonenum := c.PostForm("phone")
    pwd := c.PostForm("password")
    ename := c.PostForm("empname")
    emprole := c.PostForm("role")
    exit := mongoose.IsExist(db, collection, bson.M{"phone": phonenum})
    if exit {
        c.JSON(http.StatusInternalServerError, gin.H{
            "success": false,
            "msg":     "用户已存在",
        })
    } else {
        hashpwd, err := bcrypt.GenerateFromPassword([]byte(pwd), bcrypt.DefaultCost)
        if err != nil {
            log.Fatalln(err)
        }
        hashedpwd := string(hashpwd)
        employee := model.Employee{
            ID:       bson.NewObjectId(),
            Phone:    phonenum,
            Password: hashedpwd,
            EmpName:  ename,
            Role:     emprole,
        }
        err = dao.AddEmployee(employee)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{
                "success": false,
                "msg":     "保存失败",
            })
            return
        }
        c.JSON(http.StatusOK, gin.H{
            "success": true,
            "msg":     "保存成功",
        })
    }

}

然后添加完了 就可以登陆了。路由就很简单就不写了。后面会贴用完中间件和分组后的路由。写一个处理登录的函数,当用户名和密码都验证成功后我们把数据添加到generatetoken函数里生成token，

func Login(c *gin.Context) {
    phonenum := c.PostForm("phone")
    pwd := c.PostForm("password")
    emp := model.Employee{}
    exist := mongoose.IsExist(db, collection, bson.M{"phone": phonenum})
    if exist {
        result, err := emp.FindUserByPhone(phonenum)
        err = bcrypt.CompareHashAndPassword([]byte(result.Password), []byte(pwd))
        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{
                "success": false,
                "msg":     "用户名或密码错误",
            })
            return
        }
        gwt.GenerateToken(c, result)
    } else {
        c.JSON(http.StatusOK, gin.H{
            "status": -1,
            "msg":    "登录失败",
        })
    }
}

好像很长了。在开一篇把。。

有疑问加站长微信联系（非本文作者）

入群交流（和以上内容无关）：加入Go大咖交流群，或添加微信：liuxiaoyan-s 备注：入群；或加QQ群：692541889

14930 次点击  ∙  4 赞  
加入收藏 微博
赞
  • gin
  • mongodb
  • mgo
  • context
    9 回复  |  直到 2019-08-22 09:11:10
    暂无回复
    添加一条新回复 （您需要 登录 后才能回复 没有账号 ？）
    • 请尽量让自己的回复能够对别人有帮助
    • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
    • 支持 @ 本站用户；支持表情（输入 : 提示），见 Emoji cheat sheet
    • 图片支持拖拽、截图粘贴等方式上传

    用户登录

    Go今日面试题

     今日阅读排行

     一周阅读排行

      关注我

    • 扫码关注领全套学习资料 关注微信公众号
    • 加入 QQ 群：
      • 192706294（已满）
      • 731990104（已满）
      • 798786647（已满）
      • 729884609（已满）
      • 977810755（已满）
      • 815126783（已满）
      • 812540095（已满）
      • 1006366459（已满）
      • 692541889

    • 关注微信公众号
    • 加入微信群：liuxiaoyan-s，备注入群
    • 也欢迎加入知识星球 Go粉丝们（免费）