这一系列文章主要是让想进阶服务端开发的前端小伙伴们一个入门参考，后端大佬可以不用看了，很可能是浪费你的时间。

上一篇文章基于Golang的微服务——Micro实践(二)遇到问题了，我得先理解下，就当是占了个坑吧，后面我理解透了再补上。这篇记录下我尝试Gin框架遇到的问题。

Gin中文文档

学习Golang的过程中，虽然后端语言的大致思路是差不多的，但是在语言细节和语法上跟之前接触的Laravel, Node.js还是有区别的.多熟悉，多对比，更容易知道其所以然了。

Gin 是什么？

Gin 是一个用 Go (Golang) 编写的 HTTP web 框架。类比与

Node.js的web框架： express, koa

PHP的web框架：laravel, lumen , yii

Python的web框架 Django , Flask

只要你之前接触过这些，这么一类比你肯定就秒懂了。

官网右上角可以切换语言

Gin安装

Golang开发环境参照我前面写的基于Golang的微服务——上手篇文章配置就行

新建项目目录 tech, 我之前写Laravel的时候感觉代码和项目结构真的很优雅，就按照Laravel的项目结构来了。

tech
    -app
        -Controllers // 控制器函数
        -Middleware
        -Models //  数据模型
    -config // 配置文件
    -databse // 数据库
        -mysql.go
    -public // 静态资源目录
        -css
        -imgs
        -js
    -resources // 项目资源，比如放scss，通过编译转化成项目用的css
        -lang
        -sass
        -js
    -routes // 路由
        -web.go
    -views // 视图文件，这个项目会涉及到后端模板渲染和 API开发
        -usr
            -index.tmpl
        -post
            -index.tmpl
        -home
            -index.tmpl
    .env // 配置文件
    .gitignore 
    main.go //  入口文件
    README.md

附一张项目结构图：

项目包依赖用的govender,具体用法我前面的文章有写到。也可以自己查查资料。

入口文件

main.go

package main

import (
	"os"
	_ "tech/config"
	_ "tech/database"
	"tech/routes"
)

func main()  {
	r := routes.InitRouter()
	port := os.Getenv("HTTP_PORT")
	r.Run(":" + port) // 监听并在 0.0.0.0:8080 上启动服务
}

先贴下入口文件里的内容，然后根据入口文件从上到下讲解。

配置文件

_ tech/config

这里导入的是配置文件，tech/config/config.go文件源码如下：

package config

import (
	"github.com/joho/godotenv"
	"log"
	"os"
)

func init(){
	err := godotenv.Load() // 载入 godotenv
	if err != nil {
		log.Fatal("Error loading .env file")
	}

	PORT := os.Getenv("HTTP_PORT") //  获取.env配置文件里的HTTP_POTRT值
	log.Print(PORT)
}

这里涉及到了一个本地.env 文件读取的包godotenv，可以获取到项目里.env文件预设置的值

// 这里是 .env文件内容
HTTP_PORT=8090
AUTHOR=winyh

这里通过简单的配置文件演示项目的一些配置，比如项目端口号，数据库开发环境的数据库信息，都可以放到.env 如果正式环境的数据库信息放在.env里就一定要注意了，把这个配置文件添加到.gitingore忽略文件里，避免上传到远程代码仓库了。

数据库文件

_ tech/database

这里是数据库链接功能的实现，tech/database/mysql.go源码如下：

package database

import (
	"fmt"
	_ "github.com/go-sql-driver/mysql" //加载mysql驱动
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
)

var DB *gorm.DB

func init()  {
	var err error
	DB, err = gorm.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/tech?charset=utf8&parseTime=True&loc=Local&timeout=10ms")

	if err != nil {
		fmt.Printf("mysql connect error %v", err)
	}

	if DB.Error != nil {
		fmt.Printf("database error %v", DB.Error)
	}
}

项目数据库选的是mysql，所以需要先安装mysql的驱动包

go get github.com/go-sql-driver/mysql

写原生sql语句台痛苦了，所以引入一个ORM（简单粗暴的理解为一系列的原生sql 语句的封装，可以让你操作数据库更简便，会想起之前写Larvel，它自带的ORM用着是真爽，基本上是要啥有啥）

go get github.com/jinzhu/gorm

数据库的链接主要是下面这句，其中

root:是你本机的mysql用户名 123456: 是你本机的数据库密码 127.0.0.1:3306：表示数据库地址和端口号 tech:是你本机建立的数据库名称

DB, err = gorm.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/tech?charset=utf8&parseTime=True&loc=Local&timeout=10ms")

路由文件

tech/routes

入口文件里引入了routes这个包，tech/routes/web.go源码如下：

package routes

import (
	"github.com/gin-gonic/gin"
	"tech/app/Controllers"
)

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

	r.Static("/public", "./public") // 静态文件服务
	r.LoadHTMLGlob("views/**/*") // 载入html模板目录

	// web路由
	r.GET("/", Controllers.Home)
	r.GET("/about", Controllers.About)
	r.GET("/post/index", Controllers.Post)

	// 简单的路由组: v1
	v1 := r.Group("/api")
	{
		v1.GET("/ping", Controllers.Ping)
		v1.POST("/user/create", Controllers.UserCreate)
		v1.POST("/user/delete", Controllers.UserDestroy)
		v1.POST("/user/update", Controllers.UserUpdate)
		v1.POST("/users", Controllers.UserFindAll)
	}

	return r
}

后端项目基本都是MVC的模式，微服务架构可能会更简单一点。路由是一个项目对外提供服务的入口，所有的前端请求从这里进入到指定的处理函数。处理函数会操作业务逻辑，返回数据和给出响应，完成一次请求。这里引入的包"github.com/gin-gonic/gin"就是Gin框架的包。其次引入了我们自己编写的本地包"tech/app/Controllers"

我把这个路由文件里实现的功能分为了两类，一类是提供web服务的路由（也就是返回模板渲染后的html文件），一类是提供 Restful API 服务的路由。路由地址匹配我们的处理函数。

控制器

上面每个路由地址都关联有一个处理函数，我们把它叫做控制器。讲解其中的 Controllers/Home.go控制器内容，源码如下：

package Controllers

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

func Home(c *gin.Context) {
	c.HTML(http.StatusOK, "home/index.tmpl", gin.H{
		"title": "这是首页",
	})
}

基本逻辑是获取到请求的上下文，用Gin提供的c.HTML返回需要渲染返回到前台的数据。这里的title数据可以手动定义，也可以在数据库里查询到后再放入模板文件里渲染，这样看到的数据就是我们数据库里存放的数据了。

视图

视图是返回给前端的页面模板渲染文件，后端从数据库查询到的或者自定义的数据，都可以通过变量的方式渲染到模板里面，视图从后端到前端可见会经历两次渲染，第一次是后端把数据填充进去，然后用模板引擎把模板文件渲染成html,发送到前端的时候，浏览器识别到 content-Type:'text/html'，再次通过浏览器的渲染，把html标签渲染成用户可见的界面。第一次渲染是在服务器渲染的，第二次渲染是在前端渲染的。参照这里你应该可以理解前端常说的为了做SEO优化，需要用Node.js做服务端渲染是什么个意思可，可以参照我之前写的服务端渲染文章。这里贴一下 views/home/index.tmpl 模板文件的源码：

{{ define "home/index.tmpl" }}
    <html>
        <head>
            <meta charset="UTF-8">
            <title>Gin 框架测试</title>
        </head>

        <body>
        <div class="container">
            <h1>这是一个测试页面</h1>
            <p>{{ .title }}</p>
        </div>
        </body>
    </html>
{{ end }}

再列举一个 API服务的控制器，Controllers/Api.go源码如下：

package Controllers

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/jinzhu/gorm"
	"net/http"
	"tech/app/Models"
)

type Admins struct {
	gorm.Model
	Name string `json:"name"  binding:"required"`
	Password string `json:"password"  binding:"required"`
	Mobile string `json:"mobile" binding:"required"`
}

func Ping(c *gin.Context) {
	c.JSON(200, gin.H{
		"message": "pong",
	})
}

func UserCreate(c *gin.Context) {
	var json  Models.Admins //  定义json 变量 数据结构类型 为 Models.Admins
	err := c.BindJSON(&json) //  获取前台传过来的 json数据

	if err != nil {
		fmt.Printf("mysql connect error %v", err)
	}

	id, err := json.Insert()

	if err != nil {
		fmt.Printf("database error %v", err)
		fmt.Printf("database error %v", id)
		return
	}

	c.JSON(200, gin.H{ // 反馈给前台的信息，同时返回最新创建的一条数据的Id
		"status": true,
		"id":id,
		"message":"创建成功",
	})
}

func UserDestroy(c *gin.Context)  {
	var json  Models.Admins
	err := c.BindJSON(&json)
	if err != nil {
		fmt.Printf("mysql connect error %v", err)
		return
	}

	json.Destroy()

	c.JSON(200, gin.H{
		"status": true,
		"message":"删除成功",
	})
}

func UserUpdate(c *gin.Context) {
	var json  Models.Admins
	err := c.BindJSON(&json)

	if err != nil {
		fmt.Printf("mysql connect error %v", err)
	}

	id, err := json.Update(3)

	if err != nil {
		fmt.Printf("database error %v", err)
		fmt.Printf("database error %v", id)
		return
	}

	c.JSON(200, gin.H{
		"status": true,
		"id":id,
		"message":"更新成功",
	})
}

func UserFindAll(c *gin.Context)  {
	var json  Models.Admins
	err := c.BindJSON(&json)

	if err != nil {
		fmt.Printf("mysql connect error %v", err)
	}

	result, err := json.FindAll()

	if err != nil {
		c.JSON(http.StatusOK, gin.H{
			"status":  false,
			"message": "抱歉未找到相关信息",
		})
		return
	}

	c.JSON(200, gin.H{
		"status": true,
		"data": result,
		"message":"查询成功",
	})
}

这个文件里完成了后端基本的增删改查功能。内容相对多点，列举其中的用户新建来说一下： UserCreate 函数会接收到前台传过来的json数据，然后调用 id, err := json.Insert() 做数据入库的操作。这里涉及到 Insert函数，也就是接下来要降到的数据模型

数据模型

数据模型是数据的抽象，可以提供一些数据操作的函数封装。 app/Models/admin.go 源码如下：

package Models

import (
	"github.com/jinzhu/gorm"
	. "tech/database"
)

type Admins struct {
	gorm.Model  // 这里的配置可以让ORM 自动维护 时间戳字段，很爽有木有
	Name string `json:"name"  binding:"required"`
	Password string `json:"password"  binding:"required"`
	Mobile string `json:"mobile" binding:"required"`
}

// Insert 新增admin用户
func (admin *Admins) Insert() (userID uint, err error) {

	result := DB.Create(&admin) //  这里的DB变量是 database 包里定义的，Create 函数是 gorm包的创建数据API
	userID = admin.ID
	if result.Error != nil {
		err = result.Error
	}
	return  // 返回新建数据的id 和 错误信息，在控制器里接收
}

// Destroy 删除admin用户
func (admin *Admins) Destroy() (err error) {

	result := DB.Delete(&admin)
	if result.Error != nil {
		err = result.Error
	}
	return
}


// Update 修改admin用户
func (admin *Admins) Update(id int64) (user Admins, err error) {
	result := DB.Model(&admin).Where("id = ?", id).Updates(&admin)
	if result.Error != nil {
		err = result.Error
	}
	return
}


// FindOne 查询admin用户
func (admin *Admins) FindAll() (admins []Admins, err error) {

	result := DB.Find(&admins) // 这里的 &admins 跟返回参数要一致

	if result.Error != nil {
		err = result.Error
		return
	}
	return
}