开发Go服务有关DDD分层架构思考与实践

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

$ tree -d -NL 2
.
├── application     // [必须]DDD - 应用层
├── cmd             // [必须]参考project-layout，存放CMD
│   ├── imgupload           // 命令行上传图片
│   └── imgupload_server    // 命令行启动Httpd服务
├── deployments     // 参考project-layout，服务部署相关
├── docs            // 参考project-layout，文档相关
├── domain          // [必须]DDD - 领域层
│   ├── entity      //  - 领域实体
│   ├── repository  //  - 领域仓储接口
│   ├── service     //  - 领域服务，多个实体的能力聚合
│   └── valobj      //  - 领域值对象
├── infrastructure  // [必须]DDD - 基础层
│   └── persistence //  - 数据库持久层
├── interfaces      // [必须]DDD - 接口层
│   └── api         //  - RESTful API接口对外暴露
├── pkg             // [可选]参考project-layout，项目包，还有internel等目录结构，依据服务实际情况考虑
└── tests           // [可选]参考project-layout，测试相关
    └── mock

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package entity

import (
	"os"
	"time"
)

// UploadImg 上传图片实体
type UploadImg struct {
	ID        uint64     `gorm:"primary_key;auto_increment" json:"id"`
	Name      string     `gorm:"size:100;not null;" json:"name"`
	Path      string     `gorm:"size:100;" json:"path"`
	Url       string     `gorm:"-" json:"url"`
	Content   os.File    `gorm:"-" json:"-"`
	CreatedAt time.Time  `gorm:"default:CURRENT_TIMESTAMP" json:"created_at"`
	UpdatedAt time.Time  `gorm:"default:CURRENT_TIMESTAMP" json:"updated_at"`
	DeletedAt *time.Time `json:"-"`
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package repository

import "github.com/lupguo/go-ddd-sample/domain/entity"

// UploadImgRepo 图片上传相关仓储接口，只要实现了该接口，则可以操作Domain领域实体
type UploadImgRepo interface {
	Save(*entity.UploadImg) (*entity.UploadImg, error)
	Get(uint64) (*entity.UploadImg, error)
	GetAll() ([]entity.UploadImg, error)
	Delete(uint64) error
}

 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
51
52
53
54
55
56

package persistence

import (
	"github.com/go-sql-driver/mysql"
	_ "github.com/go-sql-driver/mysql"
	"github.com/jinzhu/gorm"
	"github.com/lupguo/go-ddd-sample/domain/entity"
	"github.com/lupguo/go-ddd-sample/domain/repository"
	"time"
)

// Repositories 总仓储机构提，包含多个领域仓储接口，以及一个DB实例
type Repositories struct {
	UploadImg repository.UploadImgRepo
	db        *gorm.DB
}

// NewRepositories 初始化所有域的总仓储实例，将实例通过依赖注入方式，将DB实例注入到领域层
func NewRepositories(DbDriver, DbUser, DbPassword, DbPort, DbHost, DbName string) (*Repositories, error) {
	cfg := &mysql.Config{
		User:                 DbUser,
		Passwd:               DbPassword,
		Net:                  "tcp",
		Addr:                 DbHost + ":" + DbPort,
		DBName:               DbName,
		Collation:            "utf8mb4_general_ci",
		Loc:                  time.FixedZone("Asia/Shanghai", 8*60*60),
		Timeout:              time.Second,
		ReadTimeout:          30 * time.Second,
		WriteTimeout:         30 * time.Second,
		AllowNativePasswords: true,
		ParseTime:            true,
	}
	// DBSource := fmt.Sprintf("%s:%s@%s(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", DbUser, DbPassword, "tcp", DbHost, DbPort, DbName)
	db, err := gorm.Open(DbDriver, cfg.FormatDSN())
	if err != nil {
		return nil, err
	}
	db.LogMode(true)

	// 初始化总仓储实例
	return &Repositories{
		UploadImg: NewUploadImgPersis(db),
		db:        db,
	}, nil
}

// closes the database connection
func (s *Repositories) Close() error {
	return s.db.Close()
}

// This migrate all tables
func (s *Repositories) AutoMigrate() error {
	return s.db.AutoMigrate(&entity.UploadImg{}).Error
}

 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
51
52
53
54
55
56
57
58
59
60
61
62
63

// persistence 通过依赖注入方式，实现领域对持久化存储的控制反转（IOC）
package persistence

import (
	"errors"
	"github.com/jinzhu/gorm"
	"github.com/lupguo/go-ddd-sample/domain/entity"
)

// UploadImgPersis 上传图片的持久化结构体
type UploadImgPersis struct {
	db *gorm.DB
}

// NewUploadImgPersis 创建上传图片DB存储实例
func NewUploadImgPersis(db *gorm.DB) *UploadImgPersis {
	return &UploadImgPersis{db}
}

// Save 保存一张上传图片
func (p *UploadImgPersis) Save(img *entity.UploadImg) (*entity.UploadImg, error) {
	err := p.db.Create(img).Error
	if err != nil {
		return nil, err
	}
	return img, nil
}

// Get 获取一张上传图片
func (p *UploadImgPersis) Get(id uint64) (*entity.UploadImg, error) {
	var img entity.UploadImg
	err := p.db.Where("id = ?", id).Take(&img).Error
	if gorm.IsRecordNotFoundError(err) {
		return nil, errors.New("upload image not found")
	}
	if err != nil {
		return nil, err
	}
	return &img, nil
}

// GetAll 获取一组上传图片
func (p *UploadImgPersis) GetAll() ([]entity.UploadImg, error) {
	var imgs []entity.UploadImg
	err := p.db.Limit(50).Order("created_at desc").Find(&imgs).Error
	if gorm.IsRecordNotFoundError(err) {
		return nil, errors.New("upload images not found")
	}
	if err != nil {
		return nil, err
	}
	return imgs, nil
}

// Delete 删除一张图片
func (p *UploadImgPersis) Delete(id uint64) error {
	var img entity.UploadImg
	err := p.db.Where("id = ?", id).Delete(&img).Error
	if err != nil {
		return err
	}
	return nil
}

 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
51
52
53
54
55
56
57
58
59
60

package application

import (
	"github.com/lupguo/go-ddd-sample/domain/entity"
	"github.com/lupguo/go-ddd-sample/domain/repository"
	"os"
)

type UploadImgAppIer interface {
	Save(*entity.UploadImg) (*entity.UploadImg, error)
	Get(uint64) (*entity.UploadImg, error)
	GetAll() ([]entity.UploadImg, error)
	Delete(uint64) error
}

type UploadImgApp struct {
	db repository.UploadImgRepo
}

// NewUploadImgApp 初始化上传图片应用
func NewUploadImgApp(db repository.UploadImgRepo) *UploadImgApp {
	return &UploadImgApp{db: db}
}

func (app *UploadImgApp) Save(img *entity.UploadImg) (*entity.UploadImg, error) {
	img, err := app.db.Save(img)
	if err != nil {
		return nil, err
	}
	img.Url = rawUrl(img.Path)
	return img, nil
}

func (app *UploadImgApp) Get(id uint64) (*entity.UploadImg, error) {
	img, err := app.db.Get(id)
	if err != nil {
		return nil, err
	}
	img.Url = rawUrl(img.Path)
	return img, nil
}

func (app *UploadImgApp) GetAll() ([]entity.UploadImg, error) {
	imgs, err := app.db.GetAll()
	if err != nil {
		return nil, err
	}
	for i, img := range imgs {
		imgs[i].Url = rawUrl(img.Path)
	}
	return imgs, nil
}

func (app *UploadImgApp) Delete(id uint64) error {
	return app.db.Delete(id)
}

func rawUrl(path string) string {
	return os.Getenv("IMAGE_DOMAIN") + os.Getenv("LISTEN_PORT") + path
}

  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
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

package handler

import (
	"errors"
	"fmt"
	"github.com/labstack/echo"
	"github.com/lupguo/go-ddd-sample/application"
	"github.com/lupguo/go-ddd-sample/domain/entity"
	"io"
	"io/ioutil"
	"math/rand"
	"net/http"
	"os"
	"path"
	"strconv"
	"time"
)

// UploadImgHandle 上传处理
func UploadImgHandle(c echo.Context) error {
	callback := c.QueryParam("callback")
	var content struct {
		Response  string    `json:"response"`
		Timestamp time.Time `json:"timestamp"`
		Random    int       `json:"random"`
	}
	content.Response = "Sent via JSONP"
	content.Timestamp = time.Now().UTC()
	content.Random = rand.Intn(1000)
	return c.JSONP(http.StatusOK, callback, &content)
}

// UploadImgHandler 图片上传接口层处理
type UploadImgHandler struct {
	uploadImgApp application.UploadImgAppIer
}

// NewUploadImgHandler 初始化一个图片上传接口
func NewUploadImgHandler(app application.UploadImgAppIer) *UploadImgHandler {
	return &UploadImgHandler{uploadImgApp: app}
}

func (h *UploadImgHandler) Save(c echo.Context) error {
	forms, err := c.MultipartForm()
	if err != nil {
		return err
	}
	var imgs []*entity.UploadImg
	for _, file := range forms.File["upload"] {
		fo, err := file.Open()
		if err != nil {
			continue
		}
		// file storage path
		_, err = os.Stat(os.Getenv("IMAGE_STORAGE"))
		if err != nil {
			if os.IsNotExist(err) {
				if err := os.MkdirAll(os.Getenv("IMAGE_STORAGE"), 0755); err != nil {
					return err
				}
			} else {
				return err
			}
		}
		// file save
		ext := path.Ext(file.Filename)
		tempFile, err := ioutil.TempFile(os.Getenv("IMAGE_STORAGE"), "img_*"+ext)
		if err != nil {
			return err
		}
		_, err = io.Copy(tempFile, fo)
		if err != nil {
			return err
		}
		// upload
		uploadImg := entity.UploadImg{
			Name:      file.Filename,
			Path:      tempFile.Name(),
			CreatedAt: time.Time{},
			UpdatedAt: time.Time{},
		}
		img, err := h.uploadImgApp.Save(&uploadImg)
		if err != nil {
			return err
		}
		imgs = append(imgs, img)
	}
	return c.JSON(http.StatusOK, imgs)
}

func (h *UploadImgHandler) Get(c echo.Context) error {
	strID := c.Param("id")
	if strID == "" {
		return errors.New("the input image ID is empty")
	}
	id, err := strconv.ParseUint(strID, 10, 0)
	if err != nil {
		return err
	}
	img, err := h.uploadImgApp.Get(id)
	if err != nil {
		return err
	}
	return c.JSON(http.StatusOK, img)
}

func (h *UploadImgHandler) GetAll(c echo.Context) error {
	imgs, err := h.uploadImgApp.GetAll()
	if err != nil {
		return err
	}
	return c.JSON(http.StatusOK, imgs)
}

func (h *UploadImgHandler) Delete(c echo.Context) error {
	strID := c.Param("id")
	if strID == "" {
		return errors.New("the deleted image ID is empty")
	}
	id, err := strconv.ParseUint(strID, 10, 0)
	if err != nil {
		return err
	}
	err = h.uploadImgApp.Delete(id)
	if err != nil {
		return err
	}
	msg := fmt.Sprintf(`{"msg": "delete Imgage ID:%s success"`, strID)
	return c.JSON(http.StatusOK, msg)
}

 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
51
52
53
54
55
56
57
58
59
60
61

package main

import (
	"github.com/joho/godotenv"
	"github.com/labstack/echo"
	"github.com/labstack/echo/middleware"
	"github.com/lupguo/go-ddd-sample/application"
	"github.com/lupguo/go-ddd-sample/infrastructure/persistence"
	"github.com/lupguo/go-ddd-sample/interfaces/api/handler"
	"log"
	"os"
)

func init() {
	// To load our environmental variables.
	if err := godotenv.Load(); err != nil {
		log.Println("no env gotten")
	}
}

func main() {
	// db detail
	dbDriver := os.Getenv("DB_DRIVER")
	host := os.Getenv("DB_HOST")
	password := os.Getenv("DB_PASSWORD")
	user := os.Getenv("DB_USER")
	dbname := os.Getenv("DB_NAME")
	port := os.Getenv("DB_PORT")

	// 初始化基础层实例 - DB实例
	persisDB, err := persistence.NewRepositories(dbDriver, user, password, port, host, dbname)
	if err != nil {
		log.Fatal(err)
	}
	defer persisDB.Close()
	// db做Migrate
	if err := persisDB.AutoMigrate(); err != nil {
		log.Fatal(err)
	}

	// 初始化应用层实例 - 上传图片应用
	uploadImgApp := application.NewUploadImgApp(persisDB.UploadImg)
	// 初始化接口层实例 - HTTP处理
	uploadImgHandler := handler.NewUploadImgHandler(uploadImgApp)

	e := echo.New()
	e.Use(middleware.Logger())
	e.Use(middleware.Recover())

	// 静态主页
	e.Static("/", "public")

	// 图片上传
	e.POST("/upload", uploadImgHandler.Save)
	e.GET("/delete/:id", uploadImgHandler.Delete)
	e.GET("/img/:id", uploadImgHandler.Get)
	e.GET("/img-list", uploadImgHandler.GetAll)

	// Start server
	e.Logger.Fatal(e.Start(os.Getenv("LISTEN_PORT")))
}

1
2
3
4
5
6
7

// 拉代码
git clone github.com/lupguo/go-ddd-sample
// 编译
cd go-ddd-sample
go build ./cmd/imgupload_server
// 运行
./impgupload_server