go从0到1项目实战体系三十五：三层架构所有代码

1. 前言:

①. 网站数百万的商品表、商品类别表,完成对应API的开发.

②. 三层架构模式解耦.

③. 目的:
   a. 在有限的资源内完成尽可能的优化系统性能和科学节约资源消耗.
   b. 尽可能的提高QPS.
   c. 经常CPU资源100%,可能需要程序优化、系统优化、硬件扩容优化.

---

2. 初始化文件:

(1). config配置文件(BsyErp\Contract\Init\Config.go):

package Init
const (
	HTTP_METHOD_GET  = "GET"
	HTTP_METHOD_POST = "POST"
	SERVER_ADDRESS   = ":8080"
)

(2). DB初始化文件(BsyErp\Contract\Init\DBInit.go):

package Init
import (
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
	"log"
)
var db *gorm.DB
func init() {
	var err error
	db, err = gorm.Open("mysql",
		"root:@tcp(localhost:3306)/test?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		log.Fatal(err)
	}
	db.SingularTable(true)
	db.DB().SetMaxIdleConns(10)
	db.DB().SetMaxOpenConns(50)
}
func  GetDB() *gorm.DB {
	return db
}

---

3. 三层架构:

①. 三层架构模式,并不是MVC,在go-kit中也使用了.

②. 考虑到可扩展性,整个业务代码写完后,框架都变化了.使用其它的框架.需要快速修改和切换.
   a. 需要有一定的模式.
   b. 有了一定的架构后,代码基本上不用变.只要改相关的接口部分.
   c. gin web框架的代码,如果换成微服务框架grpc,使用proto文件生成对应的文件,移植起来比较方便.

3.1 业务解耦:

v1.Handle("GET", "/prods", func(context *gin.Context) {
    // result := []*Models.Books{}     // 另一种写法:如果加了*指针,下面就不用加&
    result := Models.BookList{}
    Init.GetDB().Limit(10).Order("book_id desc").Find(&result)
    context.JSON(http.StatusOK, result)
})

注:
①. Handle的第三个参数,这个函数最终是要返回一个func,只要有context *gin.Context这个参数就可以.
   => 关键是要返回一个func(context *gin.Context)

②. 如果有参数,怎么获取?
   => 参数包括url形式的、form形式的、json形式的.

③. result := Models.BookList{}
   Init.GetDB().Limit(10).Order("book_id desc").Find(&result)
   => 这两句代码用面向对象来讲就是属于哪一个类的方法,属于哪个struct.

④. result获取出来了,一定是用json返回吗?是否还有其它方式,并不仅仅是输出字符串.

⑤. 以上都需要相关机制来控制的,并不是直接在函数中写死.

3.2 通用模型:

func RegisterHandler(怎么取参数, 业务最终函数, 怎么处理业务结果) func(context *gin.Context) {
  return func(context *gin.Context) {
    // 参数到底是url、form、json的?是否需要做验证?也不一定会有参数.
    1. 参数 := 怎么取参数()
    // 到底怎么取?取什么?
    2. 业务结果 := 业务最终函数(context, 参数)
    // 执行完成了返回什么?返回json只是一种方式,保存文件也是一种方式.
    3. 怎么处理业务结果(业务结果)
  }
}

注:
①. 3个形参都是函数.
②. 为了和业务进行解耦,这3个函数不能写死,是一个通用的.并不是某个产品、订单的函数.
④. 约定所有使用到对象都使用指针.    => 为了统一规范.
⑤. 不过过渡依赖gin的封装的便捷方法. => 尽量与框架无关,可移值性比较高的方式.

3.3 文件夹结构:

App 
└─ Services
   ├─ BookService.go    业务类(业务最终函数):
   │                    ①. 与架构无关,框架无关性代码.
   │                    ②. 不管是使用什么框架,使用grpc、go-mrico,这些代码是不变的.
   │
   ├─ BookEndpoint.go   Request和Response定义:
   │                    ①. 跟架构没有太大关系.
   │                    ②. 除了手工定义外,还可以通过proto文件自动生成(grpc).
   │
   └─ BookTransport.go  怎么取出参数和怎么处理响应:
                        ①. 和架构有关系的.

---

4. 列表&详情:

(1). BsyErp\Contract\main.go:

package main
import (
	"Contract.bsybx.com/App/Lib"
	"Contract.bsybx.com/App/Services"
	"Contract.bsybx.com/Init"
	"github.com/gin-gonic/gin"
)
func main () {
	router := gin.Default()
	v1 := router.Group("/v1")
	{
        // 获取book列表
		v1.Handle(Init.HTTP_METHOD_GET, "/books", Lib.RegisterHandler(
			Services.CreateBookListRequest(),
			Services.BookListEndPoint(&Services.BookService{}),
			Services.CreateBookListResponse(),
        ))
        // 获取book详情
		v1.Handle(Init.HTTP_METHOD_GET, "/book/:id", Lib.RegisterHandler(
			Services.CreateBookDetailRequest(),
			Services.BookDetailEndPoint(&Services.BookService{}),
			Services.CreateBookDetailResponse(),
		))
	}
	router.Run(Init.SERVER_ADDRESS)
}

注:
①. 下面(5)中如果Response方法优化了,这里可以优化为:
   bookResponse := Services.CreateBookResponse(),再将两个Response方法用变量替换.

②. bookService := &Services.BookService{},可以优化为传bookService.

(2). main.go优化如下:

bookResponse := Services.CreateBookResponse()
bookServer := &Services.BookService{}
bookListHandler := Lib.RegisterHandler(
  Services.CreateBookListRequest(),
  Services.BookListEndPoint(bookServer),
  bookResponse,
)
bookDetailHandler := Lib.RegisterHandler(
  Services.CreateBookDetailRequest(),
  Services.BookDetailEndPoint(bookServer),
  bookResponse,
)
v1.Handle(Init.HTTP_METHOD_GET, "/books", bookListHandler)
v1.Handle(Init.HTTP_METHOD_GET, "/book/:id", bookDetailHandler)

(3). BsyErp\Contract\App\Services\BookEndpoint.go:

package Services
import (
	"Contract.bsybx.com/App/Lib"
	"Contract.bsybx.com/Models"
	"context"
)
// v1/books?page=1&size=1
type BookListRequest struct {
	Page int  `form:"page"`
	Size int `form:"size"`
}
type BookListResponse struct {
	Result *Models.BooksList `json:"ResultData"`
}
// v1/book/12
type BookDetailRequest struct {
	// max可以做预估判断
	BookID int `uri:"id" binding:"required,gt=0,max=1000000"`
}
type BookDetailResponse struct {
	Result *Models.Books `json:"ResultData"`
}
func BookListEndPoint(book *BookService)  Lib.Endpoint {
   return func(ctx context.Context, request interface{}) (response interface{}, err error) {
	   req := request.(*BookListRequest)
	   return &BookListResponse{Result:book.BookList(req)}, nil
   }
}
func BookDetailEndPoint(book *BookService) Lib.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(*BookDetailRequest)
		return &BookDetailResponse{Result:book.BookDetail(req)}, nil
	}
}

注:
①. BookListResponse与BookDetailResponse都是返回Result,可以优化:
   type BookResponse struct {
     Result interface{} `json:"ResultData"`
   }

②. 单从上面两个EndPoint方法来看,是冗余的,有优化空间.但是加上缓存后,业务逻辑是不一样的.

(4). BsyErp\Contract\App\Services\BookService.go:

package Services
import (
	"Contract.bsybx.com/Init"
	"Contract.bsybx.com/Models"
)
type BookService struct {
}
// 这个req.Size怎么去取?跟这个struct没有任何关系.只要知道从req中取Size就行了.
// 但是这个Size是怎么产生的,不关心,解耦了.
// 不能在这里使用gin的context来获取当前的get请求
func(s *BookService) BookList(req *BookListRequest) (*Models.BooksList, error) {
	books := &Models.BooksList{}
	err := Init.GetDB().Limit(req.Page).Offset(req.Size).Order("book_id desc").Find(books).Error
	if err != nil {
		return nil, err
	}
	return books, nil
}

// 这里是一个struct对应的方法,这个是类的方法,在实际运行中RegisterHandler,识别不了类方法,需要再来一个函数,把它变成最终的业务函数.
// 这个过程就是把这个struct的方法(类的方法)调用的过程,用一个函数来做一层包装.只不过,是让最终执行函数和框架再次解耦.最终的目的是为了确保RegisterHandler和框架与业务无关.
// 到底怎么执行,是由业务来决定的,这个方法永远是恒定的.
func(s *BookService) BookDetail(req *BookDetailRequest) (*Models.Books, []*Models.BookMetas, error) {
	book := &Models.Books{}
	if Init.GetDB().Find(book, req.BookID).RowsAffected != 1 {
		return nil, nil, fmt.Errorf("no body")
	}
	Models.NewBookMeta("click", "1", book.BookID).Save()
	metas := []*Models.BookMetas{}
	Init.GetDB().Where("item_id=?", book.BookID).Find(&metas)
	return book, metas, nil
}

(5). BsyErp\Contract\App\Services\BookTransport.go:

package Services
import (
	"Contract.bsybx.com/App/Lib"
	"fmt"
	"github.com/gin-gonic/gin"
)
func CreateBookListRequest() Lib.EncodeRequestFunc {
	return func(context *gin.Context) (i interface{}, e error) {
		req := &BookListRequest{}
		err := context.BindQuery(req)   // 和框架有关系了,获取一个get参数，并且绑定到BookListRequest上，会去寻找这个BookListRequest struct中是否有size。如果有绑定，否则出错。
		fmt.Println(req)
		if err != nil{
			return nil, err
		}
		return req, nil
	}
}
func CreateBookListResponse() Lib.DecodeResponseFunc  {
	return func(context *gin.Context, i interface{}) error {
		res := i.(*BookListResponse)       // 取出BookListResponse,后再断言
		context.JSON(200, res)
		return nil
	}
}
func CreateBookDetailRequest() Lib.EncodeRequestFunc {
	return func(context *gin.Context) (interface{}, error) {
		req := &BookDetailRequest{}
		fmt.Println(req)
		err := context.BindUri(req)
		fmt.Println(req)
		if err != nil {
			return nil, err
		}
		return req, nil
	}
}
func CreateBookDetailResponse() Lib.DecodeResponseFunc {
	return func(context *gin.Context, i interface{}) error {
		res := i.(*BookDetailResponse)
		context.JSON(200, res)
		return nil
	}
}

注:
①. 两个Response都是差不多逻辑,可以优化为:
   func CreateBookResponse() Lib.DecodeResponseFunc {
     return func(context *gin.Context, res interface{}) error {
       context.JSON(200, res)
       return nil
     }
   }

(6). 请求访问:

①. 列表:
   GET http://localhost/v1/books?page=1&size=1

②. 详情:
   GET http://localhost/v1/book/200