go 管道、反射

最新推荐文章于 2024-07-26 22:49:45 发布

都是挨踢狗

最新推荐文章于 2024-07-26 22:49:45 发布

阅读量188

点赞数

分类专栏： golang 文章标签： golang

本文链接：https://blog.csdn.net/hongyawang/article/details/124103605

版权

golang 专栏收录该内容

1 篇文章

订阅专栏

本文探讨了Go语言中的管道机制及其在事件处理器中的应用，同时深入解析了反射的概念，展示了如何在Go程序中利用反射进行动态操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

利用管道、反射实现业务代码和非业务代码分离，涉及监听其设计、管道设计、反射应用等知识点

事件监听结构

const chanBuff = 100

type Event struct {
	// param list, FIFO
	Data   []interface{} `json:"data"`
	Func   interface{}   `json:"func"`
	Method string        `json:"method"`
}

type ListenEvent struct {
	Event
}

type CallBackEvent struct {
	Event
}

var sm sync.Mutex
var pe ProcessListener

type ProcessListener struct {
	ProcListenerCh chan *ListenEvent
	ProcCallBackCh chan *CallBackEvent
}

func GetProcessListener() *ProcessListener {
	sm.Lock()
	defer func() { sm.Unlock() }()
	if pe != (ProcessListener{}) {
		return &pe
	}
	pe = ProcessListener{
		ProcListenerCh: make(chan *ListenEvent, chanBuff),
		ProcCallBackCh: make(chan *CallBackEvent, chanBuff),
	}
	return &pe
}

//AddEvent 添加事件
func (pe *ProcessListener) AddEvent(event interface{}) error {
	if e, ok := event.(*ListenEvent); ok {
		pe.ProcListenerCh <- e
	}
	if e, ok := event.(*CallBackEvent); ok {
		pe.ProcCallBackCh <- e
	}
	return nil
}

//Execute 执行事件
func (pe *ProcessListener) Execute() {
	for {
		select {
		case e := <-pe.ProcListenerCh:
			GetProcessEventHandler().ListenerHandle(e)
		case e := <-pe.ProcCallBackCh:
			GetProcessEventHandler().CallBackHandle(e)
		}
	}
}

事件处理器

//流程事件处理器
type ProcessEventHandler struct {
}

func GetProcessEventHandler() *ProcessEventHandler {
	return &ProcessEventHandler{}
}

//监听流程逻辑
func (h *ProcessEventHandler) ListenerHandle(event *ListenEvent) {
	handle(event)
}

//流程回调处理逻辑
func (h *ProcessEventHandler) CallBackHandle(event *CallBackEvent) {
	handle(event)
}
func handle() {
    ctx, cancel := context.WithTimeout(context.Background(), common.TimeOut5Seco)
	defer cancel()
	handler := reflect.New(reflect.ValueOf(event.Func).Type())
	var params []reflect.Value
	vars := event.Data
	if vars != nil {
		params = make([]reflect.Value, len(vars))
		for i, v := range vars {
			params[i] = reflect.ValueOf(v)
		}
	}
	rets := handler.MethodByName(event.Method).Call(params)
	val := rets[0]
	if err, ok := val.Interface().(error); ok {
		if err != nil {
			log.Errorf(log.FormatFields(ctx, utils.LogTag, map[string]interface{}{
				"action": "the ProcessEventHandler CallBackHandle is error",
				"err":    err.Error(),
			}))
		}
	}
}

使用

// 流程结束更新配置状态
	if u.Status == model.Completed {
		configUpdate := &app_config.CallBackInfo{
			ProcInsID: param.ProcInsID,
			Status:    u.Status,
			OpUser:    model.BpmUser,
			OpType:    param.OpType,
		}
		params := make([]interface{}, 1)
		params[0] = configUpdate
		event := &domain.CallBackEvent{}
		event.Data = params
		event.Func = *app_config.GetConfigApp()
		event.Method = "CallBack"
		err = domain.GetProcessListener().AddEvent(event)
	}