如何在 Go 中组织项目结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

package articles

import (
    "context"
)

// Repo defines the DB level interaction of articles
type Repo interface {
    Get(ctx context.Context, id string) (Article, error)
    Create(ctx context.Context, ar ArticleCreateUpdate) (string, error)
}

// Service defines the service level contract that other services
// outside this package can use to interact with Article resources
type Service interface {
    Get(ctx context.Context, id string) (Article, error)
    Create(ctx context.Context, ar ArticleCreateUpdate) (Article, error)
}

type article struct {
    repo Repo
}

// New Service instance
func New(repo Repo) Service {
    return &article{repo}
}

// Get sends the request straight to the repo
func (s *article) Get(ctx context.Context, id string) (Article, error) {
    return s.repo.Get(ctx, id)
}

// Create passes of the created to the repo and retrieves the newly created record
func (s *article) Create(ctx context.Context, ar ArticleCreateUpdate) (Article, error) {
    id, err := s.repo.Create(ctx, ar)
    if err != nil {
        return Article{}, err
    }
    return s.repo.Get(ctx, id)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package transport

import (
    "database/sql"
    "net/http"

    "github.com/gin-gonic/gin"

    "github.com/kott/go-service-example/pkg/services/articles"
    "github.com/kott/go-service-example/pkg/services/articles/store"
)

type handler struct {
    ArticleService articles.Service
}

// Activate sets all the services required for articles and registers all the endpoints with the engine.
func Activate(router *gin.Engine, db *sql.DB) {
    articleService := articles.New(store.New(db))
    newHandler(router, articleService)
}

func newHandler(router *gin.Engine, as articles.Service) {
    h := handler{
        ArticleService: as,
    }
    router.GET("/articles/:id", h.Get)
    router.POST("/articles/", h.Create)
}

func (h *handler) Get(c *gin.Context) {...}

func (h *handler) Create(c *gin.Context) {...}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

package api

import (
    "context"
    "fmt"

    "github.com/gin-gonic/gin"

    "github.com/kott/go-service-example/pkg/db"
    articles "github.com/kott/go-service-example/pkg/services/articles/transport"
    "github.com/kott/go-service-example/pkg/utils/log"
    "github.com/kott/go-service-example/pkg/utils/middleware"
)

// Config defines what the API requires to run
type Config struct {
    DBHost       string
    DBPort       int
    DBUser       string
    DBPassword   string
    DBName       string
    AppHost string
    AppPort int
}

// Start initializes the API server, adding the required middleware and dependent services
func Start(cfg *Config) {
    conn, err := db.GetConnection(
        cfg.DBHost,
        cfg.DBPort,
        cfg.DBUser,
        cfg.DBPassword,
        cfg.DBName)
    if err != nil {
        log.Error(ctx, "unable to establish a database connection: %s", err.Error())
    }
    defer func() {
        if conn != nil {
            conn.Close()
        }
    }()

    router := gin.New()
    router.Use(/* some middleware */)
    articles.Activate(router, conn)

    if err := router.Run(fmt.Sprintf("%s:%d", cfg.AppHost, cfg.AppPort)); err != nil {
        log.Fatal(context.Background(), err.Error())
    }
}