golang aop

core.go

// @Title aop流程core
// @Description 参考gin库实现aop的core

package flow

import ctx "context"

type WrapF struct {
    f func(ctx ctx.Context) error

    ctx *Context
}

func WrapFunc(ctx ctx.Context, f func(ctx ctx.Context) error) *WrapF {
    return &WrapF{
        f:   f,
        ctx: newContext(ctx),
    }
}

func (wf *WrapF) UseBefore(f func(c *Context) error) {
    wf.ctx.addBeforeHandler(f)
}

func (wf *WrapF) UseBehind(f func(c *Context) error) {
    wf.ctx.addBehindHandler(f)
}

func (wf *WrapF) Handle() error {
    var err error
    wf.ctx.handlers = append(wf.ctx.handlers, wf.ctx.beforeHandlers...)
    wf.ctx.handlers = append(wf.ctx.handlers, func(c *Context) error {
        err := wf.f(wf.ctx)
        return err
    })
    wf.ctx.handlers = append(wf.ctx.handlers, wf.ctx.behindHandlers...)

    if len(wf.ctx.handlers) > 0 {
        err = wf.ctx.Next()
    }
    wf.ctx.Reset()

    return err
}

context.go

// @Title aop流程context
// @Description 参考gin库实现aop的context

package flow

import (
    ctx "context"
    "math"
)

const abort = math.MaxInt32 - 10000
const PAYLOADKEY = "payload"

type Context struct {
    ctx.Context
    offset         int
    beforeHandlers []func(ctx *Context) error
    behindHandlers []func(ctx *Context) error
    handlers       []func(ctx *Context) error
}

func newContext(ctx ctx.Context) *Context {
    return &Context{
        Context:        ctx,
        offset:         -1,
        beforeHandlers: make([]func(*Context) error, 0, 10),
        behindHandlers: make([]func(*Context) error, 0, 10),
        handlers:       make([]func(*Context) error, 0, 20),
    }
}

func (ctx *Context) Next() error {
    ctx.offset++
    s := len(ctx.handlers)
    for ; ctx.offset < s; ctx.offset++ {
        if !ctx.isAbort() {
            err := ctx.handlers[ctx.offset](ctx)
            if err != nil {
                return err
            }
        } else {
            return nil
        }
    }

    return nil
}

func (ctx *Context) Reset() {
    //ctx.PerRequestContext = &sync.Map{}
    ctx.offset = -1
    ctx.behindHandlers = ctx.handlers[:0]
    ctx.beforeHandlers = ctx.handlers[:0]
    ctx.handlers = ctx.handlers[:0]
}

func (ctx *Context) Abort() {
    ctx.offset = math.MaxInt32 - 10000
}

func (ctx *Context) isAbort() bool {
    if ctx.offset >= abort {
        return true
    }
    return false
}

func (ctx *Context) addBeforeHandler(f func(ctx *Context) error) {
    ctx.beforeHandlers = append(ctx.beforeHandlers, f)
}

func (ctx *Context) addBehindHandler(f func(ctx *Context) error) {
    ctx.behindHandlers = append(ctx.behindHandlers, f)
}

测试main.go

package main

import (
    "context"
    "errors"
    "fmt"
    "main/flow/flow"
)

type Payload struct {
    a int
    b int
}

type I interface {
    AlertTimeout()
}

func Fl() {
    payload := Payload{
        a: 1,
        b: 2,
    }
    a := 5
    c := context.WithValue(context.Background(), flow.PAYLOADKEY, &payload)
    wrapF := flow.WrapFunc(c, func(c context.Context) error {
        handle1(c, a)
        //pay := c.Value(flow.PAYLOADKEY).(*Payload)

        fmt.Println("000000000000000")

        return nil
    })
    wrapF.UseBefore(AlertTimeout)
    wrapF.UseBehind(Sentinel)
    err := wrapF.Handle()
    fmt.Println(err)

}

func main() {
    Fl()
    //wrapF2 := flow.WrapFunc(a, func() {
    //  handle2(a)
    //})
    //wrapF2.Use(AlertTimeout)
    //wrapF2.Use(Sentinel)
    //wrapF2.Handle()

}

func AlertTimeout(c *flow.Context) error {
    pay := c.Value(flow.PAYLOADKEY).(*Payload)
    pay.b = 1000

    fmt.Println("before")

    return nil
}

func Sentinel(c *flow.Context) error {
    fmt.Println("behind")

    return errors.New("ppppppppp")
}

func handle1(c context.Context, a int) int {
    fmt.Println("main1")
    //fmt.Println(c.Value(flow.PAYLOADKEY).(Payload).b)

    return 67
}

func handle2(a interface{}) {
    fmt.Println("main2")
}

请仔细阅读并实验该aop方案，代码参照gin、k8s中visitor、，包含对错误处理机制的调研

golang的错误处理机制

1. 接口定义，直观返回error

package errs

import "github.com/pkg/errors"

type A interface {
    Enter() error
    Visit() error
    Leave() error
}

func B(a A, i int, j int) error {
    if err := a.Enter(); err != nil {

        return errors.WithMessage(err, "Enter failed")
    }

    if err := a.Visit(); err != nil {

        return errors.WithMessage(err, "visit failed")
    }

    if err := a.Leave(); err != nil {

        return errors.WithMessage(err, "leave failed")
    }

    return nil
}

分步骤处理，可以针对具体返回结果进行处理
2.屏蔽过程中的error处理

package errs

import "github.com/pkg/errors"

type A interface {
    Enter()
    Visit()
    Leave()
    
    Err() error
}

func B(a A) error {
    a.Enter()
    a.Visit()
    a.Leave()
    
    if err := a.Err(); err != nil {
        
        return errors.WithMessage(err, "failed")
    }

    return nil
}

type C struct {
    err error
}

func (l *C) Visit()  {
    if l.err != nil {
        return
    }
}

将error保存稻草对象内部，处理逻辑交给每个方法，本质上还是顺序执行
aop我第一版实现就是用这种方式处理错误
3.上面aop为第三种err处理，是目前最为优雅的，利用函数式编程的yan'c