golang反射函数注册

package main

import (
“fmt”
“reflect”

)

type Job interface {
New([]interface{}) interface{}
Run() (interface{}, error)
}

type DetEd struct {
Name string
Age int
}

// 为什么这样设计
// 这样就避免了 在创建新的实例的之后 结构体的方法中接受者为指针类型的不可见的问题
func (DetEd) New() *DetEd {
return &DetEd{}
}

func (ed *DetEd) Run(msg int) (interface{}, error) {
fmt.Printf(“msg %v,name=%v, age=%v \n”, msg, ed.Name, ed.Age)
return nil, nil
}

func CreateNewObject(controller interface{}) {
// 解析结构体
Dt := reflect.TypeOf(controller) // 这里可以拿到两个方法

_, ok := Dt.MethodByName("New")
if !ok {panic("not found New function")
}Dt = Dt.Elem() // 这之后就只能拿到一个方法了
// 记录对应属性所在的位置
nameMap := make(map[int]string, 0)
for i := 0; i < Dt.NumField(); i++ {field := Dt.Field(i)nameMap[i] = field.Name
}// 创建新的指针结构体对象
// 获取一个新的结构体对象
rv := reflect.ValueOf(controller)
newobjects := rv.MethodByName("New").Call(nil)
targetObject := newobjects[0]
// targetObject.newDATA := targetObject.Interface().(*DetEd)
newDATA.Run(111111111111111)// 真实数据 赋值
// tObject := targetObject.Elem() // 获取真实数据
// idata := map[string]interface{}{"Name": "张三", "Age": 23}
// for i := 0; i < tObject.NumField(); i++ {
// 	field := tObject.Field(i)
// 	fieldType := field.Type()
// 	targetValue := reflect.ValueOf(idata[nameMap[i]])
// 	// 将输入的值转换为结构体对应属性需要的类型
// 	result := reflect.ValueOf(targetValue.Interface()).Convert(fieldType)
// 	// 赋值
// 	tObject.Field(i).Set(result)
// }
// // 运行指定方法
// targetObject.MethodByName("Run").Call([]reflect.Value{1})

}

type OperatorInterface interface {
New(conf []byte) (OperatorInterface, error)
Run()
}

type MergeOPNew struct {
Conf struct {
Enabled bool yaml:"enabled"
}
Data string
}

// New 通过反射创建出新一个对象
func (op *MergeOPNew) New(data []byte) (result OperatorInterface, err error) {
tmpResult := &MergeOPNew{Data: “3”}

return tmpResult, nil

}

func (op *MergeOPNew) Run() {
fmt.Printf(“Run %s\n”, op.Data)
}

func main() {
mergeOPNew := &MergeOPNew{}
data, err := mergeOPNew.New([]byte(enabled: true))
if err != nil {
panic(err)
}
data.Run()
// CreateNewObject(&DetEd{})

// []strategy.MergeOPV3

}

type Student struct {
Id int
Name string
Age int
}

func reflectTest(i interface{}) {
// 获取变量的 reflect.Type
reType := reflect.TypeOf(i)
fmt.Println(“reflect.Type=”, reType)

// 获取变量的 reflect.Value
reVal := reflect.ValueOf(i)
fmt.Println("reflect.Value=", reVal)// 打印reVal类型，使用 reVal，打印Name 成员 失败。无法索引Name成员
//fmt.Printf("reVal=%T, name=%v",reVal,  reVal.Name)// 将 reVal 转成 interface
iVal := reVal.Interface()
fmt.Printf("iVal= %v, type= %T\n", iVal, iVal)
// iVal.Name 会报错Unresolved reference 'Name'
// fmt.Printf("iVal= %v, type= %T, name= %v\n", iVal, iVal, iVal.Name)// 将 interface 通过类型断言 转回成 Student
// stu:= iVal.(Student)
if stu, ok := iVal.(Student); ok {fmt.Printf("stu= %v, type= %T, name=%v\n", stu, stu, stu.Name)
}

}