golang web开发

目录

文章目录

前言

一、golang web是什么？

二、搭建流程

1.模块划分

2.详细开发步骤

总结

前言

例如：习惯了java springboot 开发方式，比较疑惑golang web开发的流程和模块化的区分，

就golang web整个后台模块做下梳理。

一、golang web是什么？

   golang web是指 web后台HTTP接口开发模块。

二、搭建流程

1.模块划分

project
    -app       通常是程序启动后需要加载的数据
        app.go --加载gin 路由，指向 controller,并且做了拦截 heard token，解析放入上下文
    -biz       
       --model 
           --dto --请求的struct
           --entity --实体类
       --service   
    -common    公共常量，定义返回值 struct
       common.go
    -conf      配置信息，从配置文件里面读取到 struct
       config.go //根据环境变量读取环境resorce配置信息
    -controller  访问入口
       account_controller.go
    -resource  配置文件
       app.yml   配置数据库信息，根据 环境变量获取 取哪个配置文件
       app-dev.yml
       app-test.yml
       app-prod.yml 
    -util
     token_util.go 生成和解析token  
    -test      测试包，单元测试文件
    Dockerfile docker打包文件
    go.mod -go包管理
    main.go 启动入口

2.详细开发步骤

    相信大家看完前面的包，也有很多疑惑，该怎么开始呢？

    现在就一个包，一个包，把代码拆开来

1.     main.go 文件

import (
	"fmt"
	"app"
	"log"
)

func main() {
    //调用 app包里面的启动
	err := app.Run()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("go web start ..!")
}

1. 2.app包， 只有一个app.go 文件

• 使用gin路由，指向contoller包
• 使用util 包里面的解析 head里面的token,并把 解析后的userId,放入用户信息
• 处理跨域请求
• 初始化 dao 数据库连接

package app

import (
	"errors"
	"fmt"
     // 引入gin web插件
	"github.com/gin-gonic/gin"
    //引入mysql插件
	_ "github.com/go-sql-driver/mysql"
    //引入 http插件
   "net/http"


    //项目 自定义包
	"project/biz/dao"
	"project/biz/service"
	"ibc/common"
	"project/controller"
	"project/util"
	
)

func Run() error {
    //初始化数据库连接
	dao.InitDB()
	defer dao.CloseDB()
    //创建service
	accountService := service.NewAccountService()
	activitiesService := service.NewOfflineActivitiesService()

    //定义路由
	router := gin.Default()
	router.GET("/", homeEndpoint)    
	accountGroup := router.Group("/account")
	{
		accountCtl := controller.NewAccountController(accountService)
		accountGroup.POST("/", wrapHandler(accountCtl.InsertAccount))
		accountGroup.GET("/:userId", wrapHandler(accountCtl.FindAccount))
		accountGroup.GET("/account-flow/:accountId",                      wrapHandler(accountCtl.FindAccountFlow))
	}
	
	return router.Run(":8080")
}


type EndpointFunc func(*gin.Context) (any, error)

//定义返回
func homeEndpoint(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{"code": "SUCCESS"})
}


// 定义统一处理器
func wrapHandler(handler EndpointFunc) gin.HandlerFunc {
	return func(c *gin.Context) {
        // 处理跨域请求
		c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
		Cors(c)
       
         
		//从header 获取token,
		var token = c.GetHeader("token")
		//解析token,如果token不存在，或者 解析错误,则返回 没权限
		userId, err := util.TokenHandle(token)
		if err != nil {
			fmt.Errorf(err.Error())
			c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "token is invalid"})
			return
		}
         //解析后 userId 放入上下文中,后面的service服务，可以获取该用户信息
		c.Set("userId", userId)
		data, err := handler(c)
		if err != nil {
			var systemErr *common.Error
			if errors.As(err, &systemErr) {
				c.JSON(systemErr.Status, common.NewErrorResult(systemErr.Code, systemErr.Msg))
			} else {
				c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err.Error()})
			}
			return
		}
		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "data": data})
	}
}

//跨域请求处理
func Cors(context *gin.Context) {
	method := context.Request.Method
	// 必须，接受指定域的请求，可以使用*不加以限制，但不安全
	//context.Header("Access-Control-Allow-Origin", "*")
	context.Header("Access-Control-Allow-Origin", context.GetHeader("Origin"))
	fmt.Println(context.GetHeader("Origin"))
	// 必须，设置服务器支持的所有跨域请求的方法
	context.Header("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE, OPTIONS")
	// 服务器支持的所有头信息字段，不限于浏览器在"预检"中请求的字段
	context.Header("Access-Control-Allow-Headers", "Content-Type, Content-Length, Token")
	// 可选，设置XMLHttpRequest的响应对象能拿到的额外字段
	context.Header("Access-Control-Expose-Headers", "Access-Control-Allow-Headers, Token")
	// 可选，是否允许后续请求携带认证信息Cookir，该值只能是true，不需要则不设置
	context.Header("Access-Control-Allow-Credentials", "true")
	// 放行所有OPTIONS方法
	if method == "OPTIONS" {
		context.AbortWithStatus(http.StatusNoContent)
		return
	}
	context.Next()
}

2.dao包

• 初始化连接
• 业务dao层

  package dao
  
  import (
  	"fmt"
      //引入 sqlx  
  	"github.com/jmoiron/sqlx"
      //项目内的 配置信息
  	"project/conf"
  	"log"
  )
  
  var BaseDb sqlx.DB
  
  // app.go 里面调用
  func InitDB() {
  
  	datasource := fmt.Sprintf("%s:%s@tcp(%s)/%s?parseTime=true&charset=utf8", conf.Config.Mysql.User, conf.Config.Mysql.Passwd, conf.Config.Mysql.Host, conf.Config.Mysql.DBName)
  	db, err := sqlx.Open("mysql", datasource)
  	if err != nil {
  		log.Fatal(err)
  		return
  	}
  	BaseDb = *db
  	
  }
  
  // app.go 里面调用
  func CloseDB() {
  	err := BaseDb.Close()
  	if err != nil {
  		log.Fatal(err)
  	}
  }
  

  package dao
  
  import (
  	"database/sql"
  	"fmt"
  	"project/biz/model/entity"
  	"strings"
  )
  
  type UserAccountRepository interface {
  	Insert(account entity.UserAccount) error
  	Update(account entity.UserAccount) error
  	DeleteById(id string) (bool, error)
  	FindById(userId string) (entity.UserAccount, error)
  	ListAll() ([]entity.UserAccount, error)
  	ExistsByUserId(userId string) (error, bool)
  }
  type UserAccountFlowRepository interface {
  	Insert(accountFlow entity.UserAccountFlow) (int, error)
  	DeleteById(id string) (bool, error)
  	FindById(id string) (entity.UserAccountFlow, error)
  	ListAll() ([]entity.UserAccountFlow, error)
  	ListByAccountId(accountId string) (*[]entity.UserAccountFlow, error)
  	FindByActivities(id string, id2 int64) (*[]entity.UserAccountFlow, error)
  }
  
  type accountRepo struct {
  }
  
  type accountFlowRepo struct {
  }
  
  //NewAccountRepository 申明实现了 UserAccountRepository 接口
  func NewAccountRepository() UserAccountRepository {
  	return &accountRepo{}
  }
  
  //Insert  < 具体实现 NewAccountRepository
  func (u accountRepo) Insert(account entity.UserAccount) error {
  	sql := `insert into user_account(id,user_id,blockchain_address,balance)values(:id,:user_id,:blockchain_address,:balance)`
  	result, err := BaseDb.NamedExec(sql, &account)
  	if err != nil {
  		return err
  	}
  	fmt.Println(result)
  
  	return nil
  
  }
  func (u accountRepo) ExistsByUserId(userId string) (error, bool) {
  	sqlStr := `select * from user_account where user_id=?`
  	var account entity.UserAccount
  	err := BaseDb.Get(&account, sqlStr, userId)
  	if err == sql.ErrNoRows {
  		return nil, false
  	}
  	if err != nil {
  		return err, false
  	}
  	if account == (entity.UserAccount{}) {
  		return nil, true
  	}
  
  	return nil, false
  
  }
  
  //Update  < 具体实现 NewAccountRepository
  func (u accountRepo) Update(account entity.UserAccount) error {
  
  	sqlColum := `update user_account set `
  	if account.Balance >= -1 {
  		sqlColum += ` balance =:balance ,`
  	}
  	if account.BlockchainAddress != "" {
  		sqlColum += ` blockchain_address =:blockchain_address ,`
  	}
  	sqlColum = strings.TrimSuffix(sqlColum, ",")
  	sqlColum += " where id =:id "
  
  	_, err := BaseDb.NamedExec(sqlColum, &account)
  	return err
  
  }
  
  //DeleteById  < 具体实现 NewAccountRepository
  func (u accountRepo) DeleteById(id string) (bool, error) {
  	sql := "update user_account set is_delete=1 where id =?"
  	_, err := BaseDb.Exec(sql, id)
  	if err != nil {
  		return false, err
  	}
  	return true, err
  }
  
  //FindById  < 具体实现 NewAccountRepository
  func (u accountRepo) FindById(userId string) (entity.UserAccount, error) {
  	sql := "select * from user_account where user_id=?"
  	var userAccount entity.UserAccount
  	err := BaseDb.Get(&userAccount, sql, userId)
  	if err != nil {
  		return userAccount, err
  	}
  	return userAccount, err
  
  }
  
  //ListAll  < 具体实现 NewAccountRepository
  func (u accountRepo) ListAll() ([]entity.UserAccount, error) {
  	sql := "select * from user_account"
  	var accountFlow []entity.UserAccount
  	err := BaseDb.Get(&accountFlow, sql)
  
  	return accountFlow, err
  }
  
  func NewAccountFlowRepository() UserAccountFlowRepository {
  	return &accountFlowRepo{}
  }
  
  //Insert  < 具体实现 NewAccountFlowRepository
  func (accountFlowRepo) Insert(account entity.UserAccountFlow) (int, error) {
  	sql := `insert into user_account_flow(user_id,account_id,type,amount,blockchain_address,before_balance,balance,activities_id,transaction_info)
       values(:user_id,:account_id,:type,:amount,:blockchain_address,:before_balance,:balance,:activities_id,:transaction_info)`
  	result, err := BaseDb.NamedExec(sql, account)
  	if err != nil {
  		return 0, err
  	}
  	id, err := result.LastInsertId()
  	if err != nil {
  		return 0, err
  	}
  	account.Id = id
  	return int(id), nil
  
  }
  
  //DeleteById  < 具体实现 NewAccountFlowRepository
  func (accountFlowRepo) DeleteById(id string) (bool, error) {
  	sql := "update user_account_flow set is_delete=1 where id =?"
  	_, err := BaseDb.Exec(sql, id)
  	if err != nil {
  		return false, err
  	}
  	return true, err
  }
  
  //FindById  < 具体实现 NewAccountFlowRepository
  func (accountFlowRepo) FindById(id string) (entity.UserAccountFlow, error) {
  	sql := "select * from user_account_flow where id=?"
  	var userAccount entity.UserAccountFlow
  	err := BaseDb.Get(&userAccount, sql, id)
  	if err != nil {
  		return userAccount, err
  	}
  	return userAccount, err
  
  }
  
  //ListAll  < 具体实现 NewAccountFlowRepository
  func (accountFlowRepo) ListAll() ([]entity.UserAccountFlow, error) {
  	sql := "select * from user_account_flow where is_delete =0"
  	var accountFlow []entity.UserAccountFlow
  	err := BaseDb.Get(&accountFlow, sql)
  
  	return accountFlow, err
  }
  
  //ListByAccountId  < 具体实现 NewAccountFlowRepository
  func (accountFlowRepo) ListByAccountId(accountId string) (*[]entity.UserAccountFlow, error) {
  	sqlStr := "select * from user_account_flow where is_delete =0 and account_id =?"
  	var accountFlow []entity.UserAccountFlow
  	err := BaseDb.Select(&accountFlow, sqlStr, accountId)
  	if err == sql.ErrNoRows {
  		return nil, nil
  	}
  	return &accountFlow, err
  }
  func (accountFlowRepo) FindByActivities(accountId string, activitiesId int64) (*[]entity.UserAccountFlow, error) {
  	sqlStr := "select * from user_account_flow where is_delete =0 and account_id =? and activities_id=?"
  	var accountFlow []entity.UserAccountFlow
  	err := BaseDb.Select(&accountFlow, sqlStr, accountId, activitiesId)
  	if err == sql.ErrNoRows {
  		return nil, nil
  	}
  	return &accountFlow, err
  }
  

  3.service

• package service
  
  import (
  	"database/sql"
  	"errors"
  	"fmt"
  	"project/dao"
  	"project/biz/model/dto"
  	"project/biz/model/entity"
  	"project/util"
  	"math"
  	"strconv"
  	"strings"
  )
  
  type UserAccountService interface {
  	// InsertAccount 新增账户信息
  	InsertAccount(accountReq dto.CreateAccountRequest) (*entity.UserAccount, error)
  	// FindAccount 查找账户信息
  	FindAccount(userId string) (any, error)
  	// FindAccountFlow 根据账户ID查找账户
  	FindAccountFlow(accountId string) ([]entity.UserAccountFlow, error)
  	//RewardAccount 扫码奖励
  	RewardAccount(scanning dto.Scanning) (any, error)
  }
  
  func NewAccountService() UserAccountService {
  	return &accountService{
  		AccountRepo:           dao.NewAccountRepository(),
  		AccountFlowRepo:       dao.NewAccountFlowRepository(),
  		OfflineActivitiesRepo: dao.NewOfflineActivitiesRepo(),
  	}
  }
  
  type accountService struct {
  	AccountRepo           dao.UserAccountRepository
  	AccountFlowRepo       dao.UserAccountFlowRepository
  	OfflineActivitiesRepo dao.OfflineActivitiesRepository
  }
  
  // InsertAccount 新增账户信息
  func (me *accountService) InsertAccount(accountDto dto.CreateAccountRequest) (*entity.UserAccount, error) {
  	err, b := me.AccountRepo.ExistsByUserId(accountDto.UserId)
  	if err != nil {
  		return nil, err
  	}
  	if b {
  		return nil, err
  	}
  	node, _ := util.NewWorker(10)
  	account := entity.UserAccount{
  		UserId:            accountDto.UserId,
  		Id:                "AC" + strconv.Itoa(int(node.GetId())),
  		BlockchainAddress: accountDto.Address,
  	}
  	err = me.AccountRepo.Insert(account)
  	if err != nil {
  		return nil, err
  	}
  
  	return &account, nil
  }
  
  // FindAccount 查找账户信息
  func (me *accountService) FindAccount(userId string) (any, error) {
  	account, err := me.AccountRepo.FindById(userId)
  	if err == sql.ErrNoRows {
  		accDto := dto.CreateAccountRequest{}
  		accDto.UserId = userId
  		address, err := indiev_wallet.GetAddress()
  		if err != nil {
  			return nil, err
  		}
  		accDto.Address = address
  		accountEntity, err := me.InsertAccount(accDto)
  		if err != nil {
  			return nil, err
  		}
  		return accountEntity, nil
  	}
  	if account.BlockchainAddress != "" {
  		chainBalance := util.GetBalance(account.BlockchainAddress)
  		chainBalance = strings.TrimLeft(chainBalance, "0x")
  		f, err := strconv.ParseUint(chainBalance, 16, 32)
  		if err != nil {
  			return nil, err
  		}
  		//金额转换
  		account.Balance = int64(float64(f) / math.Pow(10, 8))
  
  	}
  	return account, err
  
  }
  
  // FindAccountFlow 根据账户ID查找账户
  func (me *accountService) FindAccountFlow(accountId string) ([]entity.UserAccountFlow, error) {
  	accountFlows, err := me.AccountFlowRepo.ListByAccountId(accountId)
  	if err != nil {
  		return nil, err
  	}
  	return *accountFlows, nil
  }
  
  
  type scanningDto struct {
  	RewardValue int64  `json:"rewardValue" db:"reward_value"`
  	Unit        string `json:"unit" db:"reward_value"`
  }
  

  4.controller包

• package controller
  
  import (
  	"github.com/gin-gonic/gin"
      //项目
  	"project/biz/model/dto"
  	"project/biz/service"
  )
  
  func NewAccountController(accountService service.UserAccountService) *AccountController {
  	return &AccountController{
  		accountService: accountService,
  	}
  }
  
  // InsertAccount 新增账户信息
  func (me *AccountController) InsertAccount(c *gin.Context) (any, error) {
  	var req dto.CreateAccountRequest
  	err := c.ShouldBindJSON(&req)
  	if err != nil {
  		return nil, err
  	}
  
  	account, err := me.accountService.InsertAccount(req)
  	if err != nil {
  		return nil, err
  	}
  	return account, err
  }
  
  // FindAccount 查找账户信息
  func (me *AccountController) FindAccount(c *gin.Context) (any, error) {
  	userId := c.Param("userId")
  	account, err := me.accountService.FindAccount(userId)
  	if err != nil {
  		return nil, err
  	}
  	return account, err
  
  }
  
  // FindAccountFlow 根据账户ID查找账户
  func (me *AccountController) FindAccountFlow(c *gin.Context) (any, error) {
  	accountId := c.Param("accountId")
  	account, err := me.accountService.FindAccountFlow(accountId)
  	if err != nil {
  		return nil, err
  	}
  	return account, err
  }
  
  type AccountController struct {
  	accountService service.UserAccountService
  }
  

  5.common包

• 返回struct

• package common
  
  import "net/http"
  
  const (
  	CodeSuccess        = "SUCCESS"
  	CodeError          = "ERROR"
  	ParamFormatError   = "PARAM_FORMAT_ERROR"
  	ParamNotExistError = "PARAM_NOT_EXIST_ERROR"
  	AppNotExistError   = "APP_NOT_EXIST_ERROR"
  	AppExistError      = "APP_EXIST_ERROR"
  
  	InternalServiceErr = "INTERNAL_SERVICE_ERROR"
  
  	Unauthorized = "UNAUTHORIZED"
  )
  
  type Result struct {
  	Code    string `json:"code"`
  	Data    any    `json:"data"`
  	Message string `json:"message"`
  }
  
  func NewOkResult(msg string) *Result {
  	return &Result{
  		Code:    CodeSuccess,
  		Data:    nil,
  		Message: msg,
  	}
  }
  
  func NewDataResult(data any) *Result {
  	return &Result{
  		Code:    CodeSuccess,
  		Data:    data,
  		Message: "",
  	}
  }
  
  func NewErrorResult(code, msg string) *Result {
  	return &Result{
  		Code:    code,
  		Data:    nil,
  		Message: msg,
  	}
  }
  
  type Error struct {
  	Status int
  	Code   string
  	Msg    string
  }
  
  func BadRequestErr(code string, msg string) error {
  	return &Error{
  		Status: http.StatusBadRequest,
  		Code:   code,
  		Msg:    msg,
  	}
  }
  
  func NotFoundErr(code string, msg string) error {
  	return &Error{
  		Status: http.StatusNotFound,
  		Code:   code,
  		Msg:    msg,
  	}
  }
  
  func UnauthorizedErr() error {
  	return &Error{
  		Status: http.StatusUnauthorized,
  		Code:   "Unauthorized",
  		Msg:    "",
  	}
  }
  
  func InternalServerErr(code string, msg string) error {
  	return &Error{
  		Status: http.StatusInternalServerError,
  		Code:   code,
  		Msg:    msg,
  	}
  }
  
  func (e *Error) Error() string {
  	return e.Msg
  }
  

  6.config包

•  

  package conf
  
  import (
  	log "github.com/sirupsen/logrus"
  	"github.com/spf13/viper"
  	"os"
  )
  //数据库配置
  type DbConfig struct {
  	Host   string
  	User   string
  	Passwd string
  	DBName string
  }
  
  type Struct struct {
  	Mysql DbConfig
  }
  
  var Config Struct
  
  //初始化，优先加载
  func init() {
  	var appName = "app"
      //路径
  	viper.AddConfigPath("./resource")
       //如果 环境信息，或者命令行有 这个变量，则追加环境信息，如果没有，默认取 app.yml 
       //加载了环境则是 app-dev.yml |app-test.yml
  	configEnv := os.Getenv("GO_ENV")
  
  	if configEnv != "" {
  		appName += "-" + configEnv
  	}
  
  	viper.SetConfigName(appName)
  	if err := viper.ReadInConfig(); err != nil {
  		log.Panicf("Error reading config file  %s\n", err)
  	}
      // viper读取了配置，并且将 json字符 反序列化 到对象
  	err := viper.Unmarshal(&Config)
  	if err != nil {
  		log.Panicf("unable to decode into struct, %v", err)
  	}
  
  }
  

  7.util包

• package util
  
  import (
  	"encoding/json"
  	"fmt"
  	"github.com/golang-jwt/jwt"
  	_ "github.com/golang-jwt/jwt"
  	"log"
  	"time"
  )
  // 秘钥，如果要对接，问问上游生成的时候，有没有 秘钥
  var mySigningKey = []byte("asfasfdafasdfdasfa.")
  //TokenHandle 解析token
  
  func TokenHandle(tokenString string) (string, error) {
  	token, err := jwt.Parse(tokenString, func(t *jwt.Token) (interface{}, error) {
  		return mySigningKey, nil
  	})
  	if err != nil {
  		log.Println(err.Error())
  		return "", err
  	}
  	data := token.Claims.(jwt.MapClaims)["data"]
  	var tokenData = new(TokenData)
  	if data != nil {
  		var info = data.(string)
  		err = json.Unmarshal([]byte(info), &tokenData)
  	}
  
  	return tokenData.UserId, err
  }
  //CreateToken is created token 
  func CreateToken(data TokenData) (string, error) {
  	dataByte, err := json.Marshal(data)
  	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
  		"data": string(dataByte),
  		"exp":  time.Now().Unix() + 1000*5,
  		"iss":  "ibc_business",
  	})
  
  	tokenString, err := token.SignedString(mySigningKey)
  	if err != nil {
  		log.Fatal(err)
  		return "", err
  	}
  	fmt.Println("加密后的token字符串", tokenString)
  	return tokenString, nil
  }
  
  //TokenData is 用户对象
  type TokenData struct {
  	UserId   string
  	Age      int32
  	NickName string
  	Name     string
  	Phone    string
  }
  

  8.go.mod

  module project //项目名
  
  go 1.18
  
  require (
  	github.com/33cn/chain33 v1.67.3
  	github.com/gin-gonic/gin v1.8.1
  	github.com/go-sql-driver/mysql v1.6.0
  	github.com/golang-jwt/jwt v3.2.1+incompatible
  	github.com/jmoiron/sqlx v1.3.5
  	github.com/miguelmota/go-ethereum-hdwallet v0.1.1
  	github.com/polydawn/refmt v0.0.0-20190807091052-3d65705ee9f1
  	github.com/satori/go.uuid v1.2.1-0.20181028125025-b2ce2384e17b
  	github.com/sirupsen/logrus v1.9.0
  	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
  	github.com/spf13/viper v1.13.0
  )
  
  require (
  	github.com/BurntSushi/toml v0.3.1 // indirect
  	github.com/btcsuite/btcd v0.22.0-beta // indirect
  	github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce // indirect
  	github.com/decred/base58 v1.0.3 // indirect
  	github.com/decred/dcrd/crypto/blake256 v1.0.0 // indirect
  	github.com/ethereum/go-ethereum v1.10.16 // indirect
  	github.com/fsnotify/fsnotify v1.5.4 // indirect
  	github.com/gin-contrib/sse v0.1.0 // indirect
  	github.com/go-playground/locales v0.14.0 // indirect
  	github.com/go-playground/universal-translator v0.18.0 // indirect
  	github.com/go-playground/validator/v10 v10.10.0 // indirect
  	github.com/go-stack/stack v1.8.0 // indirect
  	github.com/goccy/go-json v0.9.7 // indirect
  	github.com/golang/protobuf v1.5.2 // indirect
  	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect
  	github.com/hashicorp/hcl v1.0.0 // indirect
  	github.com/json-iterator/go v1.1.12 // indirect
  	github.com/leodido/go-urn v1.2.1 // indirect
  	github.com/magiconair/properties v1.8.6 // indirect
  	github.com/mattn/go-colorable v0.1.12 // indirect
  	github.com/mattn/go-isatty v0.0.14 // indirect
  	github.com/mitchellh/mapstructure v1.5.0 // indirect
  	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
  	github.com/modern-go/reflect2 v1.0.2 // indirect
  	github.com/mr-tron/base58 v1.2.0 // indirect
  	github.com/pelletier/go-toml v1.9.5 // indirect
  	github.com/pelletier/go-toml/v2 v2.0.5 // indirect
  	github.com/pkg/errors v0.9.1 // indirect
  	github.com/prometheus/client_golang v1.11.1 // indirect
  	github.com/shopspring/decimal v1.2.0 // indirect
  	github.com/spf13/afero v1.8.2 // indirect
  	github.com/spf13/cast v1.5.0 // indirect
  	github.com/spf13/jwalterweatherman v1.1.0 // indirect
  	github.com/spf13/pflag v1.0.5 // indirect
  	github.com/subosito/gotenv v1.4.1 // indirect
  	github.com/tjfoc/gmsm v1.3.2 // indirect
  	github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef // indirect
  	github.com/ugorji/go/codec v1.2.7 // indirect
  	golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4 // indirect
  	golang.org/x/net v0.0.0-20220520000938-2e3eb7b945c2 // indirect
  	golang.org/x/sync v0.0.0-20220513210516-0976fa681c29 // indirect
  	golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 // indirect
  	golang.org/x/text v0.3.7 // indirect
  	google.golang.org/genproto v0.0.0-20220519153652-3a47de7e79bd // indirect
  	google.golang.org/grpc v1.46.2 // indirect
  	google.golang.org/protobuf v1.28.0 // indirect
  	gopkg.in/ini.v1 v1.67.0 // indirect
  	gopkg.in/yaml.v2 v2.4.0 // indirect
  	gopkg.in/yaml.v3 v3.0.1 // indirect
  )
  

总结

以上就是 golang搭建web项目的流程，使用gin 做http请求，同时封装了标准返回，拦截token.并且使用sqlx做 mysql的连接。