function decoration
It is often necessary to use function decoration to make basic components. For example, I need to print start and end for all decorated methods.
Decoration for known function signatures
The function decorators we often use generally know the signature of the method being decorated, and then return a method with the same signature. The simplest example, kite 's middleware, actually decorates the handler method.
type EndPoint func(ctx context.Context, req interface{}) (resp interface{}, err error)
func Middleware(next endpoint.EndPoint) endpoint.EndPoint {
return func(ctx context.Context, req interface{}) (resp interface{}, err error) {
// before do something...
next(ctx, req)
// after do something...
}
}
So it is essentially the calling form of fa (fb(fc( fd (req)))) .
The basis of this function decoration is that each decorated method knows the signature of the decorated function. When the func signature is changed, the decorated method is unavailable.
How to solve the decoration of generic functions?
The decorator is essentially to generate a func, and the reflection package has a general method of generating func, golang.org/pkg/reflect…
func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value
MakeFunc returns a new function of the given Type that wraps the function fn. When called, that new function does the following:
- converts its arguments to a slice of Values.
- runs results := fn(args).
- returns the results as a slice of Values, one per formal result.
The input parameters of makefunc are type and func, so you need to solve the type of the decoration method, you can use the TypeOf method in the reflection package
func TypeOf(i interface{}) Type
To decorate a generic function, the input parameters of all decorators must be interface, then the preliminary design of the decorator is
func Decorate(f interface{}) interface{} {
fn := reflect.ValueOf(f)
v := reflect.MakeFunc(fn.Type(), logicFunc)
return v.Interface()
}
The next step is to solve the problem of logicFunc. According to the description of MakeFunc, v is a func with a higher type, and the result of v(args) is the execution result of logicFunc(args), so the logic of logicFunc is what the decorator needs to do , the method signature of logicFunc has been fixed
func(args []Value) (results []Value)
So directly consider the implementation of logicFunc, there is a reflection package
func (v Value) Call(in []Value) []Value
The call of any function after reflection can be realized, so the original function can also be used directly in logicFunc, analogous to next(ctx, req) in middleware.
func(in []reflect.Value) []reflect.Value {
fn := reflect.ValueOf(f)
// ...
ret := fn.Call(in)
// ...
return ret
}
So the final generic function decorator is
func Decorate(f interface{}) interface{} {
fn := reflect.ValueOf(f)
logicFunc := func(in []reflect.Value) []reflect.Value {
fn := reflect.ValueOf(f)
// before do something...
ret := fn.Call(in)
// after do something...
return ret
}
v := reflect.MakeFunc(fn.Type(), logicFunc)
return v.Interface()
}
This decorator is still awkward to use
func foo(a, b, c int) (int, error) {
return a + b + c, nil
}
func main() {
decorateFoo := Decorate(foo2)
if fn, ok := decorateFoo.(func(a, b, c int) (int, error)); ok {
ret, err := fn(1, 2, 3)
fmt.Println(ret, err)
}
}
The signature of the decorated method needs to be asserted before each use.
能不能不进行断言呢，因为被修饰的方法本身就是入参，但是为了通用性，入参必须定义为interface，那么考虑出参也在使用前定义好签名。也就是装饰器把返回值当入参由使用方来传入。这也是左耳朵耗子推荐的用法
func Decorate(decoPtr, f interface{}) error {
fn := reflect.ValueOf(f)
decoratedFunc := reflect.ValueOf(decoPtr).Elem()
logicFunc := func(in []reflect.Value) []reflect.Value {
// before do something...
ret := fn.Call(in)
// after do something...
return ret
}
v := reflect.MakeFunc(fn.Type(), logicFunc)
decoratedFunc.Set(v)
return nil
}
使用示例
func foo1(a, b, c int) (int, error) {
return a + b + c, nil
}
func main() {
decorateFoo := foo1
Decorate(&decorateFoo, foo1)
ret, err := decorateFoo(1, 2, 3)
fmt.Println(ret, err)
}
反射更改接口类型的值
有这个想法是因为在通用函数的装饰里，假设所有方法的返回值最后一位都是error，但每个方法签名不一样，怎么能做到在通用装饰里，把所有的返回error置为nil
先看普通变量赋值场景
reflect包里有set**接口，其中通用set接口说明为
func (v Value) Set(x Value)
Set assigns x to the value v. It panics if CanSet returns false. As in Go, x's value must be assignable to v's type.
那么对普通变量进行赋值
var a int64
v := reflect.ValueOf(a)
v.Set(reflect.ValueOf(int64(3)))
println(a)
这段代码是会panic的，可以看set接口的的说明，查看canset为false
println(v.CanSet())
因为go都是值复制的，所以v内的a只是个副本，不能set就好理解了。稍微变通一下就可以了，利用地址传递。 直接来个普通变量正常赋值的情况
var a int64
v := reflect.ValueOf(&a).Elem()
println(v.CanSet())
v.Set(reflect.ValueOf(int64(3)))
println(a)
对接口类型反射赋值
我们先定义一个接口和实现类
type itf interface {
String() string
}
type impl struct {
}
func (*impl) String() string {
return "itf impl"
}
参考普通变量赋值，可以写接口的赋值方法
func main() {
var a itf
v := reflect.ValueOf(&a).Elem()
println(v.CanSet())
actual := &impl{}
v.Set(reflect.ValueOf(actual))
println(a.String())
}
对接口类型反射置nil
有的场景下，是接口类型有值，但是要把这个值置空，例如感知到下游的err后要返回nil，但是每个方法的签名不一样，只知道返回值最后一位是err
var a itf
a = &impl{}
v := reflect.ValueOf(&a).Elem()
println(v.CanSet())
v.Set(reflect.ValueOf(nil))
println(a)
上述代码会直接保存，因为对nil进行反射取value得到的是空结果，set不进去。 分析我们需要set的其实是个接口itf的0值，reflect包里是有0值构造器的
func Zero(typ Type) Value
Zero方法的入参typ 应该是我们需要操作的接口类型itf, 很自然会想到
var b itf
zero := reflect.Zero(reflect.TypeOf(b))
v.Set(zero)
但是这里的b实际上也是nil，所以reflect.Typeof(nil)并不会返回itf的type。所以需要转一道, 取b的地址，然后利用elem取值
var b itf
zero := reflect.Zero(reflect.TypeOf(&b).Elem())
v.Set(zero)
所以把接口类型变量置nil的完整写法应该是
func main() {
var a itf
a = &impl{}
v := reflect.ValueOf(&a).Elem()
println(v.CanSet())
var b itf
zero := reflect.Zero(reflect.TypeOf(&b).Elem())
v.Set(zero)
println(a)
println(a == nil)
}
分析发现 var b itf实际上是多余的，只是为了一个类型，可以省略掉
zero := reflect.Zero(reflect.TypeOf((*itf)(nil)).Elem())
综上完成了对接口类型置nil的操作。