Golang框架实战-KisFlow流式计算框架专栏
Golang框架实战-KisFlow流式计算框架(1)-概述
Golang框架实战-KisFlow流式计算框架(2)-项目构建/基础模块-(上)
Golang框架实战-KisFlow流式计算框架(3)-项目构建/基础模块-(下)
Golang框架实战-KisFlow流式计算框架(4)-数据流
Golang框架实战-KisFlow流式计算框架(5)-Function调度
Golang框架实战-KisFlow流式计算框架(6)-Connector
Golang框架实战-KisFlow流式计算框架(7)-配置导入与导出
Golang框架实战-KisFlow流式计算框架(8)-KisFlow Action
Golang框架实战-KisFlow流式计算框架(9)-Cache/Params 数据缓存与数据参数
Golang框架实战-KisFlow流式计算框架(10)-Flow多副本
接下来我们来增强KisFlow中Function对业务数据处理的聚焦，将之前Function的写法：
func FuncDemo3Handler(ctx context.Context, flow kis.Flow) error {
fmt.Println("---> Call funcName3Handler ----")
fmt.Printf("Params = %+v\n", flow.GetFuncParamAll())
for _, row := range flow.Input() {
str := fmt.Sprintf("In FuncName = %s, FuncId = %s, row = %s", flow.GetThisFuncConf().FName, flow.GetThisFunction().GetId(), row)
fmt.Println(str)
}
return nil
}
是从flow.Input()中 获取到原始数据，改成可以直接获取到业务想要的具体数据结构类型，而无需断言等类型判断和转换。改成的Function扩展参数用法大致如下：
proto
type StuScores struct {
StuId int `json:"stu_id"`
Score1 int `json:"score_1"`
Score2 int `json:"score_2"`
Score3 int `json:"score_3"`
}
type StuAvgScore struct {
StuId int `json:"stu_id"`
AvgScore float64 `json:"avg_score"`
}
FaaS
type AvgStuScoreIn struct {
serialize.DefaultSerialize
proto.StuScores
}
type AvgStuScoreOut struct {
serialize.DefaultSerialize
proto.StuAvgScore
}
// AvgStuScore(FaaS) 计算学生平均分
func AvgStuScore(ctx context.Context, flow kis.Flow, rows []*AvgStuScoreIn) error {
for _, row := range rows {
avgScore := proto.StuAvgScore{
StuId: row.StuId,
AvgScore: float64(row.Score1+row.Score2+row.Score3) / 3,
}
// 提交结果数据
_ = flow.CommitRow(AvgStuScoreOut{StuAvgScore: avgScore})
}
return nil
}
这样，我们可以通过第三个形式参数rows直接拿到我们期待的目标输出结构体数据，不需要断言和转换，更加关注业务方的开发效率。
当然，如果你希望获取到原始的数据，依然可以从flow.Input()中获取到。
本章将实现KisFlow上述功能。
11.1 FaaS业务回调函数自描述
本节将完成FaaS的自描述概念改造，我们知道之前的FaaS回调如下：
type FaaS func(context.Context, Flow) error
那么我们需要一个结构体，来描述这个函数属性，包括他的函数名称、函数地址、形参数量、相残类型、返回值类型等等。
11.1.1 FaaSDesc 回调自描述类型
在kis-flow/kis/下，新创建一个文件faas.go，定义如下结构体：
kis-flow/kis/faas.go
// FaaS Function as a Service
// 将
// type FaaS func(context.Context, Flow) error
// 改为
// type FaaS func(context.Context, Flow, ...interface{}) error
// 可以通过可变参数的任意输入类型进行数据传递
type FaaS interface{}
// FaaSDesc FaaS 回调计算业务函数 描述
type FaaSDesc struct {
FnName string // Function名称
f interface{} // FaaS 函数
fName string // 函数名称
ArgsType []reflect.Type // 函数参数类型（集合）
ArgNum int // 函数参数个数
FuncType reflect.Type // 函数类型
FuncValue reflect.Value // 函数值(函数地址)
}
将之前的FaaS改进成interface{}，而FaaSDesc具备了一些属性。
- FnName: 表示当前Function的名称，例如我们之前例子的"funcDemo1" 等，这个是用来KisFlow给Function标识的FunctionName。
- f：表示定义的FaaS函数。
- fName： 定义f函数的函数名称。
- ArgsType：定义的f函数的形参类型列表，这是一个slice。
- ArgNum：定义的f函数的输入形参个数。
- FuncType：定义的f函数的数据类型。
- FuncValue：定义的f函数的函数值（可以被调度的函数地址）。
11.1.2 新建一个FaaSDesc对象
下面，提供一个新建FaaSDesc的构造函数，形参的类型就是KisFlow的FunctionName和定义的FaaS函数，如下：
kis-flow/kis/faas.go
// NewFaaSDesc 根据用户注册的FnName 和FaaS 回调函数，创建 FaaSDesc 描述实例
func NewFaaSDesc(fnName string, f FaaS) (*FaaSDesc, error) {
// 传入的回调函数FaaS,函数值(函数地址)
funcValue := reflect.ValueOf(f)
// 传入的回调函数FaaS 类型
funcType := funcValue.Type()
// 判断传递的FaaS指针是否是函数类型
if !isFuncType(funcType) {
return nil, fmt.Errorf("provided FaaS type is %s, not a function", funcType.Name())
}
// 判断传递的FaaS函数是否有返回值类型是只包括(error)
if funcType.NumOut() != 1 || funcType.Out(0) != reflect.TypeOf((*error)(nil)).Elem() {
return nil, errors.New("function must have exactly one return value of type error")
}
// FaaS函数的参数类型集合
argsType := make([]reflect.Type, funcType.NumIn())
// 获取FaaS的函数名称
fullName := runtime.FuncForPC(funcValue.Pointer()).Name()
// 确保 FaaS func(context.Context, Flow, ...interface{}) error 形参列表，存在context.Context 和 kis.Flow
// 是否包含kis.Flow类型的形参
containsKisFlow := false
// 是否包含context.Context类型的形参
containsCtx := false
// 遍历FaaS的形参类型
for i := 0; i < funcType.NumIn(); i++ {
// 取出第i个形式参数类型
paramType := funcType.In(i)
if isFlowType(paramType) {
// 判断是否包含kis.Flow类型的形参
containsKisFlow = true
} else if isContextType(paramType) {
// 判断是否包含context.Context类型的形参
containsCtx = true
} else if isSliceType(paramType) {
// 判断是否包含Slice类型的形参
// 获取当前参数Slice的元素类型
itemType := paramType.Elem()
// 如果当前参数是一个指针类型，则获取指针指向的结构体类型
if itemType.Kind() == reflect.Ptr {
itemType = itemType.Elem() // 获取指针指向的结构体类型
}
} else {
// Other types are not supported...
}
// 将当前形参类型追加到argsType集合中
argsType[i] = paramType
}
if !containsKisFlow {
// 不包含kis.Flow类型的形参，返回错误
return nil, errors.New("function parameters must have kis.Flow param, please use FaaS type like: [type FaaS func(context.Context, Flow, ...interface{}) error]")
}
if !containsCtx {
// 不包含context.Context类型的形参，返回错误
return nil, errors.New("function parameters must have context, please use FaaS type like: [type FaaS func(context.Context, Flow, ...interface{}) error]")
}
// 返回FaaSDesc描述实例
return &FaaSDesc{
FnName: fnName,
f: f,
fName: fullName,
ArgsType: argsType,
ArgNum: len(argsType),
FuncType: funcType,
FuncValue: funcValue,
}, nil
}
这里面通过用reflect反射能力，依次从f函数中获取相关的属性值，存放在FaaSDesc中。
这里面为了确保开发者传递的FaaS原因满足如下格式：
type FaaS func(context.Context, Flow, ...interface{}) error
所以对形参context.Context和形参Flow做了严格的形参类型校验，其中的校验方法如下：
kis-flow/kis/faas.go
// isFuncType 判断传递进来的 paramType 是否是函数类型
func isFuncType(paramType reflect.Type) bool {
return paramType.Kind() == reflect.Func
}
// isFlowType 判断传递进来的 paramType 是否是 kis.Flow 类型
func isFlowType(paramType reflect.Type) bool {
var flowInterfaceType = reflect.TypeOf((*Flow)(nil)).Elem()
return paramType.Implements(flowInterfaceType)
}
// isContextType 判断传递进来的 paramType 是否是 context.Context 类型
func isContextType(paramType reflect.Type) bool {
typeName := paramType.Name()
return strings.Contains(typeName, "Context")
}
// isSliceType 判断传递进来的 paramType 是否是切片类型
func isSliceType(paramType reflect.Type) bool {
return paramType.Kind() == reflect.Slice
}
在NewFaaSDesc()用containsKisFlow和containsCtx两个bool类型的变量来判断是否包括Context和Flow类型。
下面这段代码是为了兼容传递的形参类型是结构体指针时候的兼容：
// ... ...
// 获得当前形参类型
itemType := paramType.Elem()
// 如果当前参数是一个指针类型，则获取指针指向的结构体类型
if itemType.Kind() == reflect.Ptr {
itemType = itemType.Elem() // 获取指针指向的结构体类型
}
// ... ...
比如开发者传递的FaaS函数原型如下：
func MyFaaSDemo(ctx context.Context, flow Flow, []*A) error
和:
func MyFaaSDemo(ctx context.Context, flow Flow, []A) error
11.1.3 注册FaaS函数
那么接下来，我们将kisPool模块，的注册FaaS函数的方法修改成注册一个FaaSDesc描述，修改后的注册方法如下：
kis-flow/kis/pool.go
// FaaS 注册 Function 计算业务逻辑, 通过Function Name 索引及注册
func (pool *kisPool) FaaS(fnName string, f FaaS) {
// 当注册FaaS计算逻辑回调时，创建一个FaaSDesc描述对象
faaSDesc, err := NewFaaSDesc(fnName, f)
if err != nil {
panic(err)
}
pool.fnLock.Lock() // 写锁
defer pool.fnLock.Unlock()
if _, ok := pool.fnRouter[fnName]; !ok {
// 将FaaSDesc描述对象注册到fnRouter中
pool.fnRouter[fnName] = faaSDesc
} else {
errString := fmt.Sprintf("KisPoll FaaS Repeat FuncName=%s", fnName)
panic(errString)
}
log.Logger().InfoF("Add KisPool FuncName=%s", fnName)
}
那么现在的fnRouter中保存的key依然是FunctionName，但是value则为当前FaaS函数的描述对象FaaSDesc.
11.1.4 kisPool调度FaaSDesc
最后再调度Function的时候，通过FaaSDesc取出调度函数地址和函数形参列表进行函数的调度。
修改的后的CallFunction()如下：
kis-flow/kis/pool.go
// CallFunction 调度 Function
func (pool *kisPool) CallFunction(ctx context.Context, fnName string, flow Flow) error {
if funcDesc, ok := pool.fnRouter[fnName]; ok {
// 被调度Function的形参列表
params := make([]reflect.Value, 0, funcDesc.ArgNum)
for _, argType := range funcDesc.ArgsType {
// 如果是Flow类型形参，则将 flow的值传入
if isFlowType(argType) {
params = append(params, reflect.ValueOf(flow))
continue
}
// 如果是Context类型形参，则将 ctx的值传入
if isContextType(argType) {
params = append(params, reflect.ValueOf(ctx))
continue
}
// 如果是Slice类型形参，则将 flow.Input()的值传入
if isSliceType(argType) {
params = append(params, value)
continue
}
// 传递的参数，既不是Flow类型，也不是Context类型，也不是Slice类型，则默认给到零值
params = append(params, reflect.Zero(argType))
}
// 调用当前Function 的计算逻辑
retValues := funcDesc.FuncValue.Call(params)
// 取出第一个返回值，如果是nil，则返回nil
ret := retValues[0].Interface()
if ret == nil {
return nil
}
// 如果返回值是error类型，则返回error
return retValues[0].Interface().(error)
}
log.Logger().ErrorFX(ctx, "FuncName: %s Can not find in KisPool, Not Added.\n", fnName)
return errors.New("FuncName: " + fnName + " Can not find in NsPool, Not Added.")
}
函数的整体调度逻辑大致如下：
首选通过fnName进行从fnRouter路由到对应的FaaSDesc。遍历FaaSDesc的形参列表：
将Context和Flow对象依次取出来，将额外传递的自定义切片形参取出来，如果传递的参数，既不是Flow类型，也不是Context类型，也不是Slice类型，则默认给到零值，如下：
params = append(params, reflect.Zero(argType))
最后执行函数的调度:
retValues := funcDesc.FuncValue.Call(params)
得到第一个返回值error的数值，为nil则返回nil，否则返回error类型。
这样我们的FaaS自描述的调度模式就建立成功了，那么有了这套功能KisFlow可以做什么事情呢，下一节我们可以再调度FaaSDesc的时候将传递的自定义形参的数据类型进行序列化，得到开发者期待的数据类型。
11.2 FaaS形参的自定义数据类型序列化
11.2.1 Serialize序列化接口
首先，我们定义一个数据序列化接口，在kis-flow/kis/下创建serialize.go 文件，如下：
kis-flow/kis/serialize.go
// Serialize 数据序列化接口
type Serialize interface {
// UnMarshal 用于将 KisRowArr 反序列化为指定类型的值。
UnMarshal(common.KisRowArr, reflect.Type) (reflect.Value, error)
// Marshal 用于将指定类型的值序列化为 KisRowArr。
Marshal(interface{}) (common.KisRowArr, error)
}
其中KisRowArr是我们KisFlow中传递每个Function的数据切片，之前我们定义在了kis-flow/common/data_type.go中:
package common
// KisRow 一行数据
type KisRow interface{}
// KisRowArr 一次业务的批量数据
type KisRowArr []KisRow
/*
KisDataMap 当前Flow承载的全部数据
key : 数据所在的Function ID
value: 对应的KisRow
*/
type KisDataMap map[string]KisRowArr
Serialize提供了两个接口：
- UnMarshal：用于将 KisRowArr 反序列化为指定类型的值。
- Marshal：用于将指定类型的值序列化为 KisRowArr。
KisFlow会提供一个默认的Serialize给每个FaaS函数，开发者也可以自定义自己的Serialize来对FaaS传递的形参进行自定义的数据序列化动作。
11.2.2 KisFlow默认的Serialize序列化
KisFlow提供一个默认的Serialize序列化实例，主要以Json格式为主，在kis-flow/下创建serialize/文件夹，在kis-flow/serialize/下创建serialize_default.go文件，实现的序列化和反序列化代码如下：
kis-flow/serialize/serialize_default.go
package serialize
import (
"encoding/json"
"fmt"
"kis-flow/common"
"reflect"
)
type DefaultSerialize struct{}
// UnMarshal 用于将 KisRowArr 反序列化为指定类型的值。
func (f *DefaultSerialize) UnMarshal(arr common.KisRowArr, r reflect.Type) (reflect.Value, error) {
// 确保传入的类型是一个切片
if r.Kind() != reflect.Slice {
return reflect.Value{}, fmt.Errorf("r must be a slice")
}
slice := reflect.MakeSlice(r, 0, len(arr))
// 遍历每个元素并尝试反序列化
for _, row := range arr {
var elem reflect.Value
var err error
// 尝试断言为结构体或指针
elem, err = unMarshalStruct(row, r.Elem())
if err == nil {
slice = reflect.Append(slice, elem)
continue
}
// 尝试直接反序列化字符串
elem, err = unMarshalJsonString(row, r.Elem())
if err == nil {
slice = reflect.Append(slice, elem)
continue
}
// 尝试先序列化为 JSON 再反序列化
elem, err = unMarshalJsonStruct(row, r.Elem())
if err == nil {
slice = reflect.Append(slice, elem)
} else {
return reflect.Value{}, fmt.Errorf("failed to decode row: %v", err)
}
}
return slice, nil
}
// Marshal 用于将指定类型的值序列化为 KisRowArr(json 序列化)。
func (f *DefaultSerialize) Marshal(i interface{}) (common.KisRowArr, error) {
var arr common.KisRowArr
switch reflect.TypeOf(i).Kind() {
case reflect.Slice, reflect.Array:
slice := reflect.ValueOf(i)
for i := 0; i < slice.Len(); i++ {
// 序列化每个元素为 JSON 字符串，并将其添加到切片中。
jsonBytes, err := json.Marshal(slice.Index(i).Interface())
if err != nil {
return nil, fmt.Errorf("failed to marshal element to JSON: %v ", err)
}
arr = append(arr, string(jsonBytes))
}
default:
// 如果不是切片或数组类型，则直接序列化整个结构体为 JSON 字符串。
jsonBytes, err := json.Marshal(i)
if err != nil {
return nil, fmt.Errorf("failed to marshal element to JSON: %v ", err)
}
arr = append(arr, string(jsonBytes))
}
return arr, nil
}
其中一些函数定义如下：
kis-flow/serialize/serialize_default.go
// 尝试断言为结构体或指针
func unMarshalStruct(row common.KisRow, elemType reflect.Type) (reflect.Value, error) {
// 检查 row 是否为结构体或结构体指针类型
rowType := reflect.TypeOf(row)
if rowType == nil {
return reflect.Value{}, fmt.Errorf("row is nil pointer")
}
if rowType.Kind() != reflect.Struct && rowType.Kind() != reflect.Ptr {
return reflect.Value{}, fmt.Errorf("row must be a struct or struct pointer type")
}
// 如果 row 是指针类型，则获取它指向的类型
if rowType.Kind() == reflect.Ptr {
// 空指针
if reflect.ValueOf(row).IsNil() {
return reflect.Value{}, fmt.Errorf("row is nil pointer")
}
// 解引用
row = reflect.ValueOf(row).Elem().Interface()
// 拿到解引用后的类型
rowType = reflect.TypeOf(row)
}
// 检查是否可以将 row 断言为 elemType(目标类型)
if !rowType.AssignableTo(elemType) {
return reflect.Value{}, fmt.Errorf("row type cannot be asserted to elemType")
}
// 将 row 转换为 reflect.Value 并返回
return reflect.ValueOf(row), nil
}
// 尝试直接反序列化字符串(将Json字符串 反序列化为 结构体)
func unMarshalJsonString(row common.KisRow, elemType reflect.Type) (reflect.Value, error) {
// 判断源数据是否可以断言成string
str, ok := row.(string)
if !ok {
return reflect.Value{}, fmt.Errorf("not a string")
}
// 创建一个新的结构体实例，用于存储反序列化后的值
elem := reflect.New(elemType).Elem()
// 尝试将json字符串反序列化为结构体。
if err := json.Unmarshal([]byte(str), elem.Addr().Interface()); err != nil {
return reflect.Value{}, fmt.Errorf("failed to unmarshal string to struct: %v", err)
}
return elem, nil
}
// 尝试先序列化为 JSON 再反序列化(将结构体转换成Json字符串，再将Json字符串 反序列化为 结构体)
func unMarshalJsonStruct(row common.KisRow, elemType reflect.Type) (reflect.Value, error) {
// 将 row 序列化为 JSON 字符串
jsonBytes, err := json.Marshal(row)
if err != nil {
return reflect.Value{}, fmt.Errorf("failed to marshal row to JSON: %v ", err)
}
// 创建一个新的结构体实例，用于存储反序列化后的值
elem := reflect.New(elemType).Interface()
// 将 JSON 字符串反序列化为结构体
if err := json.Unmarshal(jsonBytes, elem); err != nil {
return reflect.Value{}, fmt.Errorf("failed to unmarshal JSON to element: %v ", err)
}
return reflect.ValueOf(elem).Elem(), nil
}
- UnMarshal()： 的实现 首先判断形参是否是一个Slice，如果是的话，那么切片中的每个元素的数据进行序列化，优先尝试
unMarshalStruct()结构体反序列化，其次尝试json字符串的反序列化unMarshalJsonString()，最后再尝试具备相同属性的结构体但是名称不同的反序列化unMarshalJsonStruct()。 - Marshal(): 则是将任意类型序列化为json二进制字符串存储在KisRowArr中。
注意：KisFlow目前的默认序列化只实现了json格式的序列化，开发者可以参考DefaultSerialize{} 来实现自己其他格式的数据序列化和反序列化动作。
11.2.3 默认的默认的Serialize实例
在serialize的接口定义中，定义一个全局默认的序列化实例，defaultSerialize。
kis-flow/kis/serialize.go
// defaultSerialize KisFlow提供的默认序列化实现(开发者可以自定义)
var defaultSerialize = &serialize.DefaultSerialize{}
同时提供一个判断一个数据类型是否实现了抽象接口Serialize的校验方法，如下：
kis-flow/kis/serialize.go
// isSerialize 判断传递进来的 paramType 是否实现了 Serialize 接口
func isSerialize(paramType reflect.Type) bool {
return paramType.Implements(reflect.TypeOf((*Serialize)(nil)).Elem())
}
11.2.4 FaaSDesc实现Serialize序列化接口
现在将FaaSDesc去继承且实现Serialize接口，在调度FaaSDesc的时候将传递的输入参数进行序列化得到相对应的具体类型形参，定义如下：
kis-flow/kis/faas.go
// FaaSDesc FaaS 回调计算业务函数 描述
type FaaSDesc struct {
// +++++++
Serialize // 当前Function的数据输入输出序列化实现
// +++++++
FnName string // Function名称
f interface{} // FaaS 函数
fName string // 函数名称
ArgsType []reflect.Type // 函数参数类型（集合）
ArgNum int // 函数参数个数
FuncType reflect.Type // 函数类型
FuncValue reflect.Value // 函数值(函数地址)
}
然后，在构造方法NewFaaSDesc()加上对自定义形参的判断，判断传递的自定义形参是否实现了Serialize的两个序列化接口，如果实现了，则使用自定义的序列化接口，如果没有实现，则使用默认的DefaultSerialize{}实例。
kis-flow/kis/faas.go
// NewFaaSDesc 根据用户注册的FnName 和FaaS 回调函数，创建 FaaSDesc 描述实例
func NewFaaSDesc(fnName string, f FaaS) (*FaaSDesc, error) {
// ++++++++++
// 输入输出序列化实例
var serializeImpl Serialize
// ++++++++++
// ... ...
// ... ...
// 遍历FaaS的形参类型
for i := 0; i < funcType.NumIn(); i++ {
// 取出第i个形式参数类型
paramType := funcType.In(i)
if isFlowType(paramType) {
// 判断是否包含kis.Flow类型的形参
containsKisFlow = true
} else if isContextType(paramType) {
// 判断是否包含context.Context类型的形参
containsCtx = true
} else if isSliceType(paramType) {
// 获取当前参数Slice的元素类型
itemType := paramType.Elem()
// 如果当前参数是一个指针类型，则获取指针指向的结构体类型
if itemType.Kind() == reflect.Ptr {
itemType = itemType.Elem() // 获取指针指向的结构体类型
}
// +++++++++++++++++++++++++++++
// Check if f implements Serialize interface
// (检测传递的FaaS函数是否实现了Serialize接口)
if isSerialize(itemType) {
// 如果当前形参实现了Serialize接口，则使用当前形参的序列化实现
serializeImpl = reflect.New(itemType).Interface().(Serialize)
} else {
// 如果当前形参没有实现Serialize接口，则使用默认的序列化实现
serializeImpl = defaultSerialize // Use global default implementation
}
// +++++++++++++++++++++++++++++++
} else {
// Other types are not supported
}
// 将当前形参类型追加到argsType集合中
argsType[i] = paramType
}
// ... ...
// ... ...
// 返回FaaSDesc描述实例
return &FaaSDesc{
Serialize: serializeImpl,
FnName: fnName,
f: f,
fName: fullName,
ArgsType: argsType,
ArgNum: len(argsType),
FuncType: funcType,
FuncValue: funcValue,
}, nil
}
11.2.5 完成调度FaaS数据序列化
最后在调度FaaSDesc的时候，解析形参的时候，如果是自定义的Slice参数，则对齐进行反序列化操作，将flow.Input()的原数据反序列化成为开发者需要的结构体数据，进行调度FaaS，实现如下：
kis-flow/kis/pool.go
// CallFunction 调度 Function
func (pool *kisPool) CallFunction(ctx context.Context, fnName string, flow Flow) error {
if funcDesc, ok := pool.fnRouter[fnName]; ok {
// 被调度Function的形参列表
params := make([]reflect.Value, 0, funcDesc.ArgNum)
for _, argType := range funcDesc.ArgsType {
// 如果是Flow类型形参，则将 flow的值传入
if isFlowType(argType) {
params = append(params, reflect.ValueOf(flow))
continue
}
// 如果是Context类型形参，则将 ctx的值传入
if isContextType(argType) {
params = append(params, reflect.ValueOf(ctx))
continue
}
// 如果是Slice类型形参，则将 flow.Input()的值传入
if isSliceType(argType) {
// +++++++++++++++++++
// 将flow.Input()中的原始数据，反序列化为argType类型的数据
value, err := funcDesc.Serialize.UnMarshal(flow.Input(), argType)
if err != nil {
log.Logger().ErrorFX(ctx, "funcDesc.Serialize.DecodeParam err=%v", err)
} else {
params = append(params, value)
continue
}
// +++++++++++++++++++
}
// 传递的参数，既不是Flow类型，也不是Context类型，也不是Slice类型，则默认给到零值
params = append(params, reflect.Zero(argType))
}
// 调用当前Function 的计算逻辑
retValues := funcDesc.FuncValue.Call(params)
// 取出第一个返回值，如果是nil，则返回nil
ret := retValues[0].Interface()
if ret == nil {
return nil
}
// 如果返回值是error类型，则返回error
return retValues[0].Interface().(error)
}
log.Logger().ErrorFX(ctx, "FuncName: %s Can not find in KisPool, Not Added.\n", fnName)
return errors.New("FuncName: " + fnName + " Can not find in NsPool, Not Added.")
}
这样我们就将数据序列化的动作和FaaSDesc模块结合起来了，接下来，我们写一个单元测试来测试这部分的能力。
11.3 自定义形参序列化单元测试
11.3.1 Flow与Function的配置文件定义
单元测试，我们新建两个Function配置如下：
kis-flow/test/load_conf/func/func-avgStuScore.yml
kistype: func
fname: AvgStuScore
fmode: Calculate
source:
name: 学生平均分
must:
- stu_id
kis-flow/test/load_conf/func/func-PrintStuAvgScore.yml
kistype: func
fname: PrintStuAvgScore
fmode: Expand
source:
name: 学生平均分
must:
- stu_id
然后我们来定义一个Flow将上述的两个Function链接起来
kis-flow/test/load_conf/flow/flow-StuAvg.yml
kistype: flow
status: 1
flow_name: StuAvg
flows:
- fname: AvgStuScore
- fname: PrintStuAvgScore
11.3.2 自定义基础数据proto定义
在kis-flow/test/下创建proto/文件夹，创建一个自定义的基础数据proto，为了今后数据协议的复用，如下：
kis-flow/test/proto/stu_score.go
package proto
// 学生学习分数
type StuScores struct {
StuId int `json:"stu_id"`
Score1 int `json:"score_1"`
Score2 int `json:"score_2"`
Score3 int `json:"score_3"`
}
// 学生的平均分
type StuAvgScore struct {
StuId int `json:"stu_id"`
AvgScore float64 `json:"avg_score"`
}
11.3.3 定义两个FaaS计算回调函数
定义两个FaaS计算函数，一个为计算一个Student的平均分，一个打印Student的平均分，如下：
kis-flow/test/faas/faas_stu_score_avg.go
package faas
import (
"context"
"kis-flow/kis"
"kis-flow/serialize"
"kis-flow/test/proto"
)
type AvgStuScoreIn struct {
serialize.DefaultSerialize
proto.StuScores
}
type AvgStuScoreOut struct {
serialize.DefaultSerialize
proto.StuAvgScore
}
// AvgStuScore(FaaS) 计算学生平均分
func AvgStuScore(ctx context.Context, flow kis.Flow, rows []*AvgStuScoreIn) error {
for _, row := range rows {
avgScore := proto.StuAvgScore{
StuId: row.StuId,
AvgScore: float64(row.Score1+row.Score2+row.Score3) / 3,
}
// 提交结果数据
_ = flow.CommitRow(AvgStuScoreOut{StuAvgScore: avgScore})
}
return nil
}
AvgStuScore()方法为我们改进之后的FaaS函数，其中第三个形参rows []*AvgStuScoreIn为我们自定义序列化的形参，之前我们通过flow.Input()来拿到原始的数据，然后进行遍历，其实现在依然可以这么处理，但是每次可能需要开发者在FaaS中自行断言判断，对开发的效率有些成本，那么现在开发者完全可以通过AvgStuScoreIn来描述一个形参的数据，然后在AvgStuScore的业务中，通过遍历rows得到已经序列化好的结构体，增加的代码的可读性也降低的写业务的开发成本，提高了效率。
打印平均分的FaaS实现如下：
kis-flow/test/faas/faas_stu_score_avg_print.go
package faas
import (
"context"
"fmt"
"kis-flow/kis"
"kis-flow/serialize"
"kis-flow/test/proto"
)
type PrintStuAvgScoreIn struct {
serialize.DefaultSerialize
proto.StuAvgScore
}
type PrintStuAvgScoreOut struct {
serialize.DefaultSerialize
}
func PrintStuAvgScore(ctx context.Context, flow kis.Flow, rows []*PrintStuAvgScoreIn) error {
for _, row := range rows {
fmt.Printf("stuid: [%+v], avg score: [%+v]\n", row.StuId, row.AvgScore)
}
return nil
}
与上述函数一样，我们依然采用自定义的输入形参来进行逻辑开发。
11.3.4 单元测试用例
接下来我们来编写上面Flow的测试用例单元测试，代码如下：
kis-flow/test/kis_auto_inject_param_test.go
package test
import (
"context"
"kis-flow/common"
"kis-flow/config"
"kis-flow/file"
"kis-flow/flow"
"kis-flow/kis"
"kis-flow/test/faas"
"kis-flow/test/proto"
"testing"
)
func TestAutoInjectParamWithConfig(t *testing.T) {
ctx := context.Background()
kis.Pool().FaaS("AvgStuScore", faas.AvgStuScore)
kis.Pool().FaaS("PrintStuAvgScore", faas.PrintStuAvgScore)
// 1. 加载配置文件并构建Flow
if err := file.ConfigImportYaml("load_conf/"); err != nil {
panic(err)
}
// 2. 获取Flow
flow1 := kis.Pool().GetFlow("StuAvg")
if flow1 == nil {
panic("flow1 is nil")
}
// 3. 提交原始数据
_ = flow1.CommitRow(&faas.AvgStuScoreIn{
StuScores: proto.StuScores{
StuId: 100,
Score1: 1,
Score2: 2,
Score3: 3,
},
})
_ = flow1.CommitRow(faas.AvgStuScoreIn{
StuScores: proto.StuScores{
StuId: 100,
Score1: 1,
Score2: 2,
Score3: 3,
},
})
// 提交原始数据（json字符串）
_ = flow1.CommitRow(`{"stu_id":101}`)
// 4. 执行flow1
if err := flow1.Run(ctx); err != nil {
panic(err)
}
}
在提交原始数据的时候，我们这里面采用的是使用默认的序列化方式，支持json的反序列化支持，在CommitRow()的时候，一共提交的3条数据，前两条是提交的结构体数据，最后一次是提交的json字符串，目前都可以支持。
cd 到kis-flow/test/下，执行：
$ go test -test.v -test.paniconexit0 -test.run TestAutoInjectParamWithConfig
得到结果如下：
$ go test -test.v -test.paniconexit0 -test.run TestAutoInjectParamWithConfig
...
...
Add KisPool FuncName=AvgStuScore
Add KisPool FuncName=PrintStuAvgScore
...
...
Add FlowRouter FlowName=StuAvg
context.Background
====> After CommitSrcData, flow_name = StuAvg, flow_id = flow-1265702bc905400da1788c0354080ded
All Level Data =
map[FunctionIdFirstVirtual:[0xc0002bab40 {DefaultSerialize:{} StuScores:{StuId:100 Score1:1 Score2:2 Score3:3}} {"stu_id":101}]]
KisFunctionC, flow = &{Id:flow-1265702bc905400da1788c0354080ded Name:StuAvg Conf:0xc000286100 Funcs:map[AvgStuScore:0xc00023af80 PrintStuAvgScore:0xc00023b000] FlowHead:0xc00023af80 FlowTail:0xc00023b000 flock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0} ThisFunction:0xc00023af80 ThisFunctionId:func-12a05e62a12a45fdade8477a3bddd2fd PrevFunctionId:FunctionIdFirstVirtual funcParams:map[func-12a05e62a12a45fdade8477a3bddd2fd:map[] func-7f308d00f4fa49488760ff1dfb85dc46:map[]] fplock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0} buffer:[] data:map[FunctionIdFirstVirtual:[0xc0002bab40 {DefaultSerialize:{} StuScores:{StuId:100 Score1:1 Score2:2 Score3:3}} {"stu_id":101}]] inPut:[0xc0002bab40 {DefaultSerialize:{} StuScores:{StuId:100 Score1:1 Score2:2 Score3:3}} {"stu_id":101}] abort:false action:{DataReuse:false ForceEntryNext:false JumpFunc: Abort:false} cache:0xc000210b88 metaData:map[] mLock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0}}
context.Background
====> After commitCurData, flow_name = StuAvg, flow_id = flow-1265702bc905400da1788c0354080ded
All Level Data =
map[FunctionIdFirstVirtual:[0xc0002bab40 {DefaultSerialize:{} StuScores:{StuId:100 Score1:1 Score2:2 Score3:3}} {"stu_id":101}] func-12a05e62a12a45fdade8477a3bddd2fd:[{DefaultSerialize:{} StuAvgScore:{StuId:100 AvgScore:2}} {DefaultSerialize:{} StuAvgScore:{StuId:100 AvgScore:2}} {DefaultSerialize:{} StuAvgScore:{StuId:101 AvgScore:0}}]]
KisFunctionE, flow = &{Id:flow-1265702bc905400da1788c0354080ded Name:StuAvg Conf:0xc000286100 Funcs:map[AvgStuScore:0xc00023af80 PrintStuAvgScore:0xc00023b000] FlowHead:0xc00023af80 FlowTail:0xc00023b000 flock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0} ThisFunction:0xc00023b000 ThisFunctionId:func-7f308d00f4fa49488760ff1dfb85dc46 PrevFunctionId:func-12a05e62a12a45fdade8477a3bddd2fd funcParams:map[func-12a05e62a12a45fdade8477a3bddd2fd:map[] func-7f308d00f4fa49488760ff1dfb85dc46:map[]] fplock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0} buffer:[] data:map[FunctionIdFirstVirtual:[0xc0002bab40 {DefaultSerialize:{} StuScores:{StuId:100 Score1:1 Score2:2 Score3:3}} {"stu_id":101}] func-12a05e62a12a45fdade8477a3bddd2fd:[{DefaultSerialize:{} StuAvgScore:{StuId:100 AvgScore:2}} {DefaultSerialize:{} StuAvgScore:{StuId:100 AvgScore:2}} {DefaultSerialize:{} StuAvgScore:{StuId:101 AvgScore:0}}]] inPut:[{DefaultSerialize:{} StuAvgScore:{StuId:100 AvgScore:2}} {DefaultSerialize:{} StuAvgScore:{StuId:100 AvgScore:2}} {DefaultSerialize:{} StuAvgScore:{StuId:101 AvgScore:0}}] abort:false action:{DataReuse:false ForceEntryNext:false JumpFunc: Abort:false} cache:0xc000210b88 metaData:map[] mLock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0}}
stuid: [100], avg score: [2]
stuid: [100], avg score: [2]
stuid: [101], avg score: [0]
--- PASS: TestAutoInjectParamWithConfig (0.01s)
PASS
ok kis-flow/test 0.030s
11.4 【V1.0】 源代码
https://github.com/aceld/kis-flow/releases/tag/v1.0
作者:刘丹冰Aceld github: https://github.com/aceld
KisFlow开源项目地址：https://github.com/aceld/kis-flow
Golang框架实战-KisFlow流式计算框架专栏
Golang框架实战-KisFlow流式计算框架(1)-概述
Golang框架实战-KisFlow流式计算框架(2)-项目构建/基础模块-(上)
Golang框架实战-KisFlow流式计算框架(3)-项目构建/基础模块-(下)
Golang框架实战-KisFlow流式计算框架(4)-数据流
Golang框架实战-KisFlow流式计算框架(5)-Function调度
Golang框架实战-KisFlow流式计算框架(6)-Connector
Golang框架实战-KisFlow流式计算框架(7)-配置导入与导出
Golang框架实战-KisFlow流式计算框架(8)-KisFlow Action
Golang框架实战-KisFlow流式计算框架(10)-Flow多副本
