本节核心内容

• 介绍项目的目录结构
• 介绍包括文件读取、日志、mysql、路由、http、json数据处理等技术
• 介绍自定义错误码
• 通过实战代码演练创建一个基础的web项目

本小节视频教程和代码：百度网盘，密码z2ua

可先下载视频和源码到本地，边看视频边结合源码理解后续内容，边学边练。

HTTP API 服务器启动流程

目录结构

在开发中，一个良好的目录结构是很重要的，好的目录结构不仅能使项目结构清晰，也能让后加入者快速了解项目，便于上手。

├── conf                         # 配置文件统一存放目录
│   ├── config.yaml              # 配置文件
├── config                       # 专门用来处理配置和配置文件的Go package
│   └── config.go                 
├── db.sql                       # 在部署新环境时，可以登录MySQL客户端，执行source db.sql创建数据库和表
├── handler                      # 类似MVC架构中的C，用来读取输入，并将处理流程转发给实际的处理函数，最后返回结果
│   ├── handler.go
│   ├── sd                       # 健康检查handler
│   │   └── check.go 
│   └── user                     # 核心：用户业务逻辑handler
│       ├── create.go            # 新增用户
│       └── user.go              # 存放用户handler公用的函数、结构体等
├── main.go                      # Go程序唯一入口
├── Makefile                     # Makefile文件，一般大型软件系统都是采用make来作为编译工具
├── model                        # 数据库相关的操作统一放在这里，包括数据库初始化和对表的增删改查
│   ├── init.go                  # 初始化和连接数据库
│   ├── model.go                 # 存放一些公用的go struct
│   └── user.go                  # 用户相关的数据库CURD操作
├── pkg                          # 引用的包
│   ├── constvar                 # 常量统一存放位置
│   │   └── constvar.go
│   ├── errno                    # 错误码存放位置
│   │   ├── code.go
│   │   └── errno.go
├── README.md                    # API目录README
├── router                       # 路由相关处理
│   ├── middleware               # API服务器用的是Gin Web框架，Gin中间件存放位置
│   │   ├── header.go
│   │   ├── logging.go
│   │   └── requestid.go
│   └── router.go                # 路由
├── service                      # 实际业务处理函数存放位置
│   └── service.go
├── util                         # 工具类函数存放目录
│   ├── util.go 
│   └── util_test.go
└── vendor                         # vendor目录用来管理依赖包├── github.com├── golang.org├── gopkg.in└── vendor.json

读取配置文件和配置日志对象

配置文件：

mysql:#最大空闲连接数max_idle_conns: 50#链接source_name: root:root@tcp(127.0.0.1:3306)/devops?parseTime=true&charset=utf8&loc=Local
addr: 127.0.0.1:8083                  # HTTP绑定端口

代码：

package configimport ("github.com/spf13/viper""time""os""log"
)// LogInfo 初始化日志配置
func LogInfo()   {file := "./" + time.Now().Format("2006-01-02") + ".log"logFile, _ := os.OpenFile(file,os.O_RDWR| os.O_CREATE| os.O_APPEND, 0766)log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)log.SetOutput(logFile)
}// Init 读取初始化配置文件
func Init() error {// 初始化配置文件if err := Config(); err != nil {return err}// 初始化日志包LogInfo()return nil
}// Config viper解析配置文件
func Config() error  {viper.AddConfigPath("conf")viper.SetConfigName("config")if err := viper.ReadInConfig(); err != nil {return err}return nil
}

配置Mysql

准备表数据

CREATE TABLE `user` (`id` bigint(20) NOT NULL AUTO_INCREMENT,`name` varchar(20) DEFAULT '',`age` int(11) DEFAULT '0',PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4

init初始化代码:

package modelimport ("database/sql""log"_ "github.com/go-sql-driver/mysql" //这个引用是必不可少的，因为需要调用driver.go文件里的init方法来提供一个数据库驱动程序"github.com/spf13/viper"
)var DB *sql.DB     //全局变量，这样可以在别处调用func Init() error {var err error//这行代码的作用就是初始化一个sql.DB对象DB ,err = sql.Open("mysql", viper.GetString("mysql.source_name"))if nil != err {return err}//设置最大超时时间DB.SetMaxIdleConns(viper.GetInt("mysql.max_idle_conns"))//建立链接err = DB.Ping()if nil != err{return err}else{log.Println("Mysql Startup Normal!")}return nil
}

model代码：

package modelimport ("log""fmt"
)//	Insert 插入操作
func Insert(sql string,args... interface{})(int64,error) {stmt, err := DB.Prepare(sql)defer stmt.Close()if err != nil{return 1,err}result, err := stmt.Exec(args...)if err != nil{return 1,err}id, err := result.LastInsertId()if err != nil{return 1,err}fmt.Printf("插入成功，ID为%v\n",id)return id,nil
}//	Delete 删除操作
func Delete(sql string,args... interface{})  {stmt, err := DB.Prepare(sql)defer stmt.Close()CheckErr(err, "SQL语句设置失败")result, err := stmt.Exec(args...)CheckErr(err, "参数添加失败")num, err := result.RowsAffected()CheckErr(err,"删除失败")fmt.Printf("删除成功，删除行数为%d\n",num)
}//	Update 修改操作
func Update(sql string,args... interface{})  {stmt, err := DB.Prepare(sql)defer stmt.Close()CheckErr(err, "SQL语句设置失败")result, err := stmt.Exec(args...)CheckErr(err, "参数添加失败")num, err := result.RowsAffected()CheckErr(err,"修改失败")fmt.Printf("修改成功，修改行数为%d\n",num)
}// CheckErr 用来校验error对象是否为空
func CheckErr(err error,msg string)  {if nil != err {log.Panicln(msg,err)}
}

准备数据库表和对应实体类对象

user.db数据：

/*
Navicat MySQL Data TransferSource Server         : localhost
Source Server Version : 50625
Source Host           : 127.0.0.1:3306
Source Database       : testTarget Server Type    : MYSQL
Target Server Version : 50625
File Encoding         : 65001Date: 2019-02-17 22:47:26
*/SET FOREIGN_KEY_CHECKS=0;-- ----------------------------
-- Table structure for `user`
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (`id` bigint(20) NOT NULL AUTO_INCREMENT,`user_name` varchar(20) NOT NULL DEFAULT '',`password` varchar(20) NOT NULL DEFAULT '0',PRIMARY KEY (`id`),KEY `id` (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4;-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'admin', '12164');

实体类：

type User struct {UserName 	string `json:"user_name"`Password 	string `json:"password"`
}

自定义错误码

error相关代码：

package errnoimport "fmt"type Errno struct {Code    intMessage string
}func (err Errno) Error() string {return err.Message
}// Err represents an error
type Err struct {Code    intMessage stringErr     error
}func New(errno *Errno, err error) *Err {return &Err{Code: errno.Code, Message: errno.Message, Err: err}
}func (err *Err) Add(message string) error {err.Message += " " + messagereturn err
}func (err *Err) Addf(format string, args ...interface{}) error {err.Message += " " + fmt.Sprintf(format, args...)return err
}func (err *Err) Error() string {return fmt.Sprintf("Err - code: %d, message: %s, error: %s", err.Code, err.Message, err.Err)
}func IsErrUserNotFound(err error) bool {code, _ := DecodeErr(err)return code == ErrUserNotFound.Code
}func DecodeErr(err error) (int, string) {if err == nil {return OK.Code, OK.Message}switch typed := err.(type) {case *Err:return typed.Code, typed.Messagecase *Errno:return typed.Code, typed.Messagedefault:}return InternalServerError.Code, err.Error()
}

定义code错误码：

package errnovar (// Common errorsOK                  = &Errno{Code: 0, Message: "OK"}InternalServerError = &Errno{Code: 10001, Message: "Internal server error"}ErrBind             = &Errno{Code: 10002, Message: "Error occurred while binding the request body to the struct."}ErrValidation = &Errno{Code: 20001, Message: "Validation failed."}ErrDatabase   = &Errno{Code: 20002, Message: "Database error."}// user errorsErrUserNotFound      = &Errno{Code: 20101, Message: "The user was not found."}ErrPasswordIncorrect = &Errno{Code: 20102, Message: "The password was incorrect."}
)

定义响应的handler

package handlerimport ("net/http""apiserver/pkg/errno""github.com/gin-gonic/gin"
)type Response struct {Code    int         `json:"code"`Message string      `json:"message"`Data    interface{} `json:"data"`
}func SendResponse(c *gin.Context, err error, data interface{}) {code, message := errno.DecodeErr(err)// always return http.StatusOKc.JSON(http.StatusOK, Response{Code:    code,Message: message,Data:    data,})
}

创建路由

使用中间件控制请求头：

middleware代码：

package middlewareimport ("net/http""time""github.com/gin-gonic/gin"
)// NoCache is a middleware function that appends headers
// to prevent the client from caching the HTTP response.
func NoCache(c *gin.Context) {c.Header("Cache-Control", "no-cache, no-store, max-age=0, must-revalidate, value")c.Header("Expires", "Thu, 01 Jan 1970 00:00:00 GMT")c.Header("Last-Modified", time.Now().UTC().Format(http.TimeFormat))c.Next()
}// Options is a middleware function that appends headers
// for options requests and aborts then exits the middleware
// chain and ends the request.
func Options(c *gin.Context) {if c.Request.Method != "OPTIONS" {c.Next()} else {c.Header("Access-Control-Allow-Origin", "*")c.Header("Access-Control-Allow-Methods", "GET,POST,PUT,PATCH,DELETE,OPTIONS")c.Header("Access-Control-Allow-Headers", "authorization, origin, content-type, accept")c.Header("Allow", "HEAD,GET,POST,PUT,PATCH,DELETE,OPTIONS")c.Header("Content-Type", "application/json")c.AbortWithStatus(200)}
}// Secure is a middleware function that appends security
// and resource access headers.
func Secure(c *gin.Context) {c.Header("Access-Control-Allow-Origin", "*")c.Header("X-Frame-Options", "DENY")c.Header("X-Content-Type-Options", "nosniff")c.Header("X-XSS-Protection", "1; mode=block")if c.Request.TLS != nil {c.Header("Strict-Transport-Security", "max-age=31536000")}// Also consider adding Content-Security-Policy headers// c.Header("Content-Security-Policy", "script-src 'self' https://cdnjs.cloudflare.com")
}

router代码：

package routerimport ("net/http""myapi/service""myapi/router/middleware""github.com/gin-gonic/gin"
)//InitRouter 初始化路由
func InitRouter(g *gin.Engine) {middlewares := []gin.HandlerFunc{}// Middlewares.g.Use(gin.Recovery())g.Use(middleware.NoCache)g.Use(middleware.Options)g.Use(middleware.Secure)g.Use(middlewares...)// 404 Handler.g.NoRoute(func(c *gin.Context) {c.String(http.StatusNotFound, "The incorrect API route.")})// The health check handlersrouter := g.Group("/user"){router.POST("/addUser", service.AddUser)					//添加用户router.POST("/selectUser", service.SelectUser)			//查询用户}}

处理路由

service层

package serviceimport ("github.com/gin-gonic/gin""myapi/model". "myapi/handler""myapi/pkg/error""fmt"
)func AddUser(c *gin.Context)  {var r model.Userif err := c.Bind(&r); err != nil {SendResponse(c, errno.ErrBind, nil)return}u := model.User{UserName: r.UserName,Password: r.Password,}// Validate the data.if err := u.Validate(); err != nil {SendResponse(c, errno.ErrValidation, nil)return}// Insert the user to the database.if _,err := u.Create(); err != nil {SendResponse(c, errno.ErrDatabase, nil)return}// Show the user information.SendResponse(c, nil, u)
}// SelectUser 查询用户
func SelectUser(c *gin.Context)  {name := c.Query("user_name")if name == ""{SendResponse(c, errno.ErrValidation, nil)return}var  user model.Userif err := user.SelectUserByName(name);nil != err {fmt.Println(err)SendResponse(c, errno.ErrUserNotFound, nil)return}// Validate the data.if err := user.Validate(); err != nil {SendResponse(c, errno.ErrUserNotFound, nil)return}SendResponse(c, nil, user)
}

数据库层

package modelimport ("errors""myapi/pkg/error""encoding/json""log"
)type User struct {UserName 	string `json:"user_name"`Password 	string `json:"password"`
}func (user *User)SelectUserByName(name string)error {stmt,err := DB.Prepare("SELECT user_name,password FROM user WHERE user_name=?")if err != nil {return err}defer stmt.Close()rows, err := stmt.Query(name)defer rows.Close()if err != nil {return err}// 数据处理for rows.Next() {rows.Scan( &user.UserName, &user.Password)}if err := rows.Err(); err != nil {return err}return nil
}// Validate the fields.
func (u *User) Validate() error {if u.UserName =="" || u.Password ==""{return errors.New(errno.ErrValidation.Message)}return nil
}
func (user *User) Create() (int64,error)  {id,err := Insert("INSERT INTO  user(user_name,password) values (?,?)", user.UserName, user.Password)if err != nil {return 1,err}return id,nil
}func (user *User)UserToJson()string  {jsonStr, err := json.Marshal(user)if err != nil {log.Println(err)}return string(jsonStr)
}func (user *User)JsonToUser(jsonBlob string)error  {err := json.Unmarshal([]byte(jsonBlob), &user)if err != nil {return err}return nil
}

main方法

package mainimport ("myapi/config""myapi/model""github.com/gin-gonic/gin""log""github.com/spf13/viper""myapi/router"
)func main() {if err := config.Init();err != nil {panic(err)}if err := model.Init();err != nil {panic(err)}//g := gin.Default()// Set gin mode.gin.SetMode(viper.GetString("runmode"))// Create the Gin engine.g := gin.New()router.InitRouter(g)log.Printf("Start to listening the incoming requests on http address: %s\n", viper.GetString("addr"))//log.Println(http.ListenAndServe(viper.GetString("addr"), g).Error())if err := g.Run(viper.GetString("addr"));err != nil {log.Fatal("ListenAndServe:", err)}}

Json格式处理

func (user *User)UserToJson()string  {jsonStr, err := json.Marshal(user)if err != nil {log.Println(err)}return string(jsonStr)
}func (user *User)JsonToUser(jsonBlob string)error  {err := json.Unmarshal([]byte(jsonBlob), &user)if err != nil {return err}return nil
}

小节

本小节主要通过结合之前讲过的知识点，将知识点串联起来，带领大家实现一个简单的项目，创建一个项目的步骤可大致分为下面几步：

• 创建数据库表
• 创建项目和目录结构
• 读取配置文件和配置日志对象
• 配置Mysql
• 自定义错误码
• 定义响应的handler层
• 定义路由
• 处理路由
  • service层
  • sql层
• 一些数据格式的处理
  • 如结构体和Json的格式处理
• main方法