Merge pull request '根据输入的json数据,动态生成数据结构' (#12) from feature/json into master

Reviewed-on: #12

demo/context.go

@@ -0,0 +1,586 @@
+// Package demo ...
+//
+// Description : demo ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2021-12-02 12:43 下午
+package demo
+
+import (
+	"errors"
+	"reflect"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package context defines the Context type, which carries deadlines,
+// cancellation signals, and other request-scoped values across API boundaries
+// and between processes.
+//
+// Incoming requests to a server should create a Context, and outgoing
+// calls to servers should accept a Context. The chain of function
+// calls between them must propagate the Context, optionally replacing
+// it with a derived Context created using WithCancel, WithDeadline,
+// WithTimeout, or WithValue. When a Context is canceled, all
+// Contexts derived from it are also canceled.
+//
+// The WithCancel, WithDeadline, and WithTimeout functions take a
+// Context (the parent) and return a derived Context (the child) and a
+// CancelFunc. Calling the CancelFunc cancels the child and its
+// children, removes the parent's reference to the child, and stops
+// any associated timers. Failing to call the CancelFunc leaks the
+// child and its children until the parent is canceled or the timer
+// fires. The go vet tool checks that CancelFuncs are used on all
+// control-flow paths.
+//
+// Programs that use Contexts should follow these rules to keep interfaces
+// consistent across packages and enable static analysis tools to check context
+// propagation:
+//
+// Do not store Contexts inside a struct type; instead, pass a Context
+// explicitly to each function that needs it. The Context should be the first
+// parameter, typically named ctx:
+//
+// 	func DoSomething(ctx context.Context, arg Arg) error {
+// 		// ... use ctx ...
+// 	}
+//
+// Do not pass a nil Context, even if a function permits it. Pass context.TODO
+// if you are unsure about which Context to use.
+//
+// Use context Values only for request-scoped data that transits processes and
+// APIs, not for passing optional parameters to functions.
+//
+// The same Context may be passed to functions running in different goroutines;
+// Contexts are safe for simultaneous use by multiple goroutines.
+//
+// See https://blog.golang.org/context for example code for a server that uses
+// Contexts.
+
+// A Context carries a deadline, a cancellation signal, and other values across
+// API boundaries.
+//
+// Context's methods may be called by multiple goroutines simultaneously.
+type Context interface {
+	// Deadline returns the time when work done on behalf of this context
+	// should be canceled. Deadline returns ok==false when no deadline is
+	// set. Successive calls to Deadline return the same results.
+	Deadline() (deadline time.Time, ok bool)
+
+	// Done returns a channel that's closed when work done on behalf of this
+	// context should be canceled. Done may return nil if this context can
+	// never be canceled. Successive calls to Done return the same value.
+	// The close of the Done channel may happen asynchronously,
+	// after the cancel function returns.
+	//
+	// WithCancel arranges for Done to be closed when cancel is called;
+	// WithDeadline arranges for Done to be closed when the deadline
+	// expires; WithTimeout arranges for Done to be closed when the timeout
+	// elapses.
+	//
+	// Done is provided for use in select statements:
+	//
+	//  // Stream generates values with DoSomething and sends them to out
+	//  // until DoSomething returns an error or ctx.Done is closed.
+	//  func Stream(ctx context.Context, out chan<- Value) error {
+	//  	for {
+	//  		v, err := DoSomething(ctx)
+	//  		if err != nil {
+	//  			return err
+	//  		}
+	//  		select {
+	//  		case <-ctx.Done():
+	//  			return ctx.Err()
+	//  		case out <- v:
+	//  		}
+	//  	}
+	//  }
+	//
+	// See https://blog.golang.org/pipelines for more examples of how to use
+	// a Done channel for cancellation.
+	Done() <-chan struct{}
+
+	// If Done is not yet closed, Err returns nil.
+	// If Done is closed, Err returns a non-nil error explaining why:
+	// Canceled if the context was canceled
+	// or DeadlineExceeded if the context's deadline passed.
+	// After Err returns a non-nil error, successive calls to Err return the same error.
+	Err() error
+
+	// Value returns the value associated with this context for key, or nil
+	// if no value is associated with key. Successive calls to Value with
+	// the same key returns the same result.
+	//
+	// Use context values only for request-scoped data that transits
+	// processes and API boundaries, not for passing optional parameters to
+	// functions.
+	//
+	// A key identifies a specific value in a Context. Functions that wish
+	// to store values in Context typically allocate a key in a global
+	// variable then use that key as the argument to context.WithValue and
+	// Context.Value. A key can be any type that supports equality;
+	// packages should define keys as an unexported type to avoid
+	// collisions.
+	//
+	// Packages that define a Context key should provide type-safe accessors
+	// for the values stored using that key:
+	//
+	// 	// Package user defines a User type that's stored in Contexts.
+	// 	package user
+	//
+	// 	import "context"
+	//
+	// 	// User is the type of value stored in the Contexts.
+	// 	type User struct {...}
+	//
+	// 	// key is an unexported type for keys defined in this package.
+	// 	// This prevents collisions with keys defined in other packages.
+	// 	type key int
+	//
+	// 	// userKey is the key for user.User values in Contexts. It is
+	// 	// unexported; clients use user.NewContext and user.FromContext
+	// 	// instead of using this key directly.
+	// 	var userKey key
+	//
+	// 	// NewContext returns a new Context that carries value u.
+	// 	func NewContext(ctx context.Context, u *User) context.Context {
+	// 		return context.WithValue(ctx, userKey, u)
+	// 	}
+	//
+	// 	// FromContext returns the User value stored in ctx, if any.
+	// 	func FromContext(ctx context.Context) (*User, bool) {
+	// 		u, ok := ctx.Value(userKey).(*User)
+	// 		return u, ok
+	// 	}
+	Value(key interface{}) interface{}
+}
+
+// Canceled is the error returned by Context.Err when the context is canceled.
+var Canceled = errors.New("context canceled")
+
+// DeadlineExceeded is the error returned by Context.Err when the context's
+// deadline passes.
+var DeadlineExceeded error = deadlineExceededError{}
+
+type deadlineExceededError struct{}
+
+func (deadlineExceededError) Error() string   { return "context deadline exceeded" }
+func (deadlineExceededError) Timeout() bool   { return true }
+func (deadlineExceededError) Temporary() bool { return true }
+
+// An emptyCtx is never canceled, has no values, and has no deadline. It is not
+// struct{}, since vars of this type must have distinct addresses.
+type emptyCtx int
+
+func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
+	return
+}
+
+func (*emptyCtx) Done() <-chan struct{} {
+	return nil
+}
+
+func (*emptyCtx) Err() error {
+	return nil
+}
+
+func (*emptyCtx) Value(key interface{}) interface{} {
+	return nil
+}
+
+func (e *emptyCtx) String() string {
+	switch e {
+	case background:
+		return "context.Background"
+	case todo:
+		return "context.TODO"
+	}
+	return "unknown empty Context"
+}
+
+var (
+	background = new(emptyCtx)
+	todo       = new(emptyCtx)
+)
+
+// Background returns a non-nil, empty Context. It is never canceled, has no
+// values, and has no deadline. It is typically used by the main function,
+// initialization, and tests, and as the top-level Context for incoming
+// requests.
+func Background() Context {
+	return background
+}
+
+// TODO returns a non-nil, empty Context. Code should use context.TODO when
+// it's unclear which Context to use or it is not yet available (because the
+// surrounding function has not yet been extended to accept a Context
+// parameter).
+func TODO() Context {
+	return todo
+}
+
+// A CancelFunc tells an operation to abandon its work.
+// A CancelFunc does not wait for the work to stop.
+// A CancelFunc may be called by multiple goroutines simultaneously.
+// After the first call, subsequent calls to a CancelFunc do nothing.
+type CancelFunc func()
+
+// WithCancel returns a copy of parent with a new Done channel. The returned
+// context's Done channel is closed when the returned cancel function is called
+// or when the parent context's Done channel is closed, whichever happens first.
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete.
+func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
+	if parent == nil {
+		panic("cannot create context from nil parent")
+	}
+	c := newCancelCtx(parent)
+	propagateCancel(parent, &c)
+	return &c, func() { c.cancel(true, Canceled) }
+}
+
+// newCancelCtx returns an initialized cancelCtx.
+func newCancelCtx(parent Context) cancelCtx {
+	return cancelCtx{Context: parent}
+}
+
+// goroutines counts the number of goroutines ever created; for testing.
+var goroutines int32
+
+// propagateCancel arranges for child to be canceled when parent is.
+func propagateCancel(parent Context, child canceler) {
+	done := parent.Done()
+	if done == nil {
+		return // parent is never canceled
+	}
+
+	select {
+	case <-done:
+		// parent is already canceled
+		child.cancel(false, parent.Err())
+		return
+	default:
+	}
+
+	if p, ok := parentCancelCtx(parent); ok {
+		p.mu.Lock()
+		if p.err != nil {
+			// parent has already been canceled
+			child.cancel(false, p.err)
+		} else {
+			if p.children == nil {
+				p.children = make(map[canceler]struct{})
+			}
+			p.children[child] = struct{}{}
+		}
+		p.mu.Unlock()
+	} else {
+		atomic.AddInt32(&goroutines, +1)
+		go func() {
+			select {
+			case <-parent.Done():
+				child.cancel(false, parent.Err())
+			case <-child.Done():
+			}
+		}()
+	}
+}
+
+// &cancelCtxKey is the key that a cancelCtx returns itself for.
+var cancelCtxKey int
+
+// parentCancelCtx returns the underlying *cancelCtx for parent.
+// It does this by looking up parent.Value(&cancelCtxKey) to find
+// the innermost enclosing *cancelCtx and then checking whether
+// parent.Done() matches that *cancelCtx. (If not, the *cancelCtx
+// has been wrapped in a custom implementation providing a
+// different done channel, in which case we should not bypass it.)
+func parentCancelCtx(parent Context) (*cancelCtx, bool) {
+	done := parent.Done()
+	if done == closedchan || done == nil {
+		return nil, false
+	}
+	p, ok := parent.Value(&cancelCtxKey).(*cancelCtx)
+	if !ok {
+		return nil, false
+	}
+	pdone, _ := p.done.Load().(chan struct{})
+	if pdone != done {
+		return nil, false
+	}
+	return p, true
+}
+
+// removeChild removes a context from its parent.
+func removeChild(parent Context, child canceler) {
+	p, ok := parentCancelCtx(parent)
+	if !ok {
+		return
+	}
+	p.mu.Lock()
+	if p.children != nil {
+		delete(p.children, child)
+	}
+	p.mu.Unlock()
+}
+
+// A canceler is a context type that can be canceled directly. The
+// implementations are *cancelCtx and *timerCtx.
+type canceler interface {
+	cancel(removeFromParent bool, err error)
+	Done() <-chan struct{}
+}
+
+// closedchan is a reusable closed channel.
+var closedchan = make(chan struct{})
+
+func init() {
+	close(closedchan)
+}
+
+// A cancelCtx can be canceled. When canceled, it also cancels any children
+// that implement canceler.
+type cancelCtx struct {
+	Context
+
+	mu       sync.Mutex            // protects following fields
+	done     atomic.Value          // of chan struct{}, created lazily, closed by first cancel call
+	children map[canceler]struct{} // set to nil by the first cancel call
+	err      error                 // set to non-nil by the first cancel call
+}
+
+func (c *cancelCtx) Value(key interface{}) interface{} {
+	if key == &cancelCtxKey {
+		return c
+	}
+	return c.Context.Value(key)
+}
+
+func (c *cancelCtx) Done() <-chan struct{} {
+	d := c.done.Load()
+	if d != nil {
+		return d.(chan struct{})
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	d = c.done.Load()
+	if d == nil {
+		d = make(chan struct{})
+		c.done.Store(d)
+	}
+	return d.(chan struct{})
+}
+
+func (c *cancelCtx) Err() error {
+	c.mu.Lock()
+	err := c.err
+	c.mu.Unlock()
+	return err
+}
+
+type stringer interface {
+	String() string
+}
+
+func contextName(c Context) string {
+	if s, ok := c.(stringer); ok {
+		return s.String()
+	}
+	return reflect.TypeOf(c).String()
+}
+
+func (c *cancelCtx) String() string {
+	return contextName(c.Context) + ".WithCancel"
+}
+
+// cancel closes c.done, cancels each of c's children, and, if
+// removeFromParent is true, removes c from its parent's children.
+func (c *cancelCtx) cancel(removeFromParent bool, err error) {
+	if err == nil {
+		panic("context: internal error: missing cancel error")
+	}
+	c.mu.Lock()
+	if c.err != nil {
+		c.mu.Unlock()
+		return // already canceled
+	}
+	c.err = err
+	d, _ := c.done.Load().(chan struct{})
+	if d == nil {
+		c.done.Store(closedchan)
+	} else {
+		close(d)
+	}
+	for child := range c.children {
+		// NOTE: acquiring the child's lock while holding parent's lock.
+		child.cancel(false, err)
+	}
+	c.children = nil
+	c.mu.Unlock()
+
+	if removeFromParent {
+		removeChild(c.Context, c)
+	}
+}
+
+// WithDeadline returns a copy of the parent context with the deadline adjusted
+// to be no later than d. If the parent's deadline is already earlier than d,
+// WithDeadline(parent, d) is semantically equivalent to parent. The returned
+// context's Done channel is closed when the deadline expires, when the returned
+// cancel function is called, or when the parent context's Done channel is
+// closed, whichever happens first.
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete.
+func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
+	if parent == nil {
+		panic("cannot create context from nil parent")
+	}
+	if cur, ok := parent.Deadline(); ok && cur.Before(d) {
+		// The current deadline is already sooner than the new one.
+		return WithCancel(parent)
+	}
+	c := &timerCtx{
+		cancelCtx: newCancelCtx(parent),
+		deadline:  d,
+	}
+	propagateCancel(parent, c)
+	dur := time.Until(d)
+	if dur <= 0 {
+		c.cancel(true, DeadlineExceeded) // deadline has already passed
+		return c, func() { c.cancel(false, Canceled) }
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.err == nil {
+		c.timer = time.AfterFunc(dur, func() {
+			c.cancel(true, DeadlineExceeded)
+		})
+	}
+	return c, func() { c.cancel(true, Canceled) }
+}
+
+// A timerCtx carries a timer and a deadline. It embeds a cancelCtx to
+// implement Done and Err. It implements cancel by stopping its timer then
+// delegating to cancelCtx.cancel.
+type timerCtx struct {
+	cancelCtx
+	timer *time.Timer // Under cancelCtx.mu.
+
+	deadline time.Time
+}
+
+func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
+	return c.deadline, true
+}
+
+func (c *timerCtx) String() string {
+	return contextName(c.cancelCtx.Context) + ".WithDeadline(" +
+		c.deadline.String() + " [" +
+		time.Until(c.deadline).String() + "])"
+}
+
+func (c *timerCtx) cancel(removeFromParent bool, err error) {
+	c.cancelCtx.cancel(false, err)
+	if removeFromParent {
+		// Remove this timerCtx from its parent cancelCtx's children.
+		removeChild(c.cancelCtx.Context, c)
+	}
+	c.mu.Lock()
+	if c.timer != nil {
+		c.timer.Stop()
+		c.timer = nil
+	}
+	c.mu.Unlock()
+}
+
+// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete:
+//
+// 	func slowOperationWithTimeout(ctx context.Context) (Result, error) {
+// 		ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
+// 		defer cancel()  // releases resources if slowOperation completes before timeout elapses
+// 		return slowOperation(ctx)
+// 	}
+func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
+	return WithDeadline(parent, time.Now().Add(timeout))
+}
+
+// WithValue returns a copy of parent in which the value associated with key is
+// val.
+//
+// Use context Values only for request-scoped data that transits processes and
+// APIs, not for passing optional parameters to functions.
+//
+// The provided key must be comparable and should not be of type
+// string or any other built-in type to avoid collisions between
+// packages using context. Users of WithValue should define their own
+// types for keys. To avoid allocating when assigning to an
+// interface{}, context keys often have concrete type
+// struct{}. Alternatively, exported context key variables' static
+// type should be a pointer or interface.
+func WithValue(parent Context, key, val interface{}) Context {
+	if parent == nil {
+		panic("cannot create context from nil parent")
+	}
+	if key == nil {
+		panic("nil key")
+	}
+	if !reflect.TypeOf(key).Comparable() {
+		panic("key is not comparable")
+	}
+	return &valueCtx{parent, key, val}
+}
+
+// A valueCtx carries a key-value pair. It implements Value for that key and
+// delegates all other calls to the embedded Context.
+type valueCtx struct {
+	Context
+	key, val interface{}
+}
+
+// stringify tries a bit to stringify v, without using fmt, since we don't
+// want context depending on the unicode tables. This is only used by
+// *valueCtx.String().
+func stringify(v interface{}) string {
+	switch s := v.(type) {
+	case stringer:
+		return s.String()
+	case string:
+		return s
+	}
+	return "<not Stringer>"
+}
+
+func (c *valueCtx) String() string {
+	return contextName(c.Context) + ".WithValue(type " +
+		reflect.TypeOf(c.key).String() +
+		", val " + stringify(c.val) + ")"
+}
+
+func (c *valueCtx) Value(key interface{}) interface{} {
+	if c.key == key {
+		return c.val
+	}
+	return c.Context.Value(key)
+}
+
+// ======================== 以上为 context.go 源码
+
+// MyContext 自定义 context
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 12:45 下午 2021/12/2
+type MyContext struct {
+	Context
+}

demo/context_test.go

@@ -0,0 +1,42 @@
+// Package demo ...
+//
+// Description : demo ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2021-12-02 12:46 下午
+package demo
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+)
+
+// TestCancelCtx_UDC 测试自定义context
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 12:46 下午 2021/12/2
+func TestCancelCtx_UDC(t *testing.T) {
+	childCancel := true
+
+	parentCtx, parentFunc := WithCancel(Background())
+	mctx := MyContext{parentCtx}
+
+	childCtx, childFun := WithCancel(mctx)
+
+	if childCancel {
+		childFun()
+	} else {
+		parentFunc()
+	}
+
+	fmt.Println("parent context => ", parentCtx, reflect.TypeOf(parentCtx).String())
+	fmt.Println("my context => ", mctx, reflect.TypeOf(mctx).String())
+	fmt.Println("child context => ", childCtx, reflect.TypeOf(childCtx).String())
+
+	// 防止主协程退出太快，子协程来不及打印
+	time.Sleep(5 * time.Second)
+}

easylock/abstruct.go

@@ -1,6 +1,6 @@
-// Package easylock...
+// Package easylock ...
 //
-// Description : easylock...
+// Description : easylock ...
 //
 // Author : go_developer@163.com<白茶清欢>
 //

easylock/define.go

@@ -11,7 +11,7 @@ type option struct {
 	flag string // 锁的标识
 }
 
-// Option 设置option选项
+// OptionFunc 设置option选项
 //
 // Author : go_developer@163.com<白茶清欢>
 //

easylock/error.go

@@ -1,6 +1,6 @@
-// Package easylock...
+// Package easylock ...
 //
-// Description : easylock...
+// Description : easylock ...
 //
 // Author : go_developer@163.com<白茶清欢>
 //

easylock/lock.go

@@ -1,4 +1,4 @@
-// Package easylock...
+// Package easylock ...
 //
 // Description : 包装各种姿势的锁
 //

easylock/lock_segment.go

@@ -1,4 +1,4 @@
-// Package easylock...
+// Package easylock ...
 //
 // Description : 分段的锁
 //

gin/static/define.go

@@ -0,0 +1,18 @@
+// Package static ...
+//
+// Description : static
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2021/12/24 2:18 PM
+package static
+
+// MapRule 定义映射规则
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2:18 PM 2021/12/24
+type MapRule struct {
+	URIPrefix     string `json:"uri_prefix"`      // 路由前缀
+	StaticDirPath string `json:"static_dir_path"` // 静态资源路由
+}

gin/static/static.go

@@ -0,0 +1,25 @@
+// Package static ...
+//
+// Description : 启动静态资源服务器
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2021/12/24 2:14 PM
+package static
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+// Register 静态资源服务器
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2:17 PM 2021/12/24
+func Register(router *gin.Engine, ruleList []*MapRule) {
+	for _, rule := range ruleList {
+		router.StaticFS(rule.URIPrefix, http.Dir(rule.StaticDirPath))
+	}
+}

go.mod

@@ -27,7 +27,7 @@ require (
 	gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df
 	gopkg.in/yaml.v2 v2.4.0
 	gorm.io/driver/mysql v1.2.0
-	gorm.io/gorm v1.22.3
+	gorm.io/gorm v1.22.4
 )
 
 require (
@@ -68,7 +68,7 @@ require (
 	github.com/jcmturner/gokrb5/v8 v8.4.2 // indirect
 	github.com/jcmturner/rpc/v2 v2.0.3 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
-	github.com/jinzhu/now v1.1.2 // indirect
+	github.com/jinzhu/now v1.1.4 // indirect
 	github.com/jonboulle/clockwork v0.2.2 // indirect
 	github.com/json-iterator/go v1.1.11 // indirect
 	github.com/klauspost/compress v1.13.6 // indirect

go.sum

@@ -292,8 +292,10 @@ github.com/jcmturner/rpc/v2 v2.0.3 h1:7FXXj8Ti1IaVFpSAziCZWNzbNuZmnvw/i6CqLNdWfZ
 github.com/jcmturner/rpc/v2 v2.0.3/go.mod h1:VUJYCIDm3PVOEHw8sgt091/20OJjskO/YJki3ELg/Hc=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
-github.com/jinzhu/now v1.1.2 h1:eVKgfIdy9b6zbWBMgFpfDPoAMifwSZagU9HmEU6zgiI=
 github.com/jinzhu/now v1.1.2/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
+github.com/jinzhu/now v1.1.3/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
+github.com/jinzhu/now v1.1.4 h1:tHnRBy1i5F2Dh8BAFxqFzxKqqvezXrL2OW1TnX+Mlas=
+github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/jonboulle/clockwork v0.2.2 h1:UOGuzwb1PwsrDAObMuhUnj0p5ULPj8V/xJ7Kx9qUBdQ=
 github.com/jonboulle/clockwork v0.2.2/go.mod h1:Pkfl5aHPm1nk2H9h0bjmnJD/BcgbGXUBGnn1kMkgxc8=
 github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
@@ -931,8 +933,9 @@ gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gorm.io/driver/mysql v1.2.0 h1:l8+9VwjjyzEkw0PNPBOr2JHhLOGVk7XEnl5hk42bcvs=
 gorm.io/driver/mysql v1.2.0/go.mod h1:4RQmTg4okPghdt+kbe6e1bTXIQp7Ny1NnBn/3Z6ghjk=
-gorm.io/gorm v1.22.3 h1:/JS6z+GStEQvJNW3t1FTwJwG/gZ+A7crFdRqtvG5ehA=
 gorm.io/gorm v1.22.3/go.mod h1:F+OptMscr0P2F2qU97WT1WimdH9GaQPoDW7AYd5i2Y0=
+gorm.io/gorm v1.22.4 h1:8aPcyEJhY0MAt8aY6Dc524Pn+pO29K+ydu+e/cXSpQM=
+gorm.io/gorm v1.22.4/go.mod h1:1aeVC+pe9ZmvKZban/gW4QPra7PRoTEssyc922qCAkk=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

image/define.go

@@ -1,29 +0,0 @@
-// Package image ...
-//
-// Description : image ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 2021-11-29 2:27 下午
-package image
-
-const (
-	// TypeGIF ...
-	TypeGIF = "gif"
-	// TypePNG ...
-	TypePNG = "png"
-	// TypeJPG ...
-	TypeJPG = "jpg"
-	// TypeJPEG ...
-	TypeJPEG = "jpeg"
-)
-
-// ImgInfo ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 2:45 下午 2021/11/29
-type ImgInfo struct {
-	Path string
-	Type string
-}

image/gif.go

@@ -1,195 +0,0 @@
-// Package image ...
-//
-// Description : GIF相关操作
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 2021-11-29 12:43 下午
-package image
-
-import (
-	"errors"
-	"image"
-	"image/color"
-	"image/color/palette"
-	"image/draw"
-	"image/gif"
-	"image/jpeg"
-	"image/png"
-	"os"
-
-	"git.zhangdeman.cn/zhangdeman/gopkg/util"
-)
-
-var (
-	// GIF ...
-	GIF *GIFConvert
-)
-
-func init() {
-	GIF = &GIFConvert{}
-}
-
-// GIFConvert gif转换
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 12:44 下午 2021/11/29
-type GIFConvert struct {
-}
-
-// Generate 生成
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 2:13 下午 2021/11/29
-func (g *GIFConvert) Generate(sourceImageList []string, savePath string) error {
-	if len(sourceImageList) == 0 {
-		return errors.New("source image list is empty")
-	}
-	var (
-		err           error
-		formatImgList []ImgInfo
-		disposals     []byte
-		images        []*image.Paletted
-		// 播放速度设置 , 100 次多少秒
-		delays []int
-	)
-	if formatImgList, err = g.checkImageType(sourceImageList); nil != err {
-		return err
-	}
-
-	for _, imgInfo := range formatImgList {
-		img, gErr := g.loadImage(imgInfo)
-		if nil != gErr {
-			return gErr
-		}
-		cp := g.getPalette(img)
-		//cp:=append(palette.WebSafe,color.Transparent)
-		disposals = append(disposals, gif.DisposalBackground) //透明图片需要设置
-		p := image.NewPaletted(image.Rect(0, 0, 640, 996), cp)
-		draw.Draw(p, p.Bounds(), img, image.ZP, draw.Src)
-		images = append(images, p)
-		delays = append(delays, 100)
-	}
-	gifInstance := &gif.GIF{
-		Image:     images,
-		Delay:     delays,
-		LoopCount: -1,
-		Disposal:  disposals,
-	}
-	f, fErr := os.Create(savePath)
-	if fErr != nil {
-		return fErr
-	}
-	defer func() { _ = f.Close() }()
-	return gif.EncodeAll(f, gifInstance)
-}
-
-// checkImageType 检测图片类型
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 2:16 下午 2021/11/29
-func (g *GIFConvert) checkImageType(sourceImageList []string) ([]ImgInfo, error) {
-	result := make([]ImgInfo, 0)
-	for _, item := range sourceImageList {
-		imgType := util.GetFileType(item)
-		if len(imgType) == 0 {
-			return result, errors.New(item + " parse img type fail!")
-		}
-		result = append(result, ImgInfo{
-			Path: item,
-			Type: imgType,
-		})
-	}
-	return result, nil
-}
-
-// loadImage 加载图片内容
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 2:52 下午 2021/11/29
-func (g *GIFConvert) loadImage(imgInfo ImgInfo) (image.Image, error) {
-	var (
-		err error
-		f   *os.File
-	)
-	if f, err = os.Open(imgInfo.Path); nil != err {
-		return nil, err
-	}
-
-	defer func() {
-		_ = f.Close()
-	}()
-
-	switch imgInfo.Type {
-	case TypePNG:
-		if img, imgErr := png.Decode(f); nil != err {
-			return nil, imgErr
-		} else {
-			return img, nil
-		}
-	case TypeJPEG:
-		fallthrough
-	case TypeJPG:
-		if img, imgErr := jpeg.Decode(f); nil != err {
-			return nil, imgErr
-		} else {
-			return img, nil
-		}
-	case TypeGIF:
-		if img, imgErr := gif.Decode(f); nil != err {
-			return nil, imgErr
-		} else {
-			return img, nil
-		}
-	default:
-		return nil, errors.New(imgInfo.Type + " is not support!")
-	}
-}
-
-// getPalette ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 3:01 下午 2021/11/29
-func (g *GIFConvert) getPalette(m image.Image) color.Palette {
-	p := color.Palette{color.RGBA{0x00, 0x00, 0x00, 0x00}}
-	p9 := color.Palette(palette.Plan9)
-	b := m.Bounds()
-	black := false
-	for y := b.Min.Y; y < b.Max.Y; y++ {
-		for x := b.Min.X; x < b.Max.X; x++ {
-			c := m.At(x, y)
-			cc := p9.Convert(c)
-			if cc == p9[0] {
-				black = true
-			}
-			if g.isInPalette(p, cc) == -1 {
-				p = append(p, cc)
-			}
-		}
-	}
-	if len(p) < 256 && black == true {
-		p[0] = color.RGBA{0x00, 0x00, 0x00, 0x00} // transparent
-		p = append(p, p9[0])
-	}
-	return p
-}
-
-// isInPalette ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 3:01 下午 2021/11/29
-func (g *GIFConvert) isInPalette(p color.Palette, c color.Color) int {
-	ret := -1
-	for i, v := range p {
-		if v == c {
-			return i
-		}
-	}
-	return ret
-}

image/gif_test.go

@@ -1,24 +0,0 @@
-// Package image ...
-//
-// Description : image ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 2021-11-29 3:10 下午
-package image
-
-import (
-	"fmt"
-	"testing"
-)
-
-// TestGIFConvert_Generate ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 3:10 下午 2021/11/29
-func TestGIFConvert_Generate(t *testing.T) {
-	sourceImgList := []string{"./test/1.jpeg", "./test/2.jpeg", "./test/3.jpeg", "./test/4.jpeg"}
-	savePath := "./test/test.gif"
-	fmt.Println(GIF.Generate(sourceImgList, savePath))
-}

json_tool/filter.go

@@ -20,7 +20,7 @@ import (
 	"git.zhangdeman.cn/zhangdeman/gopkg/util"
 )
 
-// NewParseJSONTree 获取解析的实例
+// NewFilter 获取解析的实例
 //
 // Author : go_developer@163.com<白茶清欢>
 //
@@ -32,7 +32,7 @@ func NewFilter(data interface{}, rule map[string]string) *Filter {
 	}
 }
 
-// ParseJSONTree 解析json树
+// Filter 解析json树
 //
 // Author : go_developer@163.com<白茶清欢>
 //

json_tool/json_test.go

@@ -8,6 +8,7 @@
 package json_tool
 
 import (
+	"encoding/json"
 	"fmt"
 	"testing"
 )
@@ -84,3 +85,43 @@ func TestSelect(t *testing.T) {
 	}
 	fmt.Println(d.String())
 }
+
+// TestParse 测试获取JSON数据结构
+//
+// Author : go_developer@163.com<张德满>
+//
+// Date : 10:59 PM 2022/1/9
+func TestParse(t *testing.T) {
+	source := map[string]interface{}{
+		"name": "zhangdeman",
+		"extra": map[string]interface{}{
+			"age":    18,
+			"height": 180,
+			"slice":  []int{1, 2, 3},
+			"obj": map[string]interface{}{
+				"la": "aaaa",
+			},
+		},
+		"slice": []int{1, 2, 3},
+		"map":   map[string]interface{}{"a": 1, "b": 2, "c": 4},
+		"table": []map[string]interface{}{
+			{"name": "alex", "age": 18, "number": 1, "obj": map[string]interface{}{"enen": "en"}},
+			{"name": "bob", "age": 28, "number": 2},
+		},
+		"two_slice": []map[string]interface{}{
+			{
+				"students": []map[string]interface{}{
+					{
+						"name":  "enen",
+						"age":   18,
+						"score": []float64{1, 2, 3, 45},
+					},
+				},
+				"other":     []interface{}{"others"},
+				"read_only": 1,
+			},
+		},
+	}
+	byteData, _ := json.Marshal(source)
+	fmt.Println(GetJSONDataStruct(string(byteData)))
+}

json_tool/parse.go

@@ -0,0 +1,53 @@
+// Package json_tool ...
+//
+// Description : json_tool ...
+//
+// Author : go_developer@163.com<张德满>
+//
+// Date : 2022-01-09 10:48 PM
+package json_tool
+
+import (
+	"github.com/tidwall/gjson"
+)
+
+// GetJSONDataStruct 获取JSON数据的结构
+//
+// Author : go_developer@163.com<张德满>
+//
+// Date : 10:53 PM 2022/1/9
+func GetJSONDataStruct(data string) []string {
+	pathList := make([]string, 0)
+	r := gjson.Parse(data)
+	r.ForEach(func(key, value gjson.Result) bool {
+		if value.IsObject() {
+			list := GetJSONDataStruct(value.String())
+			for _, k := range list {
+				pathList = append(pathList, key.String()+"."+k)
+			}
+		}
+
+		if value.IsArray() {
+			dataList := value.Array()
+			if len(dataList) > 0 {
+				if !dataList[0].IsObject() && !dataList[0].IsArray() {
+					pathList = append(pathList, key.String())
+				} else {
+					list := GetJSONDataStruct(dataList[0].String())
+					for _, k := range list {
+						pathList = append(pathList, key.String()+".[]."+k)
+					}
+				}
+			} else {
+				pathList = append(pathList, key.String())
+			}
+		}
+
+		if !value.IsObject() && !value.IsArray() {
+			pathList = append(pathList, key.String())
+		}
+
+		return true
+	})
+	return pathList
+}

logger/wrapper/gorm_v2.go

@@ -10,8 +10,11 @@ package wrapper
 import (
 	"context"
 	"fmt"
+	"strings"
 	"time"
 
+	"github.com/gin-gonic/gin"
+
 	"gorm.io/gorm"
 
 	"go.uber.org/zap/zapcore"
@@ -47,15 +50,36 @@ func NewGormV2(loggerLevel zapcore.Level, consoleOutput bool, encoder zapcore.En
 	}, nil
 }
 
+// NewGormLoggerWithInstance 获取gorm日志实现
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 3:36 PM 2021/12/24
+func NewGormLoggerWithInstance(ctx *gin.Context, dbClient *gorm.DB, instance *zap.Logger, node string, extraCtxFieldList []string) logger.Interface {
+	return &Gorm{
+		dbClient:          dbClient,
+		instance:          instance,
+		traceIDField:      "",
+		extraCtxFieldList: extraCtxFieldList,
+		flag:              "",
+		node:              node,
+		ctx:               ctx,
+	}
+}
+
 // Gorm v2 版本库日志实现
 //
 // Author : go_developer@163.com<白茶清欢>
 //
 // Date : 9:55 下午 2021/3/1
 type Gorm struct {
-	instance     *zap.Logger // 日志实例
-	traceIDField string      // 串联请求上下文的的ID
-	flag         string      // 数据库标识
+	dbClient          *gorm.DB
+	instance          *zap.Logger  // 日志实例
+	traceIDField      string       // 串联请求上下文的的ID
+	extraCtxFieldList []string     // 从请求上线问提取的字段
+	flag              string       // 数据库标识
+	node              string       // 数据库节点 master / slave
+	ctx               *gin.Context // gin上下文
 }
 
 // LogMode ...
@@ -73,12 +97,7 @@ func (g *Gorm) LogMode(level logger.LogLevel) logger.Interface {
 //
 // Date : 10:18 下午 2021/3/1
 func (g *Gorm) Info(ctx context.Context, s string, i ...interface{}) {
-	g.instance.Info(
-		"Info日志",
-		zap.String(g.traceIDField, g.getTraceID(ctx)),
-		zap.String("db_flag", g.flag),
-		zap.String("message", fmt.Sprintf(s, i...)),
-	)
+	g.write(nil, "info")
 }
 
 // Warn ...
@@ -87,12 +106,7 @@ func (g *Gorm) Info(ctx context.Context, s string, i ...interface{}) {
 //
 // Date : 10:16 下午 2021/3/1
 func (g *Gorm) Warn(ctx context.Context, s string, i ...interface{}) {
-	g.instance.Warn(
-		"SQL执行产生Warning",
-		zap.String(g.traceIDField, g.getTraceID(ctx)),
-		zap.String("db_flag", g.flag),
-		zap.String("message", fmt.Sprintf(s, i...)),
-	)
+	g.write(nil, "warn")
 }
 
 // Error 日志
@@ -101,12 +115,7 @@ func (g *Gorm) Warn(ctx context.Context, s string, i ...interface{}) {
 //
 // Date : 10:18 下午 2021/3/1
 func (g *Gorm) Error(ctx context.Context, s string, i ...interface{}) {
-	g.instance.Warn(
-		"SQL执行产生Error",
-		zap.String(g.traceIDField, g.getTraceID(ctx)),
-		zap.String("db_flag", g.flag),
-		zap.String("message", fmt.Sprintf(s, i...)),
-	)
+	g.write(nil, "error")
 }
 
 // Trace Trace 记录
@@ -123,8 +132,7 @@ func (g *Gorm) Trace(ctx context.Context, begin time.Time, fc func() (string, in
 		sql, affectRows = fc()
 	}
 
-	g.instance.Info(
-		"SQL执行记录",
+	dataList := []zap.Field{
 		zap.String(g.traceIDField, g.getTraceID(ctx)),
 		zap.String("db_flag", g.flag),
 		zap.Int64("begin_time", start),
@@ -133,7 +141,45 @@ func (g *Gorm) Trace(ctx context.Context, begin time.Time, fc func() (string, in
 		zap.String("sql", sql),
 		zap.Int64("affect_rows", affectRows),
 		zap.Error(err),
-	)
+	}
+	g.write(dataList, "info")
+
+}
+
+// write ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 4:11 PM 2021/12/24
+func (g *Gorm) write(dataList []zap.Field, level string) {
+	if nil == g.instance {
+		// 未设置日志实例
+		return
+	}
+	if nil == dataList {
+		dataList = make([]zap.Field, 0)
+	}
+	if nil != g.ctx {
+		for _, extraField := range g.extraCtxFieldList {
+			dataList = append(dataList, zap.Any(extraField, g.ctx.Value(extraField)))
+		}
+	}
+
+	// 补齐 flag、node
+	sql := g.dbClient.Dialector.Explain(g.dbClient.Statement.SQL.String(), g.dbClient.Statement.Vars...)
+	affectRows := g.dbClient.RowsAffected
+	dataList = append(dataList, zap.String("db_node", g.node), zap.String("db_flag", g.flag), zap.String("execute_sql", sql), zap.Int64("affext_rows", affectRows))
+	message := "SQL执行记录"
+	switch strings.ToLower(level) {
+	case "info":
+		g.instance.Info(message, dataList...)
+	case "warn":
+		g.instance.Warn(message, dataList...)
+	case "error":
+		g.instance.Error(message, dataList...)
+	default:
+		g.instance.Info(message, dataList...)
+	}
 }
 
 // getTraceID 获取traceID
@@ -145,7 +191,7 @@ func (g *Gorm) getTraceID(ctx context.Context) string {
 	return fmt.Sprintf("%v", ctx.Value(g.traceIDField))
 }
 
-// GetGormSQL 获取tracefn
+// GetGormSQL 获取trace fn
 //
 // Author : go_developer@163.com<白茶清欢>
 //

middleware/mysql/client.go

@@ -10,14 +10,107 @@ package mysql
 import (
 	"fmt"
 
-	"git.zhangdeman.cn/zhangdeman/gopkg/logger"
-
 	"git.zhangdeman.cn/zhangdeman/gopkg/logger/wrapper"
+	"github.com/gin-gonic/gin"
+
+	"go.uber.org/zap"
+
+	"git.zhangdeman.cn/zhangdeman/gopkg/logger"
+	gormLogger "gorm.io/gorm/logger"
 
 	"gorm.io/driver/mysql"
 	"gorm.io/gorm"
 )
 
+// NewDBClient ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 3:09 PM 2021/12/24
+func NewDBClient(masterConf *DBConfig, slaveConf *DBConfig, logConf *LogConfig, loggerInstance *zap.Logger, extraRequestFieldList []string) (*DBClient, error) {
+	client := &DBClient{
+		extraFieldList: extraRequestFieldList,
+	}
+	var err error
+	// 日志初始化失败
+	if client.loggerInstance, err = getLogInstance(logConf, loggerInstance); nil != err {
+		return nil, err
+	}
+	if client.master, err = GetDatabaseClient(masterConf, nil); nil != err {
+		return nil, err
+	}
+	if client.slave, err = GetDatabaseClient(slaveConf, nil); nil != err {
+		return nil, err
+	}
+	return client, nil
+}
+
+// DBClient 包装日志实例
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 3:09 PM 2021/12/24
+type DBClient struct {
+	loggerInstance *zap.Logger
+	master         *gorm.DB
+	slave          *gorm.DB
+	extraFieldList []string
+}
+
+// GetMaster 获取主库连接
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 3:28 PM 2021/12/24
+func (dc *DBClient) GetMaster(ctx *gin.Context) *gorm.DB {
+	session := dc.master.Session(&gorm.Session{})
+	session.Logger = dc.getLogger(ctx, session, "slave")
+	return session
+}
+
+// GetSlave 获取从库链接
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 3:29 PM 2021/12/24
+func (dc *DBClient) GetSlave(ctx *gin.Context) *gorm.DB {
+	session := dc.slave.Session(&gorm.Session{})
+	session.Logger = dc.getLogger(ctx, session, "slave")
+	return session
+}
+
+// getLogger 获取日志实例
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 3:45 PM 2021/12/24
+func (dc *DBClient) getLogger(ctx *gin.Context, dbClient *gorm.DB, node string) gormLogger.Interface {
+	return wrapper.NewGormLoggerWithInstance(ctx, dbClient, dc.loggerInstance, node, dc.extraFieldList)
+}
+
+// getLogInstance 获取日志实例
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 3:20 PM 2021/12/24
+func getLogInstance(logConf *LogConfig, loggerInstance *zap.Logger) (*zap.Logger, error) {
+	if nil != loggerInstance {
+		return loggerInstance, nil
+	}
+	logConfList := []logger.SetLoggerOptionFunc{logger.WithEncoder(logConf.Encoder), logger.WithCallerSkip(logConf.Skip), logger.WithCaller()}
+	if logConf.ConsoleOutput {
+		logConfList = append(logConfList, logger.WithConsoleOutput())
+	}
+
+	var (
+		err error
+	)
+	if loggerInstance, err = logger.NewLogger(logConf.Level, logConf.SplitConfig, logConfList...); nil != err {
+		return nil, err
+	}
+	return loggerInstance, nil
+}
+
 // GetDatabaseClient 获取日志实例
 //
 // Author : go_developer@163.com<白茶清欢>
@@ -25,35 +118,22 @@ import (
 // Date : 10:49 下午 2021/3/1
 func GetDatabaseClient(conf *DBConfig, logConf *LogConfig) (*gorm.DB, error) {
 	var (
-		instance *gorm.DB
-		err      error
+		instance       *gorm.DB
+		err            error
+		loggerInstance *zap.Logger
 	)
 
 	if instance, err = gorm.Open(mysql.Open(buildConnectionDSN(conf)), &gorm.Config{}); nil != err {
 		return nil, err
 	}
 
-	if len(logConf.TraceFieldName) == 0 {
-		logConf.TraceFieldName = defaultTraceFieldName
+	if nil != logConf {
+		if loggerInstance, err = getLogInstance(logConf, nil); nil != err {
+			return nil, err
+		}
+		instance.Logger = wrapper.NewGormLoggerWithInstance(nil, instance, loggerInstance, "", nil)
 	}
 
-	splitConfigFuncList := []logger.SetRotateLogConfigFunc{
-		logger.WithTimeIntervalType(logConf.SplitConfig.TimeIntervalType),
-		logger.WithDivisionChar(logConf.SplitConfig.DivisionChar),
-		logger.WithMaxAge(logConf.SplitConfig.MaxAge),
-	}
-
-	splitConfig, _ := logger.NewRotateLogConfig(logConf.SplitConfig.LogPath, logConf.SplitConfig.LogFileName, splitConfigFuncList...)
-
-	if instance.Logger, err = wrapper.NewGormV2(
-		logConf.Level,
-		logConf.ConsoleOutput,
-		logConf.Encoder,
-		splitConfig,
-		logConf.TraceFieldName,
-		logConf.Skip); nil != err {
-		return nil, CreateDBLogError(err)
-	}
 	return instance, nil
 }
 

middleware/mysql/define.go

@@ -42,8 +42,3 @@ type LogConfig struct {
 	TraceFieldName   string
 	Skip             int
 }
-
-const (
-	// defaultTraceFieldName 默认trace_id字段
-	defaultTraceFieldName = "trace_id"
-)

proxy/forward.go

@@ -8,13 +8,11 @@
 package proxy
 
 import (
-	"bytes"
 	"compress/gzip"
-	"fmt"
 	"io"
 	"io/ioutil"
-	"net"
 	"net/http"
+	"net/http/httputil"
 	"strings"
 )
 
@@ -24,72 +22,30 @@ import (
 //
 // Date : 2:08 下午 2021/8/6
 func Forward(rw http.ResponseWriter, req *http.Request, serverConfig *Server) {
-	fmt.Printf("Received request %s %s %s\n", req.Method, req.Host, req.RemoteAddr)
 
-	transport := http.DefaultTransport
-
-	// step 1
-	outReq := new(http.Request)
-	*outReq = *req // this only does shallow copies of maps
-
-	if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
-		if prior, ok := outReq.Header["X-Forwarded-For"]; ok {
-			clientIP = strings.Join(prior, ", ") + ", " + clientIP
-		}
-		outReq.Header.Set("X-Forwarded-For", clientIP)
+	if !strings.HasPrefix(serverConfig.URI, "/") {
+		serverConfig.URI = "/" + serverConfig.URI
 	}
-
-	// 写入重写的请求Header
-	for k, v := range serverConfig.RewriteRequestHeader {
-		outReq.Header.Set(k, v)
-	}
-
-	// 重写请求地址
-	outReq.Host = serverConfig.Host
-	outReq.URL.Path = serverConfig.URI
-	outReq.URL.Scheme = serverConfig.Scheme
-	outReq.URL.Host = serverConfig.Host
-
-	// step 2
-	res, err := transport.RoundTrip(outReq)
-	if err != nil {
-		rw.WriteHeader(http.StatusBadGateway)
-		return
-	}
-
-	// step 3
-	for key, value := range res.Header {
-		for _, v := range value {
-			if strings.ToLower(key) == "content-encoding" {
-				continue
-			}
-			rw.Header().Add(key, v)
+	// 请求重写方法
+	director := func(req *http.Request) {
+		req.URL.Scheme = serverConfig.Scheme
+		// req.URL.Host = projectDetail.GetProjectDetail().Domain + ":" + fmt.Sprintf("%v", projectDetail.GetProjectDetail().Port)
+		// req.Host = projectDetail.GetProjectDetail().Domain + ":" + fmt.Sprintf("%v", projectDetail.GetProjectDetail().Port)
+		req.Host = serverConfig.Host
+		req.URL.Host = serverConfig.Host
+		req.URL.Path = serverConfig.URI
+		req.RequestURI = serverConfig.URI
+		// 写入重写的请求Header
+		for k, v := range serverConfig.RewriteRequestHeader {
+			req.Header.Set(k, v)
 		}
 	}
-
-	rw.WriteHeader(res.StatusCode)
-
-	// 重写请求header
-	for k, v := range serverConfig.RewriteResponseHeader {
-		rw.Header().Set(k, v)
+	// TODO : 重写响应数据
+	modifyResponseFunc := func(rep *http.Response) error {
+		return nil
 	}
-
-	defer res.Body.Close()
-
-	// 重写响应数据
-	if !strings.Contains(strings.ToLower(res.Header.Get("Content-Type")), "application/json") || nil == serverConfig.RewriteResponseData || len(serverConfig.RewriteResponseData) == 0 {
-		_, _ = io.Copy(rw, res.Body)
-		return
-	}
-	var (
-		responseData []byte
-	)
-
-	responseData, err = getResponseData(res)
-	fmt.Println(string(responseData), err)
-
-	bytesBuffer := bytes.NewReader([]byte(`{"data":{"permission":true}}`))
-	_, _ = io.Copy(rw, bytesBuffer)
+	p := &httputil.ReverseProxy{Director: director, ModifyResponse: modifyResponseFunc}
+	p.ServeHTTP(rw, req)
 }
 
 // getResultCompressType 获取返回结果的压缩方式

util/file.go

@@ -85,16 +85,3 @@ func IsFileExist(filePath string) (bool, bool) {
 	f, err := os.Stat(filePath)
 	return nil == err || os.IsExist(err), (nil == err || os.IsExist(err)) && !f.IsDir()
 }
-
-// GetFileType 获取文件类型
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 2:30 下午 2021/11/29
-func GetFileType(fileName string) string {
-	fileArr := strings.Split(fileName, ".")
-	if len(fileArr) < 2 {
-		return ""
-	}
-	return strings.ToLower(fileArr[len(fileArr)-1])
-}