Go 项目结构：美化你的 Golang 项目

美化你的 Golang 项目#

伴随着你的代码一同构建你的 golang 项目

我最近的文章中，我创建了一个无组织的服务，它只针对初学者。我的动机是提供一个创建 REST 服务的基本概念，并且它能够一步一步的迭代前进。

如果你不熟悉我之前的文章，你可以通过以下链接了解功能。乍一看不难，如果你之前已经了解关于构建 web API 服务的知识那么你可以进行以下内容的学习。

https://itnext.io/building-restful-web-api...

在本教程中，我将告诉你如何构建一个项目。组织的代码很重要是因为当您希望更改以前代码的某些逻辑时，那么结构良好的项目可以很容易地调整这些变化并节省时间。尽管在项目的结构上会有种种矛盾之处，但我更喜欢 4 层的结构。您可以从这里替换或修改任何内容。

project/
    model/
    repository/
    handler/
    driver/
    main.go

models#

这一层将会存放 model 的 struct 并且它能够被其他层使用到。现在我们把 post（文章）model struct 移动到 models/post.go 文件。如果我们有另一个 model 像 author（作者）那么这些模型也会存放到这一层。我们也会增加 error.go 文件。

error.go 包含你新创建文件的错误。详情参见这里 here.

repository#

repository 目录负责与数据库有关的工作，例如查询，插入 / 存储或删除。
此处未实现任何业务逻辑。

首先，我在 repository 目录下创建了 repository.go 文件。此文件用于保存您所有与 repository 相关的接口。如果我们为 author 实例或其他内容设置了其他域，则此处包含接口中的所有 author 方法。

如果您注意到上图的左侧，我已经创建了一个名叫 post 的文件夹。我们将在 post /post_mysql.go 文件中实现我们的接口。为什么后缀为 MySQL？如果我们使用另一个数据库，例如 mongo 或 redis ，那么我们将创建 post_mongo.go（无论您叫什么），并实现与 mongo 相关的查询。

package post

import (
    "context"
    "database/sql"

    models "github.com/s1s1ty/go-mysql-crud/models"
    pRepo "github.com/s1s1ty/go-mysql-crud/repository"
)

// NewSQLPostRepo retunrs implement of post repository interface
func NewSQLPostRepo(Conn *sql.DB) pRepo.PostRepo {
    return &mysqlPostRepo{
        Conn: Conn,
    }
}

type mysqlPostRepo struct {
    Conn *sql.DB
}

func (m *mysqlPostRepo) fetch(ctx context.Context, query string, args ...interface{}) ([]*models.Post, error) {
    rows, err := m.Conn.QueryContext(ctx, query, args...)
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    payload := make([]*models.Post, 0)
    for rows.Next() {
        data := new(models.Post)

        err := rows.Scan(
            &data.ID,
            &data.Title,
            &data.Content,
        )
        if err != nil {
            return nil, err
        }
        payload = append(payload, data)
    }
    return payload, nil
}

func (m *mysqlPostRepo) Fetch(ctx context.Context, num int64) ([]*models.Post, error) {
    query := "Select id, title, content From posts limit ?"

    return m.fetch(ctx, query, num)
}

func (m *mysqlPostRepo) GetByID(ctx context.Context, id int64) (*models.Post, error) {
    query := "Select id, title, content From posts where id=?"

    rows, err := m.fetch(ctx, query, id)
    if err != nil {
        return nil, err
    }

    payload := &models.Post{}
    if len(rows) > 0 {
        payload = rows[0]
    } else {
        return nil, models.ErrNotFound
    }

    return payload, nil
}

func (m *mysqlPostRepo) Create(ctx context.Context, p *models.Post) (int64, error) {
    query := "Insert posts SET title=?, content=?"

    stmt, err := m.Conn.PrepareContext(ctx, query)
    if err != nil {
        return -1, err
    }

    res, err := stmt.ExecContext(ctx, p.Title, p.Content)
    defer stmt.Close()

    if err != nil {
        return -1, err
    }

    return res.LastInsertId()
}

func (m *mysqlPostRepo) Update(ctx context.Context, p *models.Post) (*models.Post, error) {
    query := "Update posts set title=?, content=? where id=?"

    stmt, err := m.Conn.PrepareContext(ctx, query)
    if err != nil {
        return nil, err
    }
    _, err = stmt.ExecContext(
        ctx,
        p.Title,
        p.Content,
        p.ID,
    )
    if err != nil {
        return nil, err
    }
    defer stmt.Close()

    return p, nil
}

func (m *mysqlPostRepo) Delete(ctx context.Context, id int64) (bool, error) {
    query := "Delete From posts Where id=?"

    stmt, err := m.Conn.PrepareContext(ctx, query)
    if err != nil {
        return false, err
    }
    _, err = stmt.ExecContext(ctx, id)
    if err != nil {
        return false, err
    }
    return true, nil
}

代码已被折叠，点此展开

post_mysql.go 必须满足 PostRepo 接口。如果要添加任何其他方法，则必须将其包括在接口中，并在 post_mysql.go 文件上实现。

处理程序#

基本上，处理程序文件夹可以委托给存储库，因为这一层决定了将使用哪个存储库层。任何过程都在这里处理。该层接受请求，调用存储库层并满足业务流程并发送响应。

package handler

import (
    "encoding/json"
    "fmt"
    "net/http"
    "strconv"

    "github.com/go-chi/chi"
    "github.com/s1s1ty/go-mysql-crud/driver"
    models "github.com/s1s1ty/go-mysql-crud/models"
    repository "github.com/s1s1ty/go-mysql-crud/repository"
    post "github.com/s1s1ty/go-mysql-crud/repository/post"
)

// NewPostHandler ...
func NewPostHandler(db *driver.DB) *Post {
    return &Post{
        repo: post.NewSQLPostRepo(db.SQL),
    }
}

// Post ...
type Post struct {
    repo repository.PostRepo
}

// Fetch all post data
func (p *Post) Fetch(w http.ResponseWriter, r *http.Request) {
    payload, _ := p.repo.Fetch(r.Context(), 5)

    respondwithJSON(w, http.StatusOK, payload)
}

// Create a new post
func (p *Post) Create(w http.ResponseWriter, r *http.Request) {
    post := models.Post{}
    json.NewDecoder(r.Body).Decode(&post)

    newID, err := p.repo.Create(r.Context(), &post)
    fmt.Println(newID)
    if err != nil {
        respondWithError(w, http.StatusInternalServerError, "Server Error")
    }

    respondwithJSON(w, http.StatusCreated, map[string]string{"message": "Successfully Created"})
}

// Update a post by id
func (p *Post) Update(w http.ResponseWriter, r *http.Request) {
    id, _ := strconv.Atoi(chi.URLParam(r, "id"))
    data := models.Post{ID: int64(id)}
    json.NewDecoder(r.Body).Decode(&data)
    payload, err := p.repo.Update(r.Context(), &data)

    if err != nil {
        respondWithError(w, http.StatusInternalServerError, "Server Error")
    }

    respondwithJSON(w, http.StatusOK, payload)
}

// GetByID returns a post details
func (p *Post) GetByID(w http.ResponseWriter, r *http.Request) {
    id, _ := strconv.Atoi(chi.URLParam(r, "id"))
    payload, err := p.repo.GetByID(r.Context(), int64(id))

    if err != nil {
        respondWithError(w, http.StatusNoContent, "Content not found")
    }

    respondwithJSON(w, http.StatusOK, payload)
}

// Delete a post
func (p *Post) Delete(w http.ResponseWriter, r *http.Request) {
    id, _ := strconv.Atoi(chi.URLParam(r, "id"))
    _, err := p.repo.Delete(r.Context(), int64(id))

    if err != nil {
        respondWithError(w, http.StatusInternalServerError, "Server Error")
    }

    respondwithJSON(w, http.StatusMovedPermanently, map[string]string{"message": "Delete Successfully"})
}

// respondwithJSON write json response format
func respondwithJSON(w http.ResponseWriter, code int, payload interface{}) {
    response, _ := json.Marshal(payload)

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(code)
    w.Write(response)
}

// respondwithError return error message
func respondWithError(w http.ResponseWriter, code int, msg string) {
    respondwithJSON(w, code, map[string]string{"message": msg})
}

代码已被折叠，点此展开

处理程序层还包含几种协议实现，例如 RPC，REST 等，并与其他文件夹隔离。

驱动#

在我们的结构中，驱动程序层由我们所有的数据库连接描述。该层负责与数据库连接，并将连接对象发送到控制器。

package driver

import (
    "database/sql"
    "fmt"

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

// DB ...
type DB struct {
    SQL *sql.DB
    // Mgo *mgo.database
}

// DBConn ...
var dbConn = &DB{}

// ConnectSQL ...
func ConnectSQL(host, port, uname, pass, dbname string) (*DB, error) {

    dbSource := fmt.Sprintf(
        "root:%s@tcp(%s:%s)/%s?charset=utf8",
        pass,
        host,
        port,
        dbname,
    )
    d, err := sql.Open("mysql", dbSource)
    if err != nil {
        panic(err)
    }
    dbConn.SQL = d
    return dbConn, err
}

// ConnectMgo ....
func ConnectMgo(host, port, uname, pass string) error {

    return nil
}

在这里，我们将使用 main.go 而不是控制器，因为我们的服务只有一个具有 CRUD 操作的域。

package main

import (
    "fmt"
    "net/http"
    "os"

    "github.com/go-chi/chi"
    "github.com/go-chi/chi/middleware"
    "github.com/s1s1ty/go-mysql-crud/driver"
    ph "github.com/s1s1ty/go-mysql-crud/handler/http"
)

func main() {
    dbName := os.Getenv("DB_NAME")
    dbPass := os.Getenv("DB_PASS")
    dbHost := os.Getenv("DB_HOST")
    dbPort := os.Getenv("DB_PORT")

    println("this is db", dbName, dbHost, dbPass, dbPort)

    connection, err := driver.ConnectSQL(dbHost, dbPort, "root", dbPass, dbName)
    if err != nil {
        fmt.Println(err)
        os.Exit(-1)
    }

    r := chi.NewRouter()
    r.Use(middleware.Recoverer)
    r.Use(middleware.Logger)

    pHandler := ph.NewPostHandler(connection)
    r.Get("/posts", pHandler.Fetch)
    r.Get("/posts/{id}", pHandler.GetByID)
    r.Post("/posts/create", pHandler.Create)
    r.Put("/posts/update/{id}", pHandler.Update)
    r.Delete("/posts/{id}", pHandler.Delete)

    fmt.Println("Server listen at :8005")
    http.ListenAndServe(":8005", r)
}

从 main.go，我们将提供所有数据库凭据并与数据库连接。我们阅读了 docker-compose 文件中提供的环境变量中的数据库凭证。我们还将所有路线保留在此处，但您可以将其隔离。

示例项目#

您可以在此处查看示例项目。 here

https://github.com/s1s1ty/go-mysql-crud
我也鼓励您添加测试文件。同样，任何设计都不像圣经，我们必须根据我们的项目定义，业务逻辑等来实施它。

结论#

您可以通过下面的链接了解有关此主题的更多信息。

https://8thlight.com/blog/uncle-bob/2012/0...
http://blog.ralch.com/tutorial/design-patt...
https://hackernoon.com/golang-clean-archit...
您可以观看 bob 叔叔的视频，很有趣。

Bilibili 国内搬运视频地址：https://www.bilibili.com/video/av68574027?...

最后，如果您发现我的任何错误，可以在下面的评论部分给我开枪。您也可以在我的 GitHub 仓库上向我发送 PR。

本文中的所有译文仅用于学习和交流目的，转载请务必注明文章译者、出处、和本文链接
我们的翻译工作遵照 CC 协议，如果我们的工作有侵犯到您的权益，请及时联系我们。

原文地址：https://itnext.io/beautify-your-golang-p...

译文地址：https://learnku.com/go/t/39426

Go 项目结构：美化你的 Golang 项目

美化你的 Golang 项目#

models#

repository#

处理程序#

驱动#

示例项目#

结论#

推荐文章：

社区赞助商

关于 LearnKu

资源推荐

服务提供商

其他信息

Go 项目结构：美化你的 Golang 项目

美化你的 Golang 项目#

models#

repository#

处理程序#

驱动#

示例项目#

结论#

推荐文章：

社区赞助商

关于 LearnKu

资源推荐

服务提供商

其他信息

请登录