golang框架gin基本使用，常规数据库、rocketMQ等基本使用)

安装

go get github.com/gin-gonic/gin

入口文件

package main

import (
   "activity/core"
   "activity/global"
   "activity/initialize"
   "github.com/gin-gonic/gin"
   "time"
)

func main() {

   // 设置时区 
   var cstZone = time.FixedZone("CST", 8*3600) // 东八
   time.Local = cstZone

   gin.SetMode(gin.ReleaseMode)
   // 初始化配置文件
   initialize.InitializeConfig()

   // 初始化日志
   global.GVA_LOG = core.Zap()
   defer func() {
      _ = global.GVA_LOG.Sync()
   }()
   // 初始化数据库
   initialize.InitializeDB()

   // 初始化redis
   initialize.InitializeRedis()
   initialize.InitMq()

   //数据库执行玩关闭数据库连接
   defer func() {
      global.Engine.Close()
   }()
   //run sever
   core.RunServer()
}

初始化配置文件

用goconfig类库 读取配置

package initialize

import (
    env2 "activity/env"
    "activity/global"
    "github.com/unknwon/goconfig" //用goconfig类库 读取配置
    "log"
    "os"
)

func InitializeConfig()  {

    // 配置文件初始化
    confFile := "./config/config_dev.ini"
    env := env2.Active().Value()
    if env == "pro" {
        confFile =  "./config/config.ini"
    }else if env == "dev" {
        confFile =  "./config/config_dev.ini"
    }
    var err error
    if global.Config,err = goconfig.LoadConfigFile(confFile);err!=nil {
        log.Println("配置文件不存在，程序退出")
        os.Exit(0)
    }
}

初始化数据库

package initialize

import (
    "activity/global"
    _ "github.com/go-sql-driver/mysql"
    "github.com/go-xorm/xorm"
    "log"
)

func InitializeDB(){
    var err error
    username := global.Config.MustValue("database", "username")
    password := global.Config.MustValue("database", "password")
    host := global.Config.MustValue("database", "host")
    port := global.Config.MustValue("database", "port")
    dbname := global.Config.MustValue("database", "dbname")
    dbInfo := username + ":" + password +"@tcp("+ host + ":"+ port + ")/" + dbname + "?charset=utf8"
    global.Engine,err = xorm.NewEngine("mysql",dbInfo)
    //global.Engine.SetMaxIdleConns(5)
    //global.Engine.SetMaxOpenConns(30)
    if err != nil {
        log.Fatal(err)
        return
    }
}

初始化redis

package initialize

import (
    "activity/global"
    "github.com/go-redis/redis/v8"
    "strings"
)

func InitializeRedis() {
    host := global.Config.MustValue("redisCluster", "host")
    auth := global.Config.MustValue("redisCluster", "auth")
    hostStr := strings.Split(host, ",")
    global.Cluster = redis.NewClusterClient(&redis.ClusterOptions{
        Addrs: hostStr,
        Password: auth,
        PoolSize: 25,//设置连接池大小
        MinIdleConns: 15,//设置最小空闲
    })
}

初始化RocketMQ

package initialize

import (
    "activity/global"
    "github.com/apache/rocketmq-client-go/v2"
    "github.com/apache/rocketmq-client-go/v2/primitive"
    "github.com/apache/rocketmq-client-go/v2/producer"
    "github.com/apache/rocketmq-client-go/v2/rlog"
    "strings"
)

func InitMq()  {

    nameServer := global.Config.MustValue("mq", "NameServer")
    p, _ := rocketmq.NewProducer(
        producer.WithNsResolver(primitive.NewPassthroughResolver(strings.Split(nameServer,","))),
        producer.WithRetry(1),
    )
    p.Start()
    global.Mq = p
    rlog.SetLogLevel("error")
}

初始化路由

package initialize

import (
    "activity/middleware"
    "activity/route"
    "github.com/gin-gonic/gin"
    "net/http"
)

func Routers() *gin.Engine  {

    //var Router = gin.Default()
    var Router = gin.New()
    Router.Use(gin.Recovery())

    // 跨域
    Router.Use(middleware.Cors()) //中间件的使用
    // 方便统一添加路由组前缀 多服务器上线使用
    PublicGroup := Router.Group("")
    {
        route.InitBaseRouter(PublicGroup) // 不做鉴权
    }
    PrivateGroup := Router.Group("")
    // 如果使用多个中间件 可以多次Use()
    PrivateGroup.Use(middleware.JWTAuthMiddleware()).Use(middleware.CheckGameData())//中间件的使用
    {
        // 注册功能api路由
        route.InitUserRouter(PrivateGroup)
        // ... 注册其他路由
    }

    // 健康检查接口
    Router.GET("/health", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "code" : http.StatusOK,
            "success":true,
        })
        return
    })
    return Router
}

核心脚本core.go

package core

import (
    "activity/global"
    "activity/initialize"
)

func RunServer()  {
    r := initialize.Routers() //初始化路由
    port := global.Config.MustValue("application", "port") //读取配置文件
    r.Run(":" + port)
}

api如何使用？

路由映射

package route

import (
    "activity/api"
    u "activity/api/user"
    "github.com/gin-gonic/gin"
)

func InitBaseRouter(Router *gin.RouterGroup) (R gin.IRoutes) {
    userHandler := u.New()
    BaseRouter := Router.Group("api/")
    {
        loginController := api.LoginController{}
        BaseRouter.POST("login/:action", loginController.Login)// 请求方式和对应控制器的方法
        BaseRouter.GET("login/:action", loginController.Login)
        BaseRouter.GET("public/share", userHandler.Share)
        BaseRouter.GET("test", api.Test)
    }
    return BaseRouter
}

api test请求

package api

import (
    "activity/env"
    "github.com/gin-gonic/gin"
)
func Test(c *gin.Context)  {
    c.JSON("test",env.Active().Value())
    return
}

DB操作

model定义

package model
type Player struct {
    Id         int64     `xorm:"pk autoincr bigint(64)" form:"id" json:"id"`
    Uid           int64    `xorm:"int(10) 'uid'" form:"uid" json:"uid"`
    //等等字段
    LoginTime   string    `xorm:"datetime  'loginTime' default ''" form:"loginTime" json:"loginTime"`
    CreateTime string    `xorm:"datetime  'createTime' created" form:"createTime" json:"createTime"`
    UpdateTime string    `xorm:"datetime  'updateTime' updated" form:"updateTime" json:"updateTime"`

}

查询

func GetPersonByKey(key string) (*model.Player,error) {
    player := &model.Player{}
    has,err := global.Engine.Table(global.TablePlayer).Where("`key`=? and `share` < 3", key).Get(player)
    if err != nil || !has {
        return nil,errors.New("账号不存在")
    }
    return player, nil;
}

执行curl请求

url := global.Config.MustValue("apiUrl", "query")
queryPayResult := &QueryPayResult{}
client := resty.New()
client.SetTimeout(10*time.Second)
resp, err := client.R().
    SetQueryParams(map[string]string{
        "start_time" : startDate,
        "end_time"   : endDate,
    
    }).
    SetResult(queryResult).
    ForceContentType("application/json").
    Get(url)

文件上传与下载

上传

func Upload(c *gin.Context) (file string, err error) {
    f, err := c.FormFile("file")
    if err != nil {
        return "",err
    }
    filePath := "./uploads/"
    if !utils.Exists(filePath) {
        os.Mkdir(filePath,755)
    }
    fileName := filePath + f.Filename
    c.SaveUploadedFile(f, fileName)
    return fileName, err
}

下载

func Download(c *gin.Context)  {
    fileName := "DATE.pdf"
    c.Header("Content-Type", "application/octet-stream")
    c.Header("Content-Disposition", "attachment;filename="+fileName)
    c.Header("Content-Disposition", "inline;filename="+fileName)
    c.Header("Content-Transfer-Encoding", "binary")
    c.File("./uploads/DATE.pdf")
    return
}