本文为社区首发签约文章，14天内制止转载，14天后未获授权制止转载，侵权必究！

前言

最近有许多小伙伴私信我：在学完Go根底后，想运用一个结构实战一个商业项目，可是又苦于不知道挑选什么结构，更不知道做什么商业项目。

为了处理咱们这些问题，我结合自己的项目经历，为咱们开源了一个简略易上手的Go电商前后台体系API，这个项目不仅有电商体系常用的功用点，还浓缩了我开发Go积累的一些经历。

这篇文章合适学完了Go根底，方案根据老练结构开发web项意图同学。

GoFrame简介

GoFrame是相似PHP-Laravel, Java-SpringBoot的Go企业级开发结构，是一个十分值得学习的Go结构。

之前写过文章介绍GoFrame为什么值得学习： # 十分合适PHP同学运用的GO结构：GoFrame，以及# 为什么我觉得GoFrame的garray比PHP的array还好用？

咱们能够阅读一下，添加运用GoFrame进阶实战的动力。

经历共享

我用GoFrame开发了不少商业项目，刚开始用的时分也有许多不顺手的当地，基本是一边看官方文档一边写项目。

跟着做的项目多了，遇到的问题多了，发现刚开始写的代码真实很烂。

这套开源代码不敢说多优雅，最少很标准，在这套源码根底上能够快速进行功用模块的开发，也封装了常用的东西类。

对咱们提高学习Go的效率，应该会有协助。

官方示例

官方根据最新的v2.x版别供给了示例，从以下视点演示了怎么快速建立单体API Service：

接口界说
路由注册
常量办理
控制器界说
数据库拜访
- 驱动引进
- 数据库装备
- dao代码生成
创立事务模型
供给服务接口
事务完结
- 依靠注入
- 添加引证
接口测试

官方的示例十分标准，可是过于简略。根底薄弱的小伙伴能够先实践官方示例，再实践我的电商项目。

进阶教程：电商前后台体系

作为入门级电商体系包含了常规的功用点，下面我要点说一下能学到技术上的知识点：

怎么运用gtoken完结单点登录？
怎么自界说中间件？
怎么自界说服务？
怎么界说路由组，明晰接口鸿沟？
怎么上传图片到云渠道？
怎么灵敏的设置查找条件？
怎么用一个项目，供给前后台的2套API接口？
怎么完结主动编译？
怎么运用shell脚本一键布置项目到长途服务器？

阐明：GoFrame的官方文档和示例能带你快速入门GoFrame结构和CLI东西的运用，不作为这篇文章的要点。

这篇文章的要点是：能带你更进一步，根据杰出的标准，开发比较杂乱的商业项目。下面就和我一同学习吧，文章最终我会共享给咱们这个项意图github地址以及对咱们学习有协助的文档材料。

先看目录

全体结构

要点看app目录

app目录是咱们要要点开发的部分

开始实战

提示：为了行文紧凑，便利咱们理解。与核心知识点无关的代码会直接省略或用会三个竖着的.简化。文章最终会供给GitHub地址，开源项目。

1. GToken完结单点登录

1. 检查自己的版别

首要，咱们要确定自己装置的gf版别，经过gf version指令就能够检查了。

留意：gtoken v1.5.0全面适配GoFrame v2.0.0 ; GoFrame v1.X.X 请运用GfToken v1.4.X相关版别

根据自己的版别装置合适的gtoken

2. 装置最新版gtoken

go get github.com/goflyfox/gtoken

3. 装置指定版别gtoken

@指定的版别号就能够了：

go get github.com/goflyfox/gtoken@v1.4.1

2. 自界说中间件

咱们以编写gtoken中间件为例，带咱们写一个自己的中间件：

在咱们的app/middleware目录下新建token.go文件

编写gtoken中间件的意图：

大局校验用户的登录状况
登录后的用户将用户名、id这类用户信息写入到Context上下中，便利大局调用
在中间件中统一进行账号判别，比方：是否被拉黑等判别操作

咱们来看详细的完结：

package middleware
const (
   CtxAccountId     = "account_id"     //token获取
    .
    .
    .
)
type TokenInfo struct {
   Id         int
   Name       string
    .
    .
    .
}
var GToken *gtoken.GfToken
var MiddlewareGToken = tokenMiddleware{}
type tokenMiddleware struct{}
func (s *tokenMiddleware) GetToken(r *ghttp.Request) {
   var tokenInfo TokenInfo
   token := GToken.GetTokenData(r)
   err := gconv.Struct(token.GetString("data"), &tokenInfo)
   if err != nil {
      response.Auth(r)
      return
   }
   //账号被冻住拉黑
   if tokenInfo.Status == 2 {
      response.AuthBlack(r)
      return
   }
   r.SetCtxVar(CtxAccountId, tokenInfo.Id)
    .
    .
    .
   r.Middleware.Next()
}

3. 注册中间件

咱们在app/system/frontend/ 目录下新建 router.go 文件，用来界说客户端的路由：

首要编写gtoken登录注册等办法
然后在路由文件中运用 group.Middleware() 把自界说的中间件注册到路由组中。
留意：不需求校验登录状况的接口写在 group.Middleware(middleware.MiddlewareGToken.GetToken) 之前，需求校验登录状况的写在之后。

package frontend
//前端项目登录
func Login() {
   // 发动gtoken
   middleware.GToken = &gtoken.GfToken{
      //都用默认的
      //Timeout:    gconv.Int(g.Cfg().Get("gtoken.timeout")) * gconv.Int(gtime.M),
      //MaxRefresh: 60 * 1000, //单位毫秒 登录1分钟后有恳求操作则主动改写token有用期
      CacheMode:  2,
      LoginPath:  "/frontend/sso/login",
      LogoutPath: "/frontend/sso/logout",
      AuthPaths:  g.SliceStr{},
      //AuthPaths:        g.SliceStr{"/backend"},
      AuthExcludePaths: g.SliceStr{},
      GlobalMiddleware: true, // 敞开大局拦截
      //MultiLogin:       g.Config().GetBool("gtoken.multi-login"),
      LoginBeforeFunc: frontendLogin.FrontendLogin.Login,
      LoginAfterFunc:  frontendLogin.FrontendLogin.LoginAfterFunc,
      LogoutAfterFunc: frontendLogin.FrontendLogin.Logout,
      AuthAfterFunc:   frontendLogin.FrontendLogin.AuthAfterFunc,
   }
   middleware.GToken.Start()
}
func Init(s *ghttp.Server) {
   Login()
   s.Group("/frontend/", func(group *ghttp.RouterGroup) {
      //不需求登录的
      //上传文件
      group.Group("upload/", func(group *ghttp.RouterGroup) {
         group.POST("img/", upload.Upload.Img)
      })
      //以下是需求登录的
      group.Middleware(middleware.MiddlewareGToken.GetToken)
      //登录账号相关
      group.Group("sso/", func(group *ghttp.RouterGroup) {
         group.POST("password/update", frontendLogin.FrontendLogin.UpdatePassword)
      })
   })
}

4. 自界说服务

细心的小伙伴现已发现了问题：在路由文件中写的 frontendLogin.FrontendLogin.Login是在哪里界说的呢？

没错，咱们界说成了服务。

咱们能够把登录注册这类通用的功用抽取出来，界说成通用的服务：

咱们创立 app/service/frontendLogin 目录，在这个目录下再依次创立:

define.go：用于界说登录注册需求的结构体
service.go：用于编写事务逻辑，比方校验登录暗码是否正确
api.go：用于供给接口，比方frontendLogin.FrontendLogin.Login便是在这儿界说的

define.go简化示例

package frontendLogin
type RegisterReq struct {
   Name         string `json:"name" v:"required#用户名必传"`
   PassWord     string `json:"password" v:"required-if:type,0|password#password必须传递|暗码限定在6-18位之间"`
   Avatar       string `json:"avatar"`
   Sex          int    `json:"sex"`
   Sign         string `json:"sign"`
   SecretAnswer string `json:"secret_answer"`
   UserSalt     string `json:"user_salt,omitempty"`
}
type AccessTokenRes struct {
   AccessToken string `json:"access_token"` //获取到的凭证
   ExpiresIn   int    `json:"expires_in"`   //凭证有用时间，单位：秒
}
.
.
.

service.go简化示例

package frontendLogin
import (
   "context"
    .
    .
    .
)
var service = frontendLoginService{}
type frontendLoginService struct {
}
.
.
.
//注册
func (s *frontendLoginService) Register(ctx context.Context, req *RegisterReq) (err error) {
   //查询用户名是否存在
   count, err := dao.UserInfo.Ctx(ctx).Where("name", req.Name).Count()
   if err != nil || count > 0 {
      return gerror.New("用户名已存在，请换个用户名注册账号吧")
   }
   UserSalt := grand.S(10)
   req.PassWord = library.EncryptPassword(req.PassWord, UserSalt)
   req.UserSalt = UserSalt
   //添加新用户
   _, err = dao.UserInfo.Ctx(ctx).Insert(req)
   if err != nil {
      return err
   }
   return
}
.
.
.

api.go简化示例

package frontendLogin
import (
   "github.com/goflyfox/gtoken/gtoken"
    .
    .
    .
)
var FrontendLogin = new(frontendLogin)
type frontendLogin struct {
}
//注册
func (s *frontendLogin) Register(r *ghttp.Request) {
   var data *RegisterReq
   if err := r.Parse(&data); err != nil {
      response.ParamErr(r, err)
   }
   err := service.Register(r.Context(), data)
   if err != nil {
      response.JsonExit(r, 0, "注册失败")
   } else {
      response.SuccessWithData(r, nil)
   }
}
.
.
.

好了，到这儿咱们就完结了gtoken的集成，并且自己编写了中间件，编写了服务。

对Gtoken完结原理感兴趣的小伙伴能够阅读这篇文章：# 经过阅读源码处理项目难题：GToken替换JWT完结SSO单点登录

下面再带咱们要点看一下前面说到的路由文件：

4.界说路由组，明晰接口鸿沟

建议咱们运用分组路由进行路由的办理，能让咱们的路由办理愈加的明晰标准。

咱们根据事务逻辑拆分路由组，比方下面代码中的产品办理，文章办理，点赞办理就很明晰。

能确保跟着项意图迭代也能在指定的路由组中进行办理，明晰接口鸿沟。

func Init(s *ghttp.Server) {
   Login()
   s.Group("/frontend/", func(group *ghttp.RouterGroup) {
      //产品
      group.Group("goods/", func(group *ghttp.RouterGroup) {
         group.POST("list/", goods.Goods.List)
         group.POST("detail/", goods.Goods.Detail)
         group.POST("category/", goods.Goods.Category)
      })
      //以下是需求登录的
      group.Middleware(middleware.MiddlewareGToken.GetToken)
      //文章
      group.Group("article/", func(group *ghttp.RouterGroup) {
         group.POST("add/", article.Article.Add)
         group.POST("update/", article.Article.Update)
         group.POST("delete/", article.Article.Delete)
         group.POST("list/", article.Article.List)      //全部文章列表
         group.POST("my/list/", article.Article.MyList) //我的文章列表
         group.POST("detail/", article.Article.Detail)  //文章概况
      })
      //点赞
      group.Group("praise/", func(group *ghttp.RouterGroup) {
         group.POST("add/", praise.Praise.Add)
         group.POST("delete/", praise.Praise.Delete)
         group.POST("list/", praise.Praise.List)
      })
   })
}

留意：我并没有严厉依照RESTful Api的标准设计接口，而是全部运用的POST恳求。这儿并没有严厉约束，运用什么API接口标准和结构、开发语言都没有联系，合适自己的便是最好的。

5. 上传图片到云渠道

咱们以上传图片到七牛云举例：

首要咱们运用goframe供给的r.GetUploadFiles(“file”) 上传文件到本地（假如布置到服务器，便是服务器的本地）
依照云渠道提示，装备相关的AKSK
将本地文件地址上传到云渠道
删去本地文件

下面的关键代码已加注释，AKSK等装备信息在 /config/config.toml 文件中装备

package upload
var Upload = uploadApi{}
type uploadApi struct{}
// Upload uploads files to /tmp .
func (*uploadApi) Img(r *ghttp.Request) {
   files := r.GetUploadFiles("file")
   dirPath := "/tmp/"
   names, err := files.Save(dirPath, true)
   if err != nil {
      r.Response.WriteExit(err)
   }
   for _, name := range names {
      localFile := dirPath + name
      bucket := g.Cfg().GetString("qiniu.bucket")
      key := name
      accessKey := g.Cfg().GetString("qiniu.accessKey")
      secretKey := g.Cfg().GetString("qiniu.secretKey")
      putPolicy := storage.PutPolicy{
         Scope: bucket,
      }
      mac := qbox.NewMac(accessKey, secretKey)
      upToken := putPolicy.UploadToken(mac)
      cfg := storage.Config{}
      // 空间对应的机房
      cfg.Zone = &storage.ZoneHuabei
      // 是否运用https域名
      cfg.UseHTTPS = true
      // 上传是否运用CDN上传加速
      cfg.UseCdnDomains = false
      // 构建表单上传的目标
      formUploader := storage.NewFormUploader(&cfg)
      ret := storage.PutRet{}
      // 可选装备
      putExtra := storage.PutExtra{
         Params: map[string]string{},
      }
      err = formUploader.PutFile(r.GetCtx(), &ret, upToken, key, localFile, &putExtra)
      if err != nil {
         response.FailureWithData(r, 0, err, "")
      }
      fmt.Println(ret.Key, ret.Hash)
      //删去本地文件
      err = os.Remove(localFile)
      if err != nil {
         g.Dump("删去本地文件失败：", err)
      }
      fmt.Println("删去本地文件成功", localFile)
      //回来数据
      response.SuccessWithData(r, g.Map{
         "url": g.Cfg().GetString("qiniu.url") + ret.Key,
      })
   }
}

6.怎么科学的写查找？

我来阐明一个经典的查找场景：

咱们有多个查找条件，这些查找条件非必传，传了哪些条件就命中哪些条件，怎么完结比较科学呢？

我的建议是运用map支撑set办法的特色，灵敏的设置查询条件，防止在声明的时分赋值，那么完结需求做杂乱的判别逻辑。

将查询条件封装为packListCondition办法，统一办理，便利多处复用。

func (s *goodsService) List(ctx context.Context, req *PageListReq) (res ListGoodsRes, err error) {
   //实例化map
   whereCondition := gmap.New()
   //很好的理解了map是引证类型的特色 在这个函数中为查询条件赋值
   packListCondition(req, whereCondition)
   //map是引证类型，在packListCondition函数中现已做了赋值操作，不需求在接纳回来值
   count, err := dao.GoodsInfo.Ctx(ctx).Where(whereCondition).Count()
   if err != nil {
      return
   }
   res.Count = count
   err = dao.GoodsInfo.Ctx(ctx).Where(whereCondition).OrderDesc("id").Page(req.Page, req.Limit).Scan(&res.List)
   if err != nil {
      return
   }
   return
}
func packListCondition(req *PageListReq, whereCondition *gmap.Map) {
   //运用map支撑set的特性 防止在声明的时分赋值，那么写需求做的判别太杂乱了。
   if req.Keyword != "" {
      whereCondition.Set(dao.GoodsInfo.Columns.DetailInfo+" like ", "%"+req.Keyword+"%")
   }
   if req.Name != "" {
      whereCondition.Set(dao.GoodsInfo.Columns.Name+" like ", "%"+req.Name+"%")
   }
   if req.Brand != "" {
      whereCondition.Set(dao.GoodsInfo.Columns.Brand+" like ", "%"+req.Brand+"%")
   }
}

7.供给2套API接口

咱们再来看一下目录结构，有个全体的知道：

app/system 目录是我为了在一个项目中，一同开发前后台体系，提高代码复用率而创立的。
除了app/system 目录，其他目录都是经过goframe的 gf东西生成出来的。
所以完结一个项目供给2套API接口的核心是：怎么在一个项目中发动两个服务，一同供给前后台项意图所需的接口API?

我是这么做的：在咱们main.go的入口文件中别离初始化前后台项意图路由文件，发动服务。

package main
import (
   "github.com/gogf/gf/frame/g"
   "shop/app/middleware"
   "shop/app/system/backend"
   "shop/app/system/frontend"
   _ "shop/boot"
   _ "shop/router"
)
func main() {
   s := g.Server()
   s.Use(middleware.Cors.CORS)
   //后台项目
   backend.Init(s)
   //前端项目
   frontend.Init(s)
   s.Run()
}

底层思路是：前后台项意图路由根据路由组区分是哪个渠道的接口。接口的内部逻辑，假如能够复用就复用；假如不能复用，是独立的功用就别离在system下的backend或者frontend下开发。

前台接口路由文件

func Init(s *ghttp.Server) {
   s.Group("/frontend/", func(group *ghttp.RouterGroup) {
   .
   .
   .
   }
}

后台接口路由文件

func Init(s *ghttp.Server) {
   s.Group("/backend/", func(group *ghttp.RouterGroup) {
   .
   .
   .
   }
}

小提示：假如你的需求只是开发一个项目，那么就能够把system目录砍掉，直接在原生目录下开发就能够了。

到这儿，咱们就完结了项意图全体建立和开发，感兴趣的小伙伴能够star、fork我开源到GitHub的项目源码：GitHub根据GoFrame建立的电商前后台体系API

8.主动编译

主动编译是goframe集成好的功用，咱们不需求去装置air，只需求运用如下指令就能够完结主动编译了：

gf run main.go

效果如下：

最终咱们经过编写shell脚本，完结项意图一键布置到长途服务器：

9.一键布置脚本

RED_COLOR='\E[1;31m'   #红
GREEN_COLOR='\E[1;32m' #绿
YELOW_COLOR='\E[1;33m' #黄
BLUE_COLOR='\E[1;34m'  #蓝
PINK='\E[1;35m'        #粉红
RES='\E[0m'
echo -e "${GREEN_COLOR}****根据GoFrame建立的电商前后台API体系：开始履行主动化布置****${RES}\n\n"
echo -e "${YELOW_COLOR}---step1:兼并代码---${RES}"
git pull origin master
echo -e "${BLUE_COLOR}兼并代码成功${RES}\n"
echo -e "${YELOW_COLOR}---step2:编译---${RES}"
go build
echo -e "${BLUE_COLOR}编译完结${RES}\n"
echo -e "${YELOW_COLOR}---step3:更改权限---${RES}"
chmod -R 777 shop
echo -e "${BLUE_COLOR}更改权限完结${RES}\n"
echo -e "${YELOW_COLOR}---step4:杀掉进程并且运转---${RES}"
i1=$(ps -ef | grep -E "shop" | grep -v grep | awk '{print $2}')
echo -e "${BLUE_COLOR}杀掉进程$i1${RES}\n"
kill -9 $i1 && nohup ./shop >/dev/null 2>&1 &
i2=$(ps -ef | grep -E "shop" | grep -v grep | awk '{print $2}')
echo -e "${GREEN_COLOR}****布置成功,布置的进程ID为:$i2${RES}****"

学习材料

下面是建议咱们着手实践的学习材料：

GitHub：根据GoFrame建立的电商前后台体系API

GoFrame学习专栏

GoFrame官方文档

Github：GoFrame入门官方示例项目

总结

经过这篇文章咱们根据GoFrame结构建立了一个电商体系的前后台API，实践了怎么集成gtoken完结登录，怎么自界说中间件和服务，怎么界说路由组，怎么上传文件到云渠道，以及在开发的过程中怎么完结主动编译，当项目开发完毕，怎么一键布置到长途服务器。

欢迎咱们着手实践，欢迎在谈论区探讨。

关于专栏

近期会更新一系列Go进阶实战的文章，欢迎咱们重视我的签约专栏 ：# Go语言进阶实战。

这是近期准备更新文章的知识脉络图，感兴趣的小伙伴能够重视一波，欢迎日常催更。

一同学习，晋级打怪

咱们搞了一个对学Go真实有协助的群，欢迎加入：

公众号：程序员晋级打怪之旅

微信号：wangzhongyang1993

【Go WEB进阶实战】基于GoFrame搭建的电商前后台API系统

前言

GoFrame简介

经历共享

官方示例

进阶教程：电商前后台体系

先看目录

全体结构

要点看app目录

开始实战

1. GToken完结单点登录

1. 检查自己的版别

2. 装置最新版gtoken

3. 装置指定版别gtoken

2. 自界说中间件

3. 注册中间件

4. 自界说服务

define.go简化示例

service.go简化示例

api.go简化示例

4.界说路由组，明晰接口鸿沟

5. 上传图片到云渠道

6.怎么科学的写查找？

7.供给2套API接口

前台接口路由文件

后台接口路由文件

8.主动编译

效果如下：

9.一键布置脚本

学习材料

总结

关于专栏

一同学习，晋级打怪

作者信息

推广

【Go WEB进阶实战】基于GoFrame搭建的电商前后台API系统

前言

GoFrame简介

经历共享

官方示例

进阶教程：电商前后台体系

先看目录

全体结构

要点看app目录

开始实战

1. GToken完结单点登录

1. 检查自己的版别

2. 装置最新版gtoken

3. 装置指定版别gtoken

2. 自界说中间件

3. 注册中间件

4. 自界说服务

define.go简化示例

service.go简化示例

api.go简化示例

4.界说路由组，明晰接口鸿沟

5. 上传图片到云渠道

6.怎么科学的写查找？

7.供给2套API接口

前台接口路由文件

后台接口路由文件

8.主动编译

效果如下：

9.一键布置脚本

学习材料

总结

关于专栏

一同学习，晋级打怪

相关文章

SpringBoot2.x系列教程49–SpringBoot整合Web Service实现远程接口调用

iOS依赖库版本一致性检测：确保应用兼容性

ELK搭建-生产级｜Java 开发实战

技术分享：可伸缩的精简化研发流程管理方案

作者信息

推广