阶段性完成网关

framework/gateway/builder.go

@@ -1,57 +1,110 @@
 package gateway
 
 import (
-	"fmt"
 	"git.sxidc.com/go-framework/baize/framework/core/api"
+	"git.sxidc.com/go-tools/utils/http_client"
+	"time"
 )
 
+type Result struct {
+	Result map[string]any
+	Custom map[string]any
+}
+
+type RequestCallbackFunc func(c *api.Context, response *http_client.Response, err error, customResultMap map[string]any)
+type GlobalRequestCallbackFunc func(c *api.Context, request BuilderRequest, err error, historyRequests []BuilderRequest, customResultMap map[string]any)
+
 type Builder struct {
-	router api.Router
+	router         api.Router
+	httpClient     *http_client.Client
+	httpTimeoutSec int64
 
-	httpMethod   string
-	relativePath string
+	params *builderParams
 }
 
-func (builder *Builder) Url(httpMethod string, relativePath string) *Builder {
-	newBuilder := builder.copy()
-	newBuilder.httpMethod = httpMethod
-	newBuilder.relativePath = relativePath
-	return newBuilder
+func newBuilder(router api.Router, httpClient *http_client.Client) *Builder {
+	return &Builder{
+		router:     router,
+		httpClient: httpClient,
+		params:     newBuilderParams(),
+	}
 }
 
-func (builder *Builder) Request() *Builder {
-	newBuilder := builder.copy()
+func (builder *Builder) Url(httpMethod string, relativePath string) *Builder {
+	copyBuilder := builder.copy()
+	copyBuilder.params.httpMethod = httpMethod
+	copyBuilder.params.relativePath = relativePath
+	return copyBuilder
+}
 
-	return newBuilder
+func (builder *Builder) Post(request *PostRequest, requestCallbackFunc RequestCallbackFunc) *Builder {
+	return builder.addRequest(newBuilderRequestItem(request, requestCallbackFunc))
 }
 
-func (builder *Builder) Response() *Builder {
-	newBuilder := builder.copy()
+func (builder *Builder) Delete(request *DeleteRequest, requestCallbackFunc RequestCallbackFunc) *Builder {
+	return builder.addRequest(newBuilderRequestItem(request, requestCallbackFunc))
+}
 
-	return newBuilder
+func (builder *Builder) Put(request *PutRequest, requestCallbackFunc RequestCallbackFunc) *Builder {
+	return builder.addRequest(newBuilderRequestItem(request, requestCallbackFunc))
 }
 
-func (builder *Builder) PassThrough() *Builder {
-	newBuilder := builder.copy()
+func (builder *Builder) Get(request *GetRequest, requestCallbackFunc RequestCallbackFunc) *Builder {
+	return builder.addRequest(newBuilderRequestItem(request, requestCallbackFunc))
+}
 
-	return newBuilder
+func (builder *Builder) RequestCallbackFunc(globalRequestCallbackFunc GlobalRequestCallbackFunc) *Builder {
+	copyBuilder := builder.copy()
+	copyBuilder.params.globalRequestCallbackFunc = globalRequestCallbackFunc
+	return copyBuilder
 }
 
 func (builder *Builder) Build(middlewares ...api.Handler) {
-	newBuilder := builder.copy()
-	newBuilder.router.AddRoute(builder.httpMethod, builder.relativePath, append(middlewares,
+	copyBuilder := builder.copy()
+	copyBuilder.router.AddRoute(builder.params.httpMethod, builder.params.relativePath, append(middlewares,
 		func(c *api.Context) {
-			fmt.Println("Come Here!!!")
+			httpRequest := builder.httpClient.NewRequest(http_client.WithNewRequestTimeout(time.Duration(builder.httpTimeoutSec) * time.Second))
+			historyRequests := make([]BuilderRequest, 0)
+			result := Result{
+				Result: make(map[string]any),
+				Custom: make(map[string]any),
+			}
+
+			for _, requestItem := range builder.params.requestItems {
+				err := requestItem.request.Request(httpRequest)
+
+				if requestItem.requestCallbackFunc != nil {
+					requestItem.requestCallbackFunc(c, requestItem.request.Response(), err, result.Custom)
+					return
+				}
+
+				if builder.params.globalRequestCallbackFunc != nil {
+					builder.params.globalRequestCallbackFunc(c, requestItem.request, err, historyRequests, result.Custom)
+					continue
+				}
+
+				// TODO
+				if err != nil {
+
+				}
+
+				historyRequests = append(historyRequests, requestItem.request)
+
+				return
+			}
+
+			// TODO 最终结果处理
 		})...)
 }
 
-func (builder *Builder) copy() *Builder {
-	newBuilder := &Builder{
-		router: builder.router,
-
-		httpMethod:   builder.httpMethod,
-		relativePath: builder.relativePath,
-	}
+func (builder *Builder) addRequest(item *builderRequestItem) *Builder {
+	copyBuilder := builder.copy()
+	copyBuilder.params.requestItems = append(copyBuilder.params.requestItems, item)
+	return copyBuilder
+}
 
-	return newBuilder
+func (builder *Builder) copy() *Builder {
+	copyBuilder := newBuilder(builder.router, builder.httpClient)
+	copyBuilder.params = copyBuilder.params.copy()
+	return copyBuilder
 }

framework/gateway/builder_params.go

@@ -0,0 +1,26 @@
+package gateway
+
+type builderParams struct {
+	httpMethod                string
+	relativePath              string
+	requestItems              []*builderRequestItem
+	globalRequestCallbackFunc GlobalRequestCallbackFunc
+}
+
+func newBuilderParams() *builderParams {
+	return &builderParams{
+		httpMethod:                "",
+		relativePath:              "",
+		requestItems:              make([]*builderRequestItem, 0),
+		globalRequestCallbackFunc: nil,
+	}
+}
+
+func (params *builderParams) copy() *builderParams {
+	return &builderParams{
+		httpMethod:                params.httpMethod,
+		relativePath:              params.relativePath,
+		requestItems:              params.requestItems,
+		globalRequestCallbackFunc: params.globalRequestCallbackFunc,
+	}
+}

framework/gateway/builder_request.go

@@ -0,0 +1,147 @@
+package gateway
+
+import (
+	"git.sxidc.com/go-tools/utils/http_client"
+	"net/http"
+)
+
+type BuilderRequest interface {
+	HttpMethod() string
+	RequestUrl() string
+	Request(request *http_client.Request) error
+	Response() *http_client.Response
+}
+
+type PostRequest struct {
+	Url     string
+	Headers map[string]string
+	Body    []byte
+
+	response *http_client.Response
+}
+
+func (req *PostRequest) HttpMethod() string {
+	return http.MethodPost
+}
+
+func (req *PostRequest) RequestUrl() string {
+	return req.Url
+}
+
+func (req *PostRequest) Request(request *http_client.Request) error {
+	response, err := request.Post(req.Url, req.Body,
+		http_client.WithRequestHeaders(req.Headers))
+	if err != nil {
+		return err
+	}
+
+	req.response = response
+
+	return nil
+}
+
+func (req *PostRequest) Response() *http_client.Response {
+	return req.response
+}
+
+type DeleteRequest struct {
+	Url         string
+	Headers     map[string]string
+	PathParams  map[string]string
+	QueryParams map[string]string
+
+	response *http_client.Response
+}
+
+func (req *DeleteRequest) HttpMethod() string {
+	return http.MethodDelete
+}
+
+func (req *DeleteRequest) RequestUrl() string {
+	return req.Url
+}
+
+func (req *DeleteRequest) Request(request *http_client.Request) error {
+	response, err := request.Delete(req.Url,
+		http_client.WithRequestHeaders(req.Headers),
+		http_client.WithRequestPathParams(req.PathParams),
+		http_client.WithRequestQueryParams(req.QueryParams))
+	if err != nil {
+		return err
+	}
+
+	req.response = response
+
+	return nil
+}
+
+func (req *DeleteRequest) Response() *http_client.Response {
+	return req.response
+}
+
+type PutRequest struct {
+	Url     string
+	Headers map[string]string
+	Body    []byte
+
+	response *http_client.Response
+}
+
+func (req *PutRequest) HttpMethod() string {
+	return http.MethodPut
+}
+
+func (req *PutRequest) RequestUrl() string {
+	return req.Url
+}
+
+func (req *PutRequest) Request(request *http_client.Request) error {
+	response, err := request.Put(req.Url, req.Body,
+		http_client.WithRequestHeaders(req.Headers))
+	if err != nil {
+		return err
+	}
+
+	req.response = response
+
+	return nil
+}
+
+func (req *PutRequest) Response() *http_client.Response {
+	return req.response
+}
+
+type GetRequest struct {
+	Url         string
+	Headers     map[string]string
+	PathParams  map[string]string
+	QueryParams map[string]string
+
+	response *http_client.Response
+}
+
+func (req *GetRequest) HttpMethod() string {
+	return http.MethodGet
+}
+
+func (req *GetRequest) RequestUrl() string {
+	return req.Url
+}
+
+func (req *GetRequest) Request(request *http_client.Request) error {
+	response, err := request.Get(req.Url,
+		http_client.WithRequestHeaders(req.Headers),
+		http_client.WithRequestPathParams(req.PathParams),
+		http_client.WithRequestQueryParams(req.QueryParams))
+	if err != nil {
+		return err
+	}
+
+	req.response = response
+
+	return nil
+}
+
+func (req *GetRequest) Response() *http_client.Response {
+	return req.response
+}

framework/gateway/builder_request_item.go

@@ -0,0 +1,13 @@
+package gateway
+
+type builderRequestItem struct {
+	request             BuilderRequest
+	requestCallbackFunc RequestCallbackFunc
+}
+
+func newBuilderRequestItem(request BuilderRequest, callbackFunc RequestCallbackFunc) *builderRequestItem {
+	return &builderRequestItem{
+		request:             request,
+		requestCallbackFunc: callbackFunc,
+	}
+}

framework/gateway/gateway.go

@@ -1,14 +1,32 @@
 package gateway
 
-import "git.sxidc.com/go-framework/baize/framework/core/api"
+import (
+	"git.sxidc.com/go-framework/baize/framework/core/api"
+	"git.sxidc.com/go-tools/utils/http_client"
+)
 
 type Gateway struct {
-	api *api.Api
+	api        *api.Api
+	httpClient *http_client.Client
+
+	options *Options
 }
 
-func NewGateway(api *api.Api) *Gateway {
+func NewGateway(api *api.Api, opts ...Option) *Gateway {
+	options := new(Options)
+
+	for _, opt := range opts {
+		opt(options)
+	}
+
+	if options.httpClientTimeoutSec == 0 {
+		options.httpClientTimeoutSec = 30
+	}
+
 	return &Gateway{
-		api: api,
+		api:        api,
+		httpClient: http_client.New(),
+		options:    options,
 	}
 }
 
@@ -22,7 +40,18 @@ func DestroyGateway(gw *Gateway) {
 }
 
 func (gw *Gateway) NewBuilder(routerType string, version string) *Builder {
-	return &Builder{
-		router: gw.api.ChooseRouter(routerType, version),
+
+	return newBuilder(gw.api.ChooseRouter(routerType, version), gw.httpClient)
+}
+
+type Option func(options *Options)
+
+type Options struct {
+	httpClientTimeoutSec int64
+}
+
+func WithHttpClientTimeoutSec(httpClientTimeoutSec int64) Option {
+	return func(options *Options) {
+		options.httpClientTimeoutSec = httpClientTimeoutSec
 	}
 }