Go Gin项目搭建

创建项目

项目实例链接：Demo
基于mod创建项目
设置国内镜像地址：https://goproxy.cn,direct

创建完后该目录下就会出现一个go.mod文件，mod是一个包管理工具，常用的指令如下：

go mod download 下载模块到本地缓存，缓存路径是 $GOPATH/pkg/mod/cache
go mod edit 是提供了命令版编辑 go.mod 的功能，例如 go mod edit -fmt go.mod 会格式化 go.mod
go mod graph 把模块之间的依赖图显示出来
go mod init 初始化模块（例如把原本dep管理的依赖关系转换过来）
go mod tidy 增加缺失的包，移除没用的包
go mod vendor 把依赖拷贝到 vendor/ 目录下
go mod verify 确认依赖关系
go mod why 解释为什么需要包和模块

项目结构

配置文件

app.json配置文件内容如下：

{
  "app": {
    "name": "zzt",
    "mode": "debug",
    "host": "localhost",
    "port": "8090"
  },
  "database":
  {
    "url": "root:123456@tcp(localhost:3306)/test?charset=utf8"
  }
}

读取配置文件的公共方法Config.go

package Common

import (
	"bufio"
	"encoding/json"
	"os"
)

type Config struct {
	App appConfig `json:"app"`
	DataBase DatabaseConfig `json:"database"`
}

type appConfig struct {
	AppName string `json:"name"`
	AppMode string `json:"mode"`
	AppHost string `json:"host"`
	AppPort string `json:"port"`
}

type DatabaseConfig struct{
	Url string `json:"url"`
}

var _cfg *Config = nil

func GetConfig() *Config {
	return _cfg
}

func ParseConfig(path string) (*Config, error) {
	file, err := os.Open(path)
	if err != nil {
		panic(err)
	}
	defer file.Close()

	reader := bufio.NewReader(file)
	decoder := json.NewDecoder(reader)
	if err := decoder.Decode(&_cfg); err != nil {
		return nil, err
	}
	return _cfg, nil
}

数据访问层的公共方法Orm.go
用的是Xorm

package Common

import (
	"Demo/Models"
	"github.com/go-xorm/xorm"
	_ "github.com/go-sql-driver/mysql"
)
//全局对象
var DbEngine *Orm

type Orm struct {
	*xorm.Engine
}

func OrmEngine(cfg *Config) (*Orm,error) {
	conn := cfg.DataBase.Url
	engine, err := xorm.NewEngine("mysql", conn)
	if err != nil {
		return nil, err
	}
	//输出SQL
	engine.ShowSQL()
	//同步数据库结构
	err =engine.Sync2(new(Models.User))
	if err!=nil{
		return nil, err
	}

	orm := new(Orm)
	orm.Engine = engine
	DbEngine = orm
	return orm, err
}

配置路由的文件Routers.go

package Routers

import (
	"Demo/Controller"
	"github.com/gin-gonic/gin"
)

//注册路由
func RegisterRouter() *gin.Engine {
	r := gin.Default() //gin.New() //

	//路由
	v1:=r.Group("/orm/")
	{
		v1.GET("/Select/:id", Controller.Select)
		v1.POST("/Insert",Controller.Insert)
		v1.POST("/Update",Controller.Update)
		v1.DELETE("/Delete",Controller.Delete)
	}
	return r
}

main.go

package main

import (
	"Demo/Common"
	"Demo/Routers"
	"log"
)

func main() {
	//读取配置文件
	cfg, err := Common.ParseConfig("./Config/app.json")
	if err != nil {
		log.Printf("err:%+v", err)
		return
	}
	//创建连接数据库对象
	_, err = Common.OrmEngine(cfg)
	if err != nil {
		log.Printf("err:%+v", err)
		return
	}

	//注册路由
	app := Routers.RegisterRouter()
	app.Run(cfg.App.AppHost + ":" + cfg.App.AppPort)
}

数据访问

用的是Xorm
简单的增删改查

package Dao

import (
	"Demo/Common"
	"Demo/Models"
	"log"
)

type DaoUser struct {
	*Common.Orm
}

func (d *DaoUser) Select(id int64) *Models.User{
	user :=new(Models.User)
	_,err:=d.Where("id =?",id).Get(user)
	if err!= nil{
		log.Printf("err:%+v", err.Error())
	}
	return user
}

func (d *DaoUser) Insert(m Models.User) int64{
	result,err:=d.InsertOne(m)
	if err!= nil{
		log.Printf("err:%+v", err.Error())
	}
	return result
}

func (d *DaoUser) DeleteById(id int64) int64{
	user:=new(Models.User)
	result,err:=d.ID(id).Delete(user)
	if err!=nil {
		log.Printf("err:%v", err)
	}
	return result
}

func (d *DaoUser) UpdateUser(m Models.User) int64{
	result,err:=d.ID(m.Id).Update(m)
	if err!= nil{
		log.Printf("err:%+v", err.Error())
	}
	return result
}

控制器

package Controller

import (
	"Demo/Common"
	"Demo/Dao"
	"Demo/Dto"
	"Demo/Models"
	"github.com/gin-gonic/gin"
	"strconv"
)

type MySqlController struct {

}

func Select(ctx *gin.Context) {
	id, _ := strconv.ParseInt(ctx.Param("id"), 10, 64)

	rsp := new(Dto.Rsp)
	dUser := Dao.DaoUser{Orm: Common.DbEngine}
	result := dUser.Select(id)
	if result != nil {
		rsp.Code = 200
		rsp.Msg = "成功"
		rsp.Data = result
	} else {
		rsp.Code = 200
		rsp.Msg = "失敗"
	}
	ctx.JSON(200, rsp)
}

func Insert(ctx *gin.Context) {
	account := ctx.PostForm("account")
	passWord := ctx.PostForm("passWord")

	user := Models.User{Account: account, PassWord: passWord}
	dUser := Dao.DaoUser{Orm: Common.DbEngine}
	result := dUser.Insert(user)
	if result > 0 {
		ctx.JSON(200, map[string]interface{}{
			"message": "添加成功",
		})
	} else {
		ctx.JSON(200, map[string]interface{}{
			"message": "添加失败",
		})
	}
}

func Delete(ctx *gin.Context) {
	id, _ := strconv.ParseInt(ctx.Query("id"), 10, 64)

	dUser:=Dao.DaoUser{Orm: Common.DbEngine}
	result:=dUser.DeleteById(id)
	if result>0 {
		ctx.JSON(200, map[string]interface{}{
			"message": "删除成功",
		})
	} else{
		ctx.JSON(200, map[string]interface{}{
			"message": "删除失败",
		})
	}
}

func Update(ctx *gin.Context) {
	id, _ := strconv.ParseInt(ctx.PostForm("id"), 10, 64)
	account := ctx.PostForm("account")
	passWord := ctx.PostForm("passWord")

	user := Models.User{Id: id, Account: account, PassWord: passWord}
	dUser := Dao.DaoUser{Orm: Common.DbEngine}
	result := dUser.UpdateUser(user)
	if result > 0 {
		ctx.JSON(200, map[string]interface{}{
			"message": "更新成功",
		})
	} else {
		ctx.JSON(200, map[string]interface{}{
			"message": "更新失败",
		})
	}
}

redis

package Common

import (
	"github.com/go-redis/redis"
	"fmt"
	"log"
	"time"
)

var RedisClient *redis.Client

// Redis cache implement
type Redis struct {
	Client *redis.Client
}

// Setup connection
func RedisConnect(cfg *Config) error {
	RedisClient = redis.NewClient(&redis.Options{
		Addr:     cfg.Redis.Addr,
		Password: cfg.Redis.PassWord,
		DB:       cfg.Redis.DB,
	})
	_, err := RedisClient.Ping().Result()
	if err != nil {
		log.Fatal(fmt.Sprintf("Could not connected to redis : %s", err.Error()))
	}
	return err
}

// Get from key
func (r *Redis) Get(key string) (string, error) {
	return r.Client.Get(key).Result()
}

// Set value with key and expire time
func (r *Redis) Set(key string, val string, expire int) error {
	return r.Client.Set(key, val, time.Duration(expire)*time.Second).Err()
}

// Del delete key in redis
func (r *Redis) Del(key string) error {
	return r.Client.Del(key).Err()
}

// HashGet from key
func (r *Redis) HashGet(hk, key string) (string, error) {
	return r.Client.HGet(hk, key).Result()
}

// HashDel delete key in specify redis's hashtable
func (r *Redis) HashDel(hk, key string) error {
	return r.Client.HDel(hk, key).Err()
}

// Increase
func (r *Redis) Increase(key string) error {
	return r.Client.Incr(key).Err()
}

// Set ttl
func (r *Redis) Expire(key string, dur time.Duration) error {
	return r.Client.Expire(key, dur).Err()
}