439 lines
11 KiB
Go
439 lines
11 KiB
Go
// Package event ...
|
||
//
|
||
// Description : event ...
|
||
//
|
||
// Author : go_developer@163.com<白茶清欢>
|
||
//
|
||
// Date : 2023-02-01 14:30
|
||
package event
|
||
|
||
import (
|
||
"encoding/json"
|
||
"git.zhangdeman.cn/zhangdeman/event/abstract"
|
||
"git.zhangdeman.cn/zhangdeman/util"
|
||
"github.com/tidwall/gjson"
|
||
"net/http"
|
||
"reflect"
|
||
"strings"
|
||
"sync"
|
||
)
|
||
|
||
var (
|
||
// ReflectTypeInstance 反射实例
|
||
ReflectTypeInstance *ReflectType
|
||
)
|
||
|
||
func init() {
|
||
ReflectTypeInstance = &ReflectType{
|
||
lock: &sync.RWMutex{},
|
||
cacheTable: make(map[string]*StructInfo),
|
||
}
|
||
}
|
||
|
||
// ReflectType 反射数据类型
|
||
//
|
||
// Author : go_developer@163.com<白茶清欢>
|
||
//
|
||
// Date : 14:31 2023/2/1
|
||
type ReflectType struct {
|
||
// 数据锁
|
||
lock *sync.RWMutex
|
||
// 反射结果缓存
|
||
cacheTable map[string]*StructInfo
|
||
}
|
||
|
||
// Do 反射获取数据类型
|
||
//
|
||
// Author : go_developer@163.com<白茶清欢>
|
||
//
|
||
// Date : 14:34 2023/2/1
|
||
//
|
||
// 为特定结构体生成全局唯一的标识, 并进行缓存, 加速反射结果获取
|
||
func (rt *ReflectType) Do(dataFlag string, data interface{}) *StructInfo {
|
||
rt.lock.Lock()
|
||
defer rt.lock.Unlock()
|
||
if cacheResult, exist := rt.cacheTable[dataFlag]; exist {
|
||
// 缓存存在, 直接是有缓存结果
|
||
return cacheResult
|
||
}
|
||
// 缓存不存在, 解析
|
||
res := &StructInfo{
|
||
Flag: dataFlag,
|
||
IsStruct: false,
|
||
IsStructPtr: false,
|
||
StructFieldList: make([]*StructField, 0),
|
||
}
|
||
isPtr := false
|
||
reflectType := reflect.TypeOf(data)
|
||
if reflectType.Kind() == reflect.Ptr {
|
||
isPtr = true
|
||
reflectType = reflectType.Elem()
|
||
}
|
||
if reflectType.Kind() != reflect.Struct {
|
||
// 非结构体，无需反射
|
||
rt.cacheTable[dataFlag] = res
|
||
return res
|
||
}
|
||
res.IsStruct = true
|
||
res.IsStructPtr = isPtr
|
||
for idx := 0; idx < reflectType.NumField(); idx++ {
|
||
field := &StructField{
|
||
Idx: idx,
|
||
Name: reflectType.Field(idx).Name,
|
||
JsonTag: reflectType.Field(idx).Tag.Get(JsonTag),
|
||
EventTag: reflectType.Field(idx).Tag.Get(OutEventTag),
|
||
MappingRuleList: make([]MappingRuleItem, 0),
|
||
}
|
||
rt.fillFieldType(field, reflectType.Field(idx).Type)
|
||
rt.fillMappingRule(field, reflectType.Field(idx).Tag.Get(MappingTag))
|
||
res.StructFieldList = append(res.StructFieldList, field)
|
||
}
|
||
rt.cacheTable[dataFlag] = res
|
||
return res
|
||
}
|
||
|
||
// fillFieldType 填充字段类型
|
||
//
|
||
// Author : go_developer@163.com<白茶清欢>
|
||
//
|
||
// Date : 20:46 2023/2/1
|
||
func (rt *ReflectType) fillFieldType(field *StructField, dataType reflect.Type) {
|
||
switch dataType.Kind() {
|
||
case reflect.Float32:
|
||
fallthrough
|
||
case reflect.Float64:
|
||
field.Type = reflect.Float64
|
||
case reflect.String:
|
||
field.Type = reflect.String
|
||
case reflect.Struct:
|
||
field.Type = reflect.Struct
|
||
case reflect.Slice:
|
||
field.Type = reflect.Slice
|
||
case reflect.Map:
|
||
field.Type = reflect.Map
|
||
case reflect.Ptr:
|
||
field.IsPtr = true
|
||
// 指针再次判断基础类型
|
||
field.Type = dataType.Elem().Kind()
|
||
default:
|
||
if strings.Contains(dataType.String(), "int") {
|
||
field.Type = reflect.Int64
|
||
} else {
|
||
field.Type = reflect.Interface
|
||
}
|
||
}
|
||
}
|
||
|
||
// fillTagInfo 填充标签信息
|
||
//
|
||
// Author : go_developer@163.com<白茶清欢>
|
||
//
|
||
// Date : 17:11 2023/2/1
|
||
func (rt *ReflectType) fillTagInfo(field *StructField) {
|
||
if len(field.JsonTag) == 0 {
|
||
field.JsonTag = field.Name
|
||
}
|
||
|
||
// jsonTag 去掉 omitempty
|
||
jsonTagValArr := strings.Split(field.JsonTag, ",")
|
||
for _, item := range jsonTagValArr {
|
||
if len(item) > 0 && item != OmitemptyTag {
|
||
field.JsonTag = item
|
||
break
|
||
}
|
||
}
|
||
|
||
// 没有设置event tag,则和 json tag保持一致
|
||
if len(field.EventTag) == 0 {
|
||
field.EventTag = field.JsonTag
|
||
}
|
||
}
|
||
|
||
// fillMappingRule 解析参数映射规则
|
||
//
|
||
// Author : go_developer@163.com<白茶清欢>
|
||
//
|
||
// Date : 17:14 2023/2/1
|
||
//
|
||
// mapping:"user_id:param#user_id|header#id"
|
||
func (rt *ReflectType) fillMappingRule(field *StructField, inputMappingVal string) {
|
||
|
||
if len(inputMappingVal) == 0 {
|
||
// 没有指定规则, 有默认规则
|
||
for _, location := range mappingLocationList {
|
||
field.MappingRuleList = append(field.MappingRuleList, MappingRuleItem{
|
||
Location: location,
|
||
Field: field.JsonTag,
|
||
})
|
||
}
|
||
return
|
||
}
|
||
mappingArr := strings.Split(inputMappingVal, ",")
|
||
for _, item := range mappingArr {
|
||
item = strings.TrimSpace(item)
|
||
// 要赋值的字段名
|
||
itemArr := strings.Split(item, ":")
|
||
if len(itemArr) != 2 {
|
||
// 配置格式错误, 跳过
|
||
continue
|
||
}
|
||
mapRuleArr := strings.Split(strings.TrimSpace(itemArr[1]), "|")
|
||
for _, itemMapRule := range mapRuleArr {
|
||
itemMapRule = strings.TrimLeft(itemMapRule, "#")
|
||
itemMapRuleArr := strings.Split(itemMapRule, "#")
|
||
// 注意 : # 为特殊分隔符, 如配置成 mapping:"project_id:#source_project_id#xxx_project_id" 实际等价于 mapping:"project_id:#source_project_id" 多余配置自动跳过
|
||
if len(itemMapRuleArr[0]) < 2 {
|
||
// 没有指定位置，默认all, 即配置格式: mapping:"project_id:#source_project_id"
|
||
itemMapRuleArr[0] = MappingLocationAll
|
||
itemMapRuleArr = []string{MappingLocationAll, itemMapRuleArr[0]}
|
||
}
|
||
|
||
switch itemMapRuleArr[0] {
|
||
// 从header读取
|
||
case MappingLocationHeader:
|
||
field.MappingRuleList = append(field.MappingRuleList, MappingRuleItem{
|
||
Location: MappingLocationHeader,
|
||
Field: itemMapRuleArr[1],
|
||
})
|
||
// 从请求参数读取
|
||
case MappingLocationParam:
|
||
field.MappingRuleList = append(field.MappingRuleList, MappingRuleItem{
|
||
Location: MappingLocationParam,
|
||
Field: itemMapRuleArr[1],
|
||
})
|
||
// 从响应数据读取
|
||
case MappingLocationResponse:
|
||
field.MappingRuleList = append(field.MappingRuleList, MappingRuleItem{
|
||
Location: MappingLocationResponse,
|
||
Field: itemMapRuleArr[1],
|
||
})
|
||
// 从扩展数据读取
|
||
case MappingLocationExtension:
|
||
field.MappingRuleList = append(field.MappingRuleList, MappingRuleItem{
|
||
Location: MappingLocationExtension,
|
||
Field: itemMapRuleArr[1],
|
||
})
|
||
// 全部读取一遍
|
||
case MappingLocationAll:
|
||
fallthrough
|
||
default:
|
||
for _, itemLocation := range mappingLocationList {
|
||
field.MappingRuleList = append(field.MappingRuleList, MappingRuleItem{
|
||
Location: itemLocation,
|
||
Field: itemMapRuleArr[1],
|
||
})
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// ReflectValue 反射值的实例
|
||
//
|
||
// Author : go_developer@163.com<白茶清欢>
|
||
//
|
||
// Date : 10:53 2023/2/2
|
||
type ReflectValue struct {
|
||
}
|
||
|
||
// Do 通过反射机制，对data进行数据填充，此逻辑要求 data 必须是结构体或者结构体指针
|
||
//
|
||
// Author : go_developer@163.com<白茶清欢>
|
||
//
|
||
// Date : 11:52 2023/2/2
|
||
func (rv *ReflectValue) Do(dataFlag string, data interface{}, preSendHandler abstract.IPreSendHandler) {
|
||
structInfo := ReflectTypeInstance.Do(dataFlag, data)
|
||
if !structInfo.IsStruct {
|
||
return
|
||
}
|
||
reflectValue := reflect.ValueOf(data)
|
||
if structInfo.IsStructPtr {
|
||
reflectValue = reflectValue.Elem()
|
||
}
|
||
|
||
for _, fieldInfo := range structInfo.StructFieldList {
|
||
if !rv.isZeroInputFieldValue(reflectValue, fieldInfo) {
|
||
// 不是零值, 无需处理
|
||
continue
|
||
}
|
||
// 是零值, 填充默认值
|
||
}
|
||
}
|
||
|
||
// isZeroInputFieldValue 判断对应的字段是否为对应类型默认的零值
|
||
//
|
||
// Author : go_developer@163.com<白茶清欢>
|
||
//
|
||
// Date : 12:04 2023/2/2
|
||
func (rv *ReflectValue) isZeroInputFieldValue(reflectValue reflect.Value, fieldInfo *StructField) bool {
|
||
inputVal := reflectValue.Field(fieldInfo.Idx).Interface()
|
||
switch fieldInfo.Type {
|
||
case reflect.Float64:
|
||
var f float64
|
||
if err := util.ConvertAssign(&f, inputVal); nil == err {
|
||
if f != 0 {
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
case reflect.String:
|
||
var s string
|
||
if err := util.ConvertAssign(&s, inputVal); nil == err {
|
||
if len(s) > 0 {
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
case reflect.Int64:
|
||
var i int64
|
||
if err := util.ConvertAssign(&i, inputVal); nil == err {
|
||
if i != 0 {
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
case reflect.Map:
|
||
if nil == inputVal {
|
||
return true
|
||
}
|
||
var m map[interface{}]interface{}
|
||
if err := util.ConvertAssign(&m, inputVal); nil == err {
|
||
if len(m) != 0 {
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
case reflect.Slice:
|
||
if nil == inputVal {
|
||
return true
|
||
}
|
||
var sl []interface{}
|
||
if err := util.ConvertAssign(&sl, inputVal); nil == err {
|
||
if len(sl) != 0 {
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
case reflect.Interface:
|
||
if inputVal == nil {
|
||
return true
|
||
}
|
||
return false
|
||
default:
|
||
// 默认不处理
|
||
return false
|
||
}
|
||
return false
|
||
}
|
||
|
||
// fillFieldValue 填充字段值
|
||
//
|
||
// Author : go_developer@163.com<白茶清欢>
|
||
//
|
||
// Date : 14:00 2023/2/2
|
||
func (rv *ReflectValue) fillFieldValue(reflectValue reflect.Value, fieldInfo *StructField, preSendHandler abstract.IPreSendHandler) {
|
||
paramByte, _ := json.Marshal(preSendHandler.GetRequestParam())
|
||
header := preSendHandler.GetRequestHeader()
|
||
responseByte, _ := json.Marshal(preSendHandler.GetResponseData())
|
||
extensionByte, _ := json.Marshal(preSendHandler.GetExtensionData())
|
||
for _, item := range fieldInfo.MappingRuleList {
|
||
if rv.setDataValue(reflectValue, fieldInfo, item, header, paramByte, responseByte, extensionByte) {
|
||
// 找到数据，并且赋值成功，结束继续查找
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
// getInputValue 获取输入的值
|
||
//
|
||
// Author : go_developer@163.com<白茶清欢>
|
||
//
|
||
// Date : 14:24 2023/2/2
|
||
func (rv *ReflectValue) setDataValue(reflectVal reflect.Value, fieldInfo *StructField, rule MappingRuleItem, header http.Header, paramByte, responseByte, extensionByte []byte) bool {
|
||
inputVal := rv.getInputValue(rule, header, paramByte, responseByte, extensionByte)
|
||
if len(inputVal) == 0 {
|
||
return false
|
||
}
|
||
switch fieldInfo.Type {
|
||
case reflect.String:
|
||
reflectVal.Field(fieldInfo.Idx).SetString(inputVal)
|
||
return true
|
||
case reflect.Int64:
|
||
var i int64
|
||
if err := util.ConvertAssign(&i, inputVal); nil != err {
|
||
return false
|
||
}
|
||
if i == 0 {
|
||
return false
|
||
}
|
||
if fieldInfo.IsPtr {
|
||
reflectVal.Field(fieldInfo.Idx).Set(reflect.ValueOf(&i))
|
||
} else {
|
||
reflectVal.Field(fieldInfo.Idx).SetInt(i)
|
||
}
|
||
return true
|
||
case reflect.Float64:
|
||
var f float64
|
||
if err := util.ConvertAssign(&f, inputVal); nil != err {
|
||
return false
|
||
}
|
||
if f == 0 {
|
||
return false
|
||
}
|
||
if fieldInfo.IsPtr {
|
||
reflectVal.Field(fieldInfo.Idx).Set(reflect.ValueOf(&f))
|
||
} else {
|
||
reflectVal.Field(fieldInfo.Idx).SetFloat(f)
|
||
}
|
||
return true
|
||
case reflect.Interface:
|
||
reflectVal.Field(fieldInfo.Idx).Set(reflect.ValueOf(&inputVal))
|
||
return true
|
||
case reflect.Slice:
|
||
fallthrough
|
||
case reflect.Map:
|
||
fallthrough
|
||
case reflect.Struct:
|
||
var v interface{}
|
||
if err := json.Unmarshal([]byte(inputVal), &v); nil != err {
|
||
return false
|
||
}
|
||
reflectVal.Field(fieldInfo.Idx).Set(reflect.ValueOf(&v))
|
||
return true
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
// getInputValue 获取输入的值
|
||
//
|
||
// Author : go_developer@163.com<白茶清欢>
|
||
//
|
||
// Date : 14:43 2023/2/2
|
||
func (rv *ReflectValue) getInputValue(rule MappingRuleItem, header http.Header, paramByte, responseByte, extensionByte []byte) string {
|
||
switch rule.Location {
|
||
case MappingLocationHeader:
|
||
return header.Get(rule.Field)
|
||
case MappingLocationParam:
|
||
return gjson.GetBytes(paramByte, rule.Field).String()
|
||
case MappingLocationResponse:
|
||
return gjson.GetBytes(responseByte, rule.Field).String()
|
||
case MappingLocationExtension:
|
||
return gjson.GetBytes(extensionByte, rule.Field).String()
|
||
case MappingLocationAll:
|
||
str := header.Get(rule.Field)
|
||
if len(str) == 0 {
|
||
str = gjson.GetBytes(paramByte, rule.Field).String()
|
||
}
|
||
if len(str) == 0 {
|
||
str = gjson.GetBytes(responseByte, rule.Field).String()
|
||
}
|
||
if len(str) == 0 {
|
||
str = gjson.GetBytes(extensionByte, rule.Field).String()
|
||
}
|
||
return str
|
||
default:
|
||
return ""
|
||
}
|
||
}
|