golang web 开发 —— gin 框架 （gorm 链接 mysql）

目录

1. 介绍

2. 环境

3. gin

3.1 gin提供的常见路由

3.2 gin的分组

main.go

router.go

代码结构

3.3 gin 提供的Json方法

main.go

route.go

common.go

user.go

order.go

3.4 gin框架下如何获取传递来的参数

第一种是GET请求后面直接 /拼上传递的参数

第二种是这样传递

第三种是以Json方式来传递

3.5 golang如何进行异常捕获和处理

4. 关于日志

5. gin如何操作数据库（需要用到gorm）

main.go

config

db.go

controller

common.go

order.go

user.go

dao

dao.go

models

user.go

router

router.go

1. 介绍

2. 环境

查看是否设置成功

（PS:go env -w GOSUMDB=sum.golang.org(GOSUM问题)）

3. gin

gin 的路由是通过前缀树来实现的，每个请求方法一个前缀树（没有使用反射来实现，比反射的效率好得多），一般路由分为（GET,POST,DELETE等等，我们都来看看）

3.1 gin提供的常见路由

package main

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

func main() {
	//先生成一个实例
	r:= gin.Default()
	//再定义一个路由
	//第一个是访问的url 第二个是处理函数
	r.GET("/hello", func(ctx *gin.Context) {
		ctx.String(http.StatusOK/*200*/, "Hello, World!")
	})
	r.POST("/user/list", func(ctx *gin.Context) {
		ctx.String(http.StatusOK/*200*/, "user list")
	})
	r.PUT("/user/add", func(ctx *gin.Context) {
		ctx.String(http.StatusOK/*200*/, "user add")
	})
	r.DELETE("/user/delete", func(ctx *gin.Context) {
		ctx.String(http.StatusOK/*200*/, "user delete")
	})
	//可以使用ANY方法来处理所有的请求
	r.Any("/any", func(ctx *gin.Context) {
		ctx.String(http.StatusOK/*200*/, "Hello, World!")
	})

	//最后启动web服务
	//可以指定端口号
	r.Run(":9999")
}

3.2 gin的分组

并且 gin 的路由是可以分组的（/user/list /user/add这种）

package main

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

func main() {
	//先生成一个实例
	r:= gin.Default()
	//再定义一个路由
	//第一个是访问的url 第二个是处理函数
	// r.GET("/hello", func(ctx *gin.Context) {
	// 	ctx.String(http.StatusOK/*200*/, "Hello, World!")
	// })
	// r.POST("/user/list", func(ctx *gin.Context) {
	// 	ctx.String(http.StatusOK/*200*/, "user list")
	// })
	// r.PUT("/user/add", func(ctx *gin.Context) {
	// 	ctx.String(http.StatusOK/*200*/, "user add")
	// })
	// r.DELETE("/user/delete", func(ctx *gin.Context) {
	// 	ctx.String(http.StatusOK/*200*/, "user delete")
	// })

	user:=r.Group("user")
	{
		//因为上面已经有/user了 所以这里不用再写/user
		user.POST("/list", func(ctx *gin.Context) {
			ctx.String(http.StatusOK/*200*/, "user list")
		})
		user.PUT("/add", func(ctx *gin.Context) {
			ctx.String(http.StatusOK/*200*/, "user add")
		})
		user.DELETE("/delete", func(ctx *gin.Context) {
			ctx.String(http.StatusOK/*200*/, "user delete")
		})
	}

	//最后启动web服务
	//可以指定端口号
	r.Run(":9999")
}

然后此时是写在main包里面的，而main包作为入口文件，把这么多的路由写在这里显然很不合理，所以我们创建一个router包去专门导入路由

main.go

package main

import (
    //引入包这个整了很久，一直有各种问题
    //使用注意：要在 GOROOT/src 同级目录下创建项目，然后进入项目文件夹，
    //然后 go mod init 该文件夹，然后去使用 
	"gin-ranking/router"
)

func main() {
	r:=router.Router()
	
	r.Run(":9999")
}

router.go

package router//和文件夹名保持一致

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

func Router() *gin.Engine {
	r := gin.Default()

	user:=r.Group("user")
	{
		//因为上面已经有/user了 所以这里不用再写/user
		user.POST("/list", func(ctx *gin.Context) {
			ctx.String(http.StatusOK/*200*/, "user list")
		})
		user.PUT("/add", func(ctx *gin.Context) {
			ctx.String(http.StatusOK/*200*/, "user add")
		})
		user.DELETE("/delete", func(ctx *gin.Context) {
			ctx.String(http.StatusOK/*200*/, "user delete")
		})
	}

	return r
}

代码结构

3.3 gin 提供的Json方法

gin返回Json数据很简单，因为他提供了Json方法

路由以及统一的返回

main.go

package main

import (
	"gin-ranking/router"
)

func main() {
	r:=router.Router()
	 
	r.Run(":9999")
}

route.go

package router//和文件夹名保持一致

import (
	"github.com/gin-gonic/gin"
	"net/http"
	"gin-ranking/controller"
)

func Router() *gin.Engine {
	r := gin.Default()

	user:=r.Group("user")
	{
		//因为上面已经有/user了 所以这里不用再写/user 注意使用Talend的时候，前面是 ip:port/user/各种信息
		user.GET("/info",controller.UserController{}.GetUserInfo)
		user.POST("/list", controller.UserController{}.GetList)
		user.PUT("/add", func(ctx *gin.Context) {
			ctx.String(http.StatusOK/*200*/, "user add")
		})
		user.DELETE("/delete", func(ctx *gin.Context) {
			ctx.String(http.StatusOK/*200*/, "user delete")
		})
	}

	order:=r.Group("/order")
	{
		order.POST("/list", controller.OrderController{}.GetList)
	}
	return r
}

common.go

package controller

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

type JsonStruct struct {
	Code int         `json:"code"`   //返回的是 200 400 404 500...
	Msg  interface{} `json:"msg"`    //返回的信息
	Data interface{} `json:"data"`   //返回的数据
	Count int64      `json:"count"`  //返回的数据总数
}

type JsonErrorStruct struct {
	Code int         `json:"code"`   //返回的是 200 400 404 500...
	Msg  interface{} `json:"msg"`    //返回的信息
}

func ReturnSucces(c *gin.Context, code int,msg interface{}, data interface{}, count int64) {
	json := &JsonStruct{
		Code: code,
		Msg:  msg,
		Data: data,
		Count: count,
	}
	c.JSON(200, json)
}

func ReturnError(c *gin.Context, code int, msg interface{}) {
	json := &JsonErrorStruct{
		Code: code,
		Msg:  msg,
	}
	c.JSON(200, json)
}

user.go

package controller

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

//因为我们目前这么写的话，这些文件都在一个包也就其实是
//一个作用域，所以函数名容易重复，此时我们可以给他们加上一个前缀
//比如这里的UserController
type UserController struct {}

func (u UserController)GetUserInfo(c *gin.Context) {
	ReturnSucces(c,0,"succes","user info",1)
}

func (u UserController)GetList(c *gin.Context) {
	ReturnError(c,4004,"没有相关信息list")
}

order.go

package controller

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

type OrderController struct {}

func (o OrderController)GetList(c *gin.Context){
	ReturnError(c,4004,"没有相关信息order")
}

3.4 gin框架下如何获取传递来的参数

传递参数一般分为三种：

第一种是GET请求后面直接 /拼上传递的参数

第二种是这样传递

第三种是以Json方式来传递

然后我们分别来看如何获取：

一 url方式：

这种我们一般会在路由中直接拼上

第二种是通过POST怎么接收值呢

这种方式路由是不用改的，直接改order.go

第三种是Json格式的数据传入

接收Json数据我们需要通过map或者结构体

对于Json还有一种解决方式就是用结构体

3.5 golang如何进行异常捕获和处理

其他语言底层抛出异常上层逻辑通过try catch捕获异常，但是go语言的设计者认为将异常与控制结构混在一起会很容易使得代码变得混乱，为了不影响代码的原有逻辑，采用的延迟执行捕获异常的模式来实现

defer：压栈延迟执行

recover：是个内建函数，可以让系统崩溃的流程恢复过来，仅在延迟函数defer内有效，在正常程序执行中调用会返回nil，并且没有任何效果。假如有问题调用recover可以捕获到panic的输入值，并且恢复正常的执行。

panic：让程序直接崩溃

我们改一下user.go

然后加上

web访问结果就是200，并且没有内容了

并且打印里面捕获到了异常

自定义log中间件，并实现日志的收集

4. 关于日志

///

关于日志，比较重要的有三种：

第一种是项目的请求日志和ngix类似，每次请求都保留日志

第二种是错误日志，当程序出现错误的时候，日志应该保留下来

第三种是在开发业务逻辑的时候，程序员自己保存的日志。比如请求第三方接口的时候，把接口返回的信息直接保留下来。

///

5. gin如何操作数据库（需要用到gorm）

gorm中文文档：GORM - The fantastic ORM library for Golang, aims to be developer friendly.

项目结构

main.go

package main

import (
	"gin-ranking/router"
)

func main() {
	r:=router.Router()
	 
	r.Run(":9999")
}

config

db.go

package config

const (
	//
	Mysqldb = "root:password@tcp(10.18.xx.xx:3306)/lml_dtbase?charset=utf8"
)

controller

common.go

package controller

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

type JsonStruct struct {
	Code int         `json:"code"`   //返回的是 200 400 404 500...
	Msg  interface{} `json:"msg"`    //返回的信息
	Data interface{} `json:"data"`   //返回的数据
	Count int64      `json:"count"`  //返回的数据总数
}

type JsonErrorStruct struct {
	Code int         `json:"code"`   //返回的是 200 400 404 500...
	Msg  interface{} `json:"msg"`    //返回的信息
}

func ReturnSucces(c *gin.Context, code int,msg interface{}, data interface{}, count int64) {
	json := &JsonStruct{
		Code: code,
		Msg:  msg,
		Data: data,
		Count: count,
	}
	c.JSON(200, json)
}

func ReturnError(c *gin.Context, code int, msg interface{}) {
	json := &JsonErrorStruct{
		Code: code,
		Msg:  msg,
	}
	c.JSON(200, json)
}

order.go

package controller

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

type OrderController struct{}

type Search struct {
	//需要注意的是定义结构体和返回的时候，
	//都要指定Json的字段，否则首字母大写肯定是匹配不上的
	//注意前端传来的数据一定是小写的所以我们统一转成小写
	Name string `json:"name"`
	Cid  int    `json:"cid"`
}

func (o OrderController) GetList(c *gin.Context) {
	//cid:=c.PostForm("cid")
	//name:=c.DefaultPostForm("name","wangwu(Default)")
	// param := make(map[string]interface{})
	// err := c.BindJSON(&param)

	search := &Search{}
	err := c.BindJSON(&search)

	if err == nil {
		ReturnSucces(c, 0, search.Name, search.Cid, 1)
		return
	}
	ReturnError(c, 4001, gin.H{"err": err})
}

user.go

package controller

import (
	"fmt"
	"gin-ranking/models"
	"strconv"

	//"gin-ranking/pkg/logger"

	"github.com/gin-gonic/gin"
)

// 因为我们目前这么写的话，这些文件都在一个包也就其实是
// 一个作用域，所以函数名容易重复，此时我们可以给他们加上一个前缀
// 比如这里的UserController
type UserController struct{}

func (u UserController) GetUserInfo(c *gin.Context) {
	idStr := c.Param("id")
	name := c.Param("name")

	id, _ := strconv.Atoi(idStr)      //----------test
	user, _ := models.GetUserTest(id) //-----test

	ReturnSucces(c, 0, name, user, 1)
}

func (u UserController) AddUser(c *gin.Context) {
	username := c.DefaultPostForm("username", "")
	id, err := models.AddUser(username)
	if err != nil {
		ReturnError(c, 4002, "保存错误")
		return
	}
	ReturnSucces(c, 0, "保存成功", id, 1)
}

func (u UserController) UpdateUser(c *gin.Context) {
	username := c.DefaultPostForm("username", "") //获取username
	idStr := c.DefaultPostForm("id", "")
	id, _ := strconv.Atoi(idStr)
	models.UpdateUser(id, username)
	ReturnSucces(c, 0, "更新成功", true, 1)
}

func (u UserController) DeleteUser(c *gin.Context) {
	idStr := c.DefaultPostForm("id", "")
	id, _ := strconv.Atoi(idStr)
	err := models.DeleteUser(id)
	if err != nil {
		ReturnError(c, 4002, "删除错误")
		return
	}
	ReturnSucces(c, 0, "删除成功", true, 1)
}

func (u UserController) GetList(c *gin.Context) {
	//user logger
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("异常捕获", err)
		}
	}()

	num1 := 1
	num2 := 0
	num3 := num1 / num2
	ReturnError(c, 4004, num3)
	//ReturnError(c, 4004, "没有相关信息list")
}

func (u UserController) GetUserListTest(c *gin.Context) {
	users, err := models.GetUserListTest()
	if err != nil {
		ReturnError(c, 4004, "没有相关信息list")
		return
	}
	ReturnSucces(c, 0, "获取成功", users, 1)
}

dao

dao.go

package dao

import (
	"fmt"
	"gin-ranking/config"
	"time"

	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
)

// 因为要和数据库建立连接，所以我们要把链接保存到var中
var (
	Db  *gorm.DB
	err error
)

func init() {
	Db, err = gorm.Open("mysql", config.Mysqldb)
	if err != nil {
		fmt.Println("-----mysql connect error:", err)
	}
	if Db.Error != nil {
		fmt.Println("-----database err:", err)
	}

	Db.DB().SetMaxIdleConns(10)
	Db.DB().SetMaxOpenConns(100)
	Db.DB().SetConnMaxLifetime(time.Hour)
}

models

user.go

package dao

import (
	"fmt"
	"gin-ranking/config"
	"time"

	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
)

// 因为要和数据库建立连接，所以我们要把链接保存到var中
var (
	Db  *gorm.DB
	err error
)

func init() {
	Db, err = gorm.Open("mysql", config.Mysqldb)
	if err != nil {
		fmt.Println("-----mysql connect error:", err)
	}
	if Db.Error != nil {
		fmt.Println("-----database err:", err)
	}

	Db.DB().SetMaxIdleConns(10)
	Db.DB().SetMaxOpenConns(100)
	Db.DB().SetConnMaxLifetime(time.Hour)
}

router

router.go

package dao

import (
	"fmt"
	"gin-ranking/config"
	"time"

	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
)

// 因为要和数据库建立连接，所以我们要把链接保存到var中
var (
	Db  *gorm.DB
	err error
)

func init() {
	Db, err = gorm.Open("mysql", config.Mysqldb)
	if err != nil {
		fmt.Println("-----mysql connect error:", err)
	}
	if Db.Error != nil {
		fmt.Println("-----database err:", err)
	}

	Db.DB().SetMaxIdleConns(10)
	Db.DB().SetMaxOpenConns(100)
	Db.DB().SetConnMaxLifetime(time.Hour)
}