Go語言從入門到精通 -【web項目實戰篇】- 完整的web項目

本節核心內容

• 介紹項目的目錄結構
• 介紹包括文件讀取、日誌、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 config

import (
    "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 model

import (
    "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 model

import (
    "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 Transfer

Source Server         : localhost
Source Server Version : 50625
Source Host           : 127.0.0.1:3306
Source Database       : test

Target Server Type    : MYSQL
Target Server Version : 50625
File Encoding         : 65001

Date: 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 errno

import "fmt"

type Errno struct {
    Code    int
    Message string
}

func (err Errno) Error() string {
    return err.Message
}

// Err represents an error
type Err struct {
    Code    int
    Message string
    Err     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 += " " + message
    return 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.Message
    case *Errno:
        return typed.Code, typed.Message
    default:
    }

    return InternalServerError.Code, err.Error()
}

定義code錯誤碼：

package errno

var (
    // Common errors
    OK                  = &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 errors
    ErrUserNotFound      = &Errno{Code: 20101, Message: "The user was not found."}
    ErrPasswordIncorrect = &Errno{Code: 20102, Message: "The password was incorrect."}
)

定義響應的handler

package handler

import (
    "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.StatusOK
    c.JSON(http.StatusOK, Response{
        Code:    code,
        Message: message,
        Data:    data,
    })
}

創建路由

使用中間件控制請求頭：

middleware代碼：

package middleware

import (
    "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 router

import (
    "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 handlers
    router := g.Group("/user")
    {
        router.POST("/addUser", service.AddUser)                    //添加用戶
        router.POST("/selectUser", service.SelectUser)          //查詢用戶
    }

}

處理路由

service層

package service

import (
    "github.com/gin-gonic/gin"
    "myapi/model"
    . "myapi/handler"
    "myapi/pkg/error"
    "fmt"
)

func AddUser(c *gin.Context)  {
    var r model.User
    if 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.User
    if 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 model

import (
    "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 main

import (
    "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方法