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

.
├── app
│   ├── controller
│   ├── lib
│   ├── middleware
│   ├── model
│   └── router
├── cmd
│   ├── cron
│   └── server
├── config
│   └── initializer
├── db
│   └── migrate
│   └── migrate.go
├── go.mod
├── mock
├── test
└── third_party

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

.
├── api
│   └── product
│       └── app
│           ├── errcode
│           └── v1
│               └── v1.proto
├── cmd
│   ├── cron
│   │   ├── main.go
│   │   └── wire.go
│   ├── migrate
│   └── server
├── config
├── go.mod
├── internal
│   ├── cron
│   │   ├── repo
│   │   ├── service
│   │   ├── usecase
│   │   └── wire_set.go
│   ├── domain
│   ├── pkg
│   │   ├── copier
│   │   ├── mock
│   │   └── test
│   └── server
│       ├── repo
│       ├── service
│       ├── usecase
│       └── wire_set.go
└── third_party

1
2
3
4
5

{
  "code": 1,
  "msg": "成功",
  "data": {}
}

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

// 这里指定了 proto 文件的版本
syntax = "proto3";
// package 命名规则: product.application.version
package product.app.v1;
// go_package 生成 go 文件当中的包名
option go_package = "github.com/mohuishou/new-project/api/product/app/v1";
import "google/api/annotations.proto";
service BlogService {
  // 创建文章
  rpc CreateArticle(CreateArticleReq) returns (CreateArticleResp) {
  	// option 还是都加上，可以利用插件自动生成 swagger 文档
    option (google.api.http) = {
      post: "/article"
      body: "*"
    };
  }
}
// 参数和返回值定义，这里就不详细列了
message CreateArticleReq {}
message CreateArticleResp {}

1
2
3
4

message GetArticleReq {
  // @inject_tag: form:"id" binding:"required"
  int32 id = 1;
}

1
2
3
4
5
6
7
8

message ListArticleTagsResp {
  repeated Tag tags = 1;
}
message Tag {
  string key = 1;
  string value = 2;
}

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

// UnmarshalJSON sets *m to a copy of data.
func (m *ListArticleTagsResp) UnmarshalJSON(data []byte) error {
	if m == nil {
		return errors.New("json.RawMessage: UnmarshalJSON on nil pointer")
	}
	return json.Unmarshal(data, &m.Tags)
}
// MarshalJSON returns m as the JSON encoding of m.
func (m *ListArticleTagsResp) MarshalJSON() ([]byte, error) {
	if m == nil {
		return []byte("null"), nil
	}
	return json.Marshal(m.Tags)
}

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

// 这里指定了 proto 文件的版本
syntax = "proto3";
// package 命名规则: product.application.version
package product.app.v1;
// go_package 生成 go 文件当中的包名
option go_package = "github.com/mohuishou/new-project/api/product/app/v1";
message Timestamp {
    // Represents seconds of UTC time since Unix epoch
    // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
    // 9999-12-31T23:59:59Z inclusive.
    int64 seconds = 1;
    // Non-negative fractions of a second at nanosecond resolution. Negative
    // second values with fractions must still have non-negative nanos values
    // that count forward in time. Must be from 0 to 999,999,999
    // inclusive.
    int32 nanos = 2;
}

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

// NewTimestamp NewTimestamp
func NewTimestamp(t time.Time) *Timestamp {
	return &Timestamp{
		Seconds: t.Unix(),
		Nanos:   int32(t.Nanosecond()),
	}
}
// Time 类型转换
func (m *Timestamp) Time() time.Time {
	// Don't return the zero value on error, because corresponds to a valid
	// timestamp. Instead return whatever time.Unix gives us.
	if m == nil {
		return time.Unix(0, 0).UTC() // treat nil like the empty Timestamp
	}
	return time.Unix(m.Seconds, int64(m.Nanos)).UTC()
}
// UnmarshalJSON sets *m to a copy of data.
func (m *Timestamp) UnmarshalJSON(data []byte) error {
	if m == nil {
		return errors.New("json.RawMessage: UnmarshalJSON on nil pointer")
	}
	var t time.Time
	if err := json.Unmarshal(data, &t); err != nil {
		return err
	}
	*m = *NewTimestamp(t)
	return nil
}
// MarshalJSON returns m as the JSON encoding of m.
func (m *Timestamp) MarshalJSON() ([]byte, error) {
	if m == nil {
		return []byte("null"), nil
	}
	return json.Marshal(m.Time())
}

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

// article.go
// Article 文章
type Article struct {
	Model // 基础结构体，包含 id, created_at, deleted_at, updated_at
	Title   string `json:"title"`
	Content string `json:"content"`
	Tags    []Tag  `json:"tags" gorm:"many2many:article_tags"`
}
// IArticleUsecase IArticleUsecase
type IArticleUsecase interface {
    // 获取文章详情
	GetArticle(ctx context.Context, id int) (*Article, error)
	// 创建一篇文章
    CreateArticle(ctx context.Context, article *Article) error
}
// IArticleRepo IArticleRepo
type IArticleRepo interface {
	GetArticle(ctx context.Context, id int) (*Article, error)
	CreateArticle(ctx context.Context, article *Article) error
}
// tag.go
// Tag 标签数据
type Tag struct {
	Model
	Key   string `json:"key"`
	Value string `json:"value"`
}

1
2
3
4
5

mockgen:
	cd ./internal && for file in `egrep -rnl "type.*?interface" ./domain | grep -v "_test" `; do \
		echo $$file ; \
		cd .. && mockgen -destination="./internal/pkg/mock/$$file" -source="./internal/$$file" && cd ./internal ; \
	done

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

// 确保实现了对应的接口
var _ v1.BlogServiceHTTPServer = &Artcile{}
// Artcile Artcile
type Artcile struct {
	usecase domain.IArticleUsecase
}
// NewArticleService 初始化方法
func NewArticleService(usecase domain.IArticleUsecase) *Artcile {
	return &Artcile{usecase: usecase}
}
// CreateArticle 创建一篇文章
func (a *Artcile) CreateArticle(ctx context.Context, req *v1.CreateArticleReq) (*v1.CreateArticleResp, error) {
	article := &domain.Article{
		Title:   req.Title,
		Content: req.Content,
	}
	err := a.usecase.CreateArticle(ctx, article)
	return &v1.CreateArticleResp{}, err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Copy 从一个结构体复制到另一个结构体
func Copy(to, from interface{}) error {
	b, err := json.Marshal(from)
	if err != nil {
		return errors.Wrap(err, "marshal from data err")
	}
	err = json.Unmarshal(b, to)
	if err != nil {
		return errors.Wrap(err, "unmarshal to data err")
	}
	return nil
}

1
2
3
4
5
6
7
8
9
10
11

// CreateArticle 创建一篇文章
func (a *Artcile) CreateArticle(ctx context.Context, req *v1.CreateArticleReq) (*v1.CreateArticleResp, error) {
	var article domain.Article
	err := copier.Copy(&article, req)
	if err != nil {
		return nil, err
	}
	err = a.usecase.CreateArticle(ctx, &article)
	return &v1.CreateArticleResp{}, err
}

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

type article struct {
	repo domain.IArticleRepo
}
// NewArticleUsecase init
func NewArticleUsecase(repo domain.IArticleRepo) domain.IArticleUsecase {
	return &article{repo: repo}
}
func (u *article) GetArticle(ctx context.Context, id int) (*domain.Article, error) {
	// 这里可能有其他业务逻辑...
	return u.repo.GetArticle(ctx, id)
}
func (u *article) CreateArticle(ctx context.Context, article *domain.Article) error {
	return u.repo.CreateArticle(ctx, article)
}

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

type article struct {
	db *gorm.DB
}
// NewArticleRepo init
func NewArticleRepo(db *gorm.DB) domain.IArticleRepo {
	return &article{db: db}
}
func (r *article) GetArticle(ctx context.Context, id int) (*domain.Article, error) {
	var a domain.Article
	if err := r.db.WithContext(ctx).Find(&a, id); err != nil {
		// 这里返回业务错误码
	}
	return &a, nil
}
func (r *article) CreateArticle(ctx context.Context, article *domain.Article) error {
	if err := r.db.WithContext(ctx).Create(article); err != nil {
		// 这里返回业务错误码
	}
	return nil
}

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

package server
import (
	"github.com/google/wire"
	"github.com/mohuishou/new-project/internal/server/repo"
	"github.com/mohuishou/new-project/internal/server/service"
	"github.com/mohuishou/new-project/internal/server/usecase"
)
// Set for di
var Set = wire.NewSet(
	service.NewArticleService,
	usecase.NewArticleUsecase,
	repo.NewArticleRepo,
)

1
2
3
4
5

.
├── main.go # 包含 main 函数
├── server.go # 包含 wire set 等
├── wire.go # for wire build
└── wire_gen.go # wire 自动生成的

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

var set = wire.NewSet(
	// domains
	server.Set,
	// common
	initializer.Set,
)
type services struct {
	article *service.Artcile
}
func (s *services) register(r gin.IRouter) {
	v1.RegisterBlogServiceHTTPServer(r, s.article)
}

1
2
3
4
5
6
7

// NewServices NewServices
func NewServices() (*services, error) {
	panic(wire.Build(
		wire.Struct(new(services), "*"),
		set,
	))
}

1
2
3
4
5
6
7
8
9
10
11
12

func main() {
	s, err := NewServices()
	if err != nil {
		panic(err)
	}
	e := gin.Default()
	s.register(e)
	// 这里还有优雅中止的一些代码，就不贴了
}