项目地址：github

概述

这一节我们将实现用户的注册登录,以及关注的后台功能

定义用户模型

在model目录下新建user.go文件。我们将和user相关的结构体都定义在里面。

package model

import "time"

type Gender int

const (
    Man Gender = iota + 1
    Woman
    Unknown
)

type UserState int

const (
    Unsigned UserState = iota + 1
    Normal
    Forbidden
    Freeze
)

type User struct {
    Id        uint64     `graphql:"id"`
    Username  string     `graphql:"username"`
    Email     string     `graphql:"email"`
    Password  string     `graphql:"-"`
    Avatar    string     `graphql:"avatar"`
    Gender    Gender     `graphql:"gender"`
    Introduce *string    `graphql:"introduce"`
    State     UserState  `graphql:"state"`
    Root      bool       `graphql:"root"`
    CreatedAt time.Time  `graphql:"createdAt"`
    UpdatedAt time.Time  `graphql:"updatedAt"`
    DeletedAt *time.Time `graphql:"deletedAt"`
    Count     UserCount  `graphql:"-"`
}

type UserCount struct {
    Uid        uint64    `graphql:"-"`
    FansNum    int       `graphql:"fansNum"`
    FollowNum  int       `graphql:"followNum"`
    ArticleNum int       `graphql:"articleNum"`
    Words      int       `graphql:"words"`
    LikeNum    int       `graphql:"likeNum"`
    CreatedAt  time.Time `graphql:"-"`
    UpdatedAt  time.Time `graphql:"-"`
    DeletedAt  time.Time `graphql:"-"`
}

type UserFollow struct {
    Id        int64     `graphql:"-"`
    Uid       int64     `graphql:"-"`
    Fuid      int64     `graphql:"-"`
    CreatedAt time.Time `graphql:"createdAt"`
    UpdatedAt time.Time `graphql:"updatedAt"`
    DeletedAt *time.Time `graphql:"deletedAt"`
}

可以看到，我们使用了tag:graphql来标识结构体中字段在GraphQL中的命名，其中"-"表示忽略该字段。

在User的定义中，Introduce和DeletedAt使用了指针，这是因为在graphql库中，对于字段可以为空或者非空的判定，正是根据是否是指针类型来判断的。

graphql库中的GraphQL类型，大多与Go中类型保持一致，比如int，string这种类型，因为在Go中不可能为空，所以映射到GraphQL中时也是非空类型。若需要定义一个空的基本类型，需要使用指针。

将用户模型映射到GraphQL中

我们刚刚定义了关于用户的三个结构体，那么如何将这些模型在GraphQL中体现呢？
首先，我们需要在handler目录下，新建graphql.go文件，用来整合处理所有的模型注册事件。

package resolve

func Register(){
    
}

现在graphql中只有一个空的Register函数。我们需要为它添加内容。在同级目录下新建user.go文件。

package resolve

import "github.com/shyptr/graphql/schemabuilder"

func registerUser(schema *schemabuilder.Schema) {

}

schema正是graphql中用于将我们定义好的数据类型映射到GraphQL中的媒介。

我们先来分析一下，对于用户数据而言，如果我们要从前端界面获取用户数据，需要哪些数据。如下列了在简书项目中，我们要使用到的数据。

• 用户基本信息，Id，用户名，头像，邮箱等
• 用户计数，包括文章数，粉丝数等
• 用户关系网，譬如粉丝列表，关注列表
• 用户发表的内容，文章，评论等

由于我们现在只涉及用户，所有文章评论等暂不考虑。那么接下来就该注册这些数据到GraphQL中了。

修改handler.user.go。

func registerUser(schema *schemabuilder.Schema) {
    // 枚举类型映射
    schema.Enum("Gender", model.Gender(0), map[string]model.Gender{
        "Man":     model.Man,
        "Woman":   model.Woman,
        "Unknown": model.Unknown,
    })
    schema.Enum("UserState", model.UserState(0), map[string]model.UserState{
        "Unsigned":  model.Unsigned,
        "Forbidden": model.Forbidden,
        "Freeze":    model.Freeze,
    })
    // 将user结构体映射到graphql
    user := schema.Object("User", model.User{})
    // 粉丝数，关注数，文章数，字数，被点赞数
    user.FieldFunc("FansNum", func(u model.User) int { return u.Count.FansNum })
    user.FieldFunc("FollowNum", func(u model.User) int { return u.Count.FollowNum })
    user.FieldFunc("ArticleNum", func(u model.User) int { return u.Count.ArticleNum })
    user.FieldFunc("Words", func(u model.User) int { return u.Count.Words })
    user.FieldFunc("LikeNum", func(u model.User) int { return u.Count.LikeNum })
    // 粉丝列表
    user.FieldFunc("Fans", func() []model.User { return nil })
    // 关注列表
    user.FieldFunc("Followed", func() []model.User { return nil })

    query := schema.Query()
    // 获取用户信息
    query.FieldFunc("User", func() model.User { return model.User{} })
}

Enum将我们定义的枚举类型，转换成字符类型的枚举值列表在GraphQL中展示。

在graphql中，结构体被定义为Object，对于tag:graphql不为"-"的字段，graphql会自动处理，无需单独定义。
而像粉丝数，粉丝列表这样的字段，则需要调用object的FieldFunc方法进行注册。该方法第一个参数是这个字段的名称，第二个参数则是这个字段的解析函数。
这里粉丝列表和关注列表，我们没有准备在这里实现解析函数的逻辑。handler中应该只是像路由一样，作为转发，对于复杂逻辑，应该在resolve中单独定义。

对于用户数据的获取，这里就定义完了。剩下的就是对用户的动作的定义。

• 注册
• 登录
• 关注
• 取消关注

这就是我们这一节的大头了。仍然修改handler.user.go文件,添加内容。

mutation := schema.Mutation()
// 注册
mutation.FieldFunc("SignUp", func() model.User { return model.User{} })
// 登录
mutation.FieldFunc("SingIn", func() model.User { return model.User{} })
// 关注
mutation.FieldFunc("Follow", func() {})
// 取消关注
mutation.FieldFunc("UnFollow", func() {})

修改handler.graphql.go文件。

func Register(){
    schema:=schemabuilder.NewSchema()
    registerUser(schema)
}

编写解析函数

现在我们终于要和数据库打交道了。

我们在前面定义了一个查询单个用户的query字段，用户的信息在定义中，包括基本信息，计数，关注与被关注情况。

我们修改model.user.go文件，添加如下内容。

func GetUser(tx *sqlog.DB, id uint64, username, email string) (User, error) {
    rows, err := PSql.Select("id,username,email,password,avatar,gender,introduce,state,root,created_at,updated_at,deleted_at").
        From(`"user"`).
        Where("deleted_at is null").
        WhereExpr(
            sqlex.IF{id != 0, sqlex.Eq{"id": id}},
        ).
        WhereExpr(
            sqlex.Or{
                sqlex.IF{username != "", sqlex.Eq{"username": username}},
                sqlex.IF{email != "", sqlex.Eq{"email": email}},
            },
        ).
        RunWith(tx).Query()
    if err != nil {
        return User{}, err
    }
    var user User
    defer rows.Close()
    if rows.Next() {
        err := rows.Scan(&user.Id, &user.Username, &user.Email, &user.Password, &user.Avatar, &user.Gender, &user.Introduce, &user.State,
            &user.Root, &user.CreatedAt, &user.UpdatedAt, &user.DeletedAt)
        if err != nil {
            return user, err
        }
    }
    return user, nil
}

func GetUserCount(tx *sqlog.DB, id uint64) (UserCount, error) {
    rows, err := PSql.Select("fans_num,follow_num,article_num,words,like_num").
        From("user_count").
        Where("uid=$1", id).
        Where("deleted_at is null").
        RunWith(tx).Query()
    if err != nil {
        return UserCount{}, err
    }
    var c UserCount
    defer rows.Close()
    if rows.Next() {
        err := rows.Scan(&c.FansNum, &c.FollowNum, &c.ArticleNum, &c.Words, &c.LikeNum)
        if err != nil {
            return c, err
        }
    }
    return c, nil
}

func GetUserFollower(tx *sqlog.DB, id uint64) ([]uint64, error) {
    rows, err := PSql.Select("fuid").
        From("user_follow").
        Where("uid=$1", id).
        Where("deleted_at is null").
        RunWith(tx).Query()
    if err != nil {
        return nil, err
    }
    var fs []uint64
    defer rows.Close()
    for rows.Next() {
        var f uint64
        err := rows.Scan(&f)
        if err != nil {
            return nil, err
        }
        fs = append(fs, f)
    }
    return fs, nil
}

func GetFollowUser(tx *sqlog.DB, id uint64) ([]uint64, error) {
    rows, err := PSql.Select("uid").
        From("user_follow").
        Where("fuid=$1", id).
        Where("deleted_at is null").
        RunWith(tx).Query()
    if err != nil {
        return nil, err
    }
    var fs []uint64
    defer rows.Close()
    for rows.Next() {
        var f uint64
        err := rows.Scan(&f)
        if err != nil {
            return nil, err
        }
        fs = append(fs, f)
    }
    return fs, nil
}

在resolve下新建user.go文件。

package resolve

import (
    "context"
    "fmt"
    "github.com/shyptr/jianshu/model"
    "github.com/shyptr/jianshu/util"
)

type userResolver struct{}

var UserResolver userResolver

type idArgs struct {
    Id int64 `graphql:"id"`
}

// 根据用户ID查询用户信息
func (u userResolver) User(ctx context.Context, args idArgs) (model.User, error) {
    logger := util.GetLogger()
    defer util.PutLogger(logger)
    user, err := model.GetUser(args.Id)
    if err != nil {
        logger.Error().Caller().Err(err).Send()
        return model.User{}, fmt.Errorf("查询用户信息失败")
    }
    count, err := model.GetUserCount(args.Id)
    if err != nil {
        logger.Error().Caller().Err(err).Send()
        return model.User{}, fmt.Errorf("查询用户信息失败")
    }
    user.Count = count
    return user, nil
}

// 粉丝列表
func (u userResolver) Followers(ctx context.Context, user model.User) ([]model.User, error) {
    logger := ctx.Value("logger").(zerolog.Logger)
    tx := ctx.Value("tx").(*sqlog.DB)

    ids, err := model.GetUserFollower(tx, user.Id)
    if err != nil {
        logger.Error().Caller().Err(err).Send()
        return nil, fmt.Errorf("查询用户信息失败")
    }
    var users []model.User
    for _, id := range ids {
        user, err := u.User(ctx, IdArgs{id})
        if err != nil {
            return nil, err
        }
        users = append(users, user)
    }
    return users, nil
}

// 关注列表
func (u userResolver) Follows(ctx context.Context, user model.User) ([]model.User, error) {
    logger := ctx.Value("logger").(zerolog.Logger)
    tx := ctx.Value("tx").(*sqlog.DB)

    ids, err := model.GetFollowUser(tx, user.Id)
    if err != nil {
        logger.Error().Caller().Err(err).Send()
        return nil, fmt.Errorf("查询用户信息失败")
    }
    var users []model.User
    for _, id := range ids {
        user, err := u.User(ctx, IdArgs{id})
        if err != nil {
            return nil, err
        }
        users = append(users, user)
    }
    return users, nil
}

关于查询的逻辑，都很简单，没有可以多说的。重点还是接下来的注册和登录。
唯一需要注意的是，关注列表和粉丝列表，由于在GraphQL中是属于User的字段，所以id的参数并不需要从客户端传入，而是从source获取。
在这里source就是我们通过query查询到的User结构体了，所以在函数参数处，我们没有使用args，而是用了user model.Use。

修改model.user.go文件，添加内容如下。

type UserArg struct {
    Username string `graphql:"username" validate:"min=6,max=16"`
    Email    string `graphql:"email" validate:"email"`
    Password string `graphql:"password" validate:"min=8"`
    Avatar   string `graphql:"-"`
}

func InsertUser(tx *sqlog.DB, arg UserArg) (uint64, error) {
    id, err := idfetcher.NextID()
    if err != nil {
        return id, err
    }
    result, err := PSql.Insert(`"user"`).
        Columns("id,username,email,password,avatar").
        Values(id, arg.Username, arg.Email, arg.Password,arg.Avatar).
        RunWith(tx).Exec()
    if err != nil {
        return id, err
    }
    affected, _ := result.RowsAffected()
    if affected == 0 {
        return id, fmt.Errorf("保存用户信息失败")
    }
    return id, nil
}

func InsertUserCount(tx *sqlog.DB, id uint64) error {
    result, err := PSql.Insert("user_count").Columns("uid").Values(id).RunWith(tx).Exec()
    if err != nil {
        return err
    }
    affected, _ := result.RowsAffected()
    if affected == 0 {
        return fmt.Errorf("保存用户信息失败")
    }
    return nil
}

func InsertUserFollow(tx *sqlog.DB, uid uint64, fuid uint64) error {
    id, err := idfetcher.NextID()
    if err != nil {
        return err
    }
    result, err := PSql.Insert("user_follow").Columns("id,uid,fuid").Values(id, uid, fuid).RunWith(tx).Exec()
    if err != nil {
        return err
    }
    affected, _ := result.RowsAffected()
    if affected == 0 {
        return fmt.Errorf("关注失败")
    }
    return nil
}

func DeleteUserFollow(tx *sqlog.DB, id uint64, fuid uint64) error {
    result, err := PSql.Update("user_follow").
        Set("deleted_at", time.Now()).
        Where(sqlex.Eq{"uid": id, "fuid": fuid}).
        RunWith(tx).Exec()

    if err != nil {
        return err
    }
    affected, _ := result.RowsAffected()
    if affected == 0 {
        return fmt.Errorf("取消关注失败")
    }
    return nil
}

我们这里先写注册登录的逻辑。

修改resolve/user.go文件，新增内容。

// 注册
func (u userResolver) SingUp(ctx context.Context, args model.UserArg) (user model.User, err error) {
    logger := ctx.Value("logger").(zerolog.Logger)
    tx := ctx.Value("tx").(*sqlog.DB)

    err = u.ValidUsername(ctx, usernameArg{Username: args.Username})
    if err != nil {
        return model.User{}, err
    }
    err = u.ValidEmail(ctx, emailArg{Email: args.Email})
    if err != nil {
        return model.User{}, err
    }

    // 密码加密
    password, err := bcrypt.GenerateFromPassword([]byte(args.Password), 10)
    if err != nil {
        logger.Error().Caller().Err(err).Send()
        return model.User{}, errors.New("注册失败")
    }

    args.Password = string(password)
    id, err := model.InsertUser(tx, args)
    if err != nil {
        logger.Error().Caller().Err(err).Send()
        return model.User{}, errors.New("注册失败")
    }
    err = model.InsertUserCount(tx, id)
    if err != nil {
        logger.Error().Caller().Err(err).Send()
        return model.User{}, errors.New("注册失败")
    }

    // TODO:邮箱验证

    user, _ = model.GetUser(tx, id, "", "")
    return user, nil
}

func (u userResolver) SignIn(ctx context.Context, args struct {
    Username   string `graphql:"username"` // 邮箱或者用户名
    Password   string `graphql:"password"`
    RememberMe bool   `graphql:"rememberme"`
}) (user model.User, err error) {
    // 验证账号密码
    logger := ctx.Value("logger").(zerolog.Logger)
    tx := ctx.Value("tx").(*sqlog.DB)

    user, err = model.GetUser(tx, 0, args.Username, args.Username)
    if err != nil {
        logger.Error().Caller().AnErr("登录失败", err).Send()
        return model.User{}, errors.New("登录失败")
    }

    if user.Id == 0 {
        return model.User{}, errors.New("用户不存在！")
    }

    // 验证密码
    err = bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(args.Password))
    if err != nil {
        return model.User{}, err
    }

    // 生成token，并设置cookie
    var age int
    if args.RememberMe {
        age = 7 * 24
    }
    token, err := util.GeneraToken(user.Id, age)
    if err != nil {
        logger.Error().Caller().AnErr("生成token失败", err).Send()
        return model.User{}, errors.New("登录失败")
    }
    c := ctx.(*graphql.Context)
    http.SetCookie(c.Writer, &http.Cookie{
        Name:    "me",
        Value:   token,
        Path:    "/",
        Expires: time.Now(),
        MaxAge:  int(time.Hour) * age,
    })
    return user, nil
}

在注册时，我们对用户名和邮箱进行了一次唯一性校验。同时也可以看到我们在model.UserArg上增加了validate的tag。
这是因为graphql默认引入了validator库，用于参数的校验。当然，validate的使用需要手动开启，默认情况下是不开启的。

注册时，简书项目使用了Go的扩展库golang.org/x/crypto下的bcrypt包。bcrypt包使用base64编码，实现了Provos和Mazières的bcrypt自适应散列算法。
该算法的具体内容可以看这篇论文《A Future-Adaptable Password Scheme》
。可以看到，我们在加密的时候传了一个10到GenerateFromPassword函数中。这里可以理解为表示该密码被破译需要花费的代价。
这个cost值越高，加密就越复杂，越难以破解。当然相应的，加密的过程耗费的时间也越长，使用时应权衡好具体数值。

登录最主要的就是session的管理。关于token，session，cookie的区别，这里不多赘述，网上已经有很多详解了。在这里，我们使用了jwt-go库。
将用户的Id作为session信息，通过加密得到token，并将token存入客户端的cookie中。即我们的session信息，是通过cookie存储的。

最后是关注与取消关注的解析函数，修改resolve/user.go。

// 关注
func (u userResolver) Follow(ctx context.Context, args struct {
    Id uint64 `graphql:"id"`
}) error {
    logger := ctx.Value("logger").(zerolog.Logger)
    tx := ctx.Value("tx").(*sqlog.DB)

    userId := ctx.Value("userId").(uint64)
    err := model.InsertUserFollow(tx, args.Id, userId)
    if err != nil {
        logger.Error().Caller().AnErr("关注失败", err).Send()
        return errors.New("关注失败")
    }
    // TODO: 发送通知
    return nil
}

// 取消关注
func (u userResolver) CancelFollow(ctx context.Context, args struct {
    Id uint64 `graphql:"id"`
}) error {
    logger := ctx.Value("logger").(zerolog.Logger)
    tx := ctx.Value("tx").(*sqlog.DB)

    userId := ctx.Value("userId").(uint64)
    err := model.DeleteUserFollow(tx, args.Id, userId)
    if err != nil {
        logger.Error().Caller().AnErr("取消关注失败", err).Send()
        return errors.New("取消关注失败")
    }
    
    return nil
}

将复杂解析函数注册到GraphQL对应字段

现在我们的业务逻辑都在解析函数中编写完成了。接下来就要将这些函数注册到对应的字段上去。

修改handler/user.go文件。

func registerUser(schema *schemabuilder.Schema) {
    // 枚举类型映射
    schema.Enum("Gender", model.Gender(0), map[string]model.Gender{
        "Man":     model.Man,
        "Woman":   model.Woman,
        "Unknown": model.Unknown,
    })
    schema.Enum("UserState", model.UserState(0), map[string]model.UserState{
        "Unsigned":  model.Unsigned,
        "Forbidden": model.Forbidden,
        "Freeze":    model.Freeze,
    })
    // 将user结构体映射到graphql
    user := schema.Object("User", model.User{})
    // 粉丝数，关注数，文章数，字数，被点赞数
    user.FieldFunc("FansNum", func(u model.User) int { return u.Count.FansNum })
    user.FieldFunc("FollowNum", func(u model.User) int { return u.Count.FollowNum })
    user.FieldFunc("ArticleNum", func(u model.User) int { return u.Count.ArticleNum })
    user.FieldFunc("Words", func(u model.User) int { return u.Count.Words })
    user.FieldFunc("LikeNum", func(u model.User) int { return u.Count.LikeNum })
    // 粉丝列表
    user.FieldFunc("Fans", resolve.UserResolver.Followers)
    // 关注列表
    user.FieldFunc("Followed", resolve.UserResolver.Follows)

    query := schema.Query()
    // 获取用户信息
    query.FieldFunc("User", resolve.UserResolver.User)

    mutation := schema.Mutation()
    // 注册
    mutation.FieldFunc("SignUp", resolve.UserResolver.SingUp, middleware.BasicAuth(), middleware.LoginNeed())
    // 登录
    mutation.FieldFunc("SingIn", resolve.UserResolver.SignIn, middleware.BasicAuth(), middleware.NotLogin())
    // 关注
    mutation.FieldFunc("Follow", resolve.UserResolver.Follow, middleware.BasicAuth(), middleware.LoginNeed())
    // 取消关注
    mutation.FieldFunc("UnFollow", resolve.UserResolver.CancelFollow, middleware.BasicAuth(), middleware.LoginNeed())
}

启动GraphiQL

现在我们在main方法中调用handler的Register方法。

修改handler/graphql.go文件。

func Register(mux *http.ServeMux) {
    builder := schemabuilder.NewSchema()
    registerUser(builder)
    schema, err := builder.Build()
    if err != nil {
        log.Fatalln(err)
    }

    introspection.AddIntrospectionToSchema(schema)

    mux.Handle("/", graphql.GraphiQLHandler("/graphql"))
    mux.Handle("/graphql", graphql.HTTPHandler(schema))
}

修改main函数。

handler.Register(mux)

命令启动项目。

go run cmd/jianshu/main.go 

最终效果如下。

作者个人博客地址：https://unrotten.org

作者微信公众号：

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