GoLang 后端入门

简单 (非技术框架) 实现的 Go 后端

~~众所周知，~~后端的开发一般是面向接口的开发，也可以说是 CRUD 工程师，本文章将使用 Go 描述从数据库读出数据，然后返回 JSON 数据

数据库

例子为从 MySQL 数据库的分类表，读出分类的名称与 ID，数据库的结构如下

DROP TABLE IF EXISTS categories ;
CREATE TABLE categories (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    description VARCHAR(255)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

项目结构

本例子的项目结构如下

project/
├── database/       // 数据库包
│   └── database.go // 数据库连接
├── handler/        // 处理器包
│   └── category.go // 分类相关接口
├── model/          // 数据模型包
│   ├── category.go // 分类表模型
│   └── response.go // 响应数据模型
├── router/         // 路由包
│   └── router.go   // 路由配置
├── utils           // 工具包
│   └── response.go // 统一响应
├── main.go         // 程序入口

接下来将分目录说明

database

该包是管理与数据库的连接

// database.go
package database

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql"
)

var DB *sql.DB

func InitDB() {
    var err error

    dsn := "username:password@tcp(address:3306)/name?charset=utf8"
    DB, err = sql.Open("mysql", dsn)
    if err != nil {
        log.Fatalf("Failed to open database: %v", err)
    }

    // Test Connect
    err = DB.Ping()
    if err != nil {
        log.Fatalf("Failed to ping database: %v", err)
    }

    fmt.Println("Successfully connected Database!")
}

handler

这个包是对于特定处理的逻辑 (类似于三层架构的 service)，其中数据库处理还可以分层 (类似于 Mapper)，但这只是一个简单的示例，就酱子啦~

// category.go
package handler

import (
    "net/http"
    "project/database"
    "project/model"
    "project/utils"
)

func GetCategories(w http.ResponseWriter, r *http.Request) {
    // Select Database
    rows, err := database.DB.Query("select id,name from categories")
    if err != nil {
        http.Error(w, "Failed to query Categories", http.StatusInternalServerError)
        return
    }
    defer rows.Close()

    // analyze data
    var categories []model.Category
    for rows.Next() {
        var category model.Category
        err = rows.Scan(&category.Id, &category.Name)
        if err != nil {
            utils.JSONResponse(w, http.StatusInternalServerError, "Failed to analyze Categories", nil)
            //http.Error(w, "Failed to analyze Categories", http.StatusInternalServerError)
            return
        }
        categories = append(categories, category)
    }

    // return JSON
    //w.Header().Set("Content-Type", "application/json")
    //json.NewEncoder(w).Encode(categories)
    utils.JSONResponse(w, http.StatusOK, "", categories)
}

注释掉的内容为不适用统一响应接口，直接返回 JSON 的情况

model

这里的数据模型一般可以分为三个，从前端接收到的、数据库的以及返回给前端的，由于这只是一个简单的示例，所以我并没有细分

// category.go
package model

type Category struct {
    Id          int    `json:"id"`
    Name        string `json:"name"`
    Description string `json:"description"`
}

响应的数据模型为

package model

type Response struct {
    Code int         `json:"code"`
    Msg  string      `json:"msf"`
    Data interface{} `json:"data"`
}

router

该包管理路由，即访问了什么路径要指定相应的处理逻辑 (类似于三层架构的 controller)

// router.go
package router

import (
    "github.com/gorilla/mux"
    "project/handler"
)

func InitRouter() *mux.Router {
    router := mux.NewRouter()
    router.HandleFunc("/categories", handler.GetCategories).Methods("GET")
    return router
}

utils

该包为工具类，用于定义可以通用的工具

// response.go
package utils

import (
    "encoding/json"
    "log"
    "net/http"
    "project/model"
)

func JSONResponse(w http.ResponseWriter, code int, message string, data interface{}) {
    w.Header().Set("Content-Type", "application/json; charset=utf-8")
    w.WriteHeader(http.StatusOK)
    err := json.NewEncoder(w).Encode(model.Response{Code: code, Msg: message, Data: data})
    if err != nil {
        log.Fatal(err)
        return
    }
}

main

程序的入口

// main.go
package main

import (
    "log"
    "net/http"
    "project/database"
    "project/router"
)

func main() {
    // init Database
    database.InitDB()

    // Init Router
    r := router.InitRouter()

    // start
    log.Println("Starting server on port 8848")
    log.Fatal(http.ListenAndServe(":8848", r))
}

运行 go run main.go，程序将监听 8848 端口