``` go
type Task struct{
TaskExec
Status int
Name string
StratTime int64
EndTime int64
}
type TaskExec interface{
exec()
}
type TaskA struct{
Task
ParamA string
}
type TaskB struct{
Task
ParamA string
}
func (TaskA) exec(){
// 执行任务A的逻辑
}
func (TaskB) exec(){
// 执行任务B的逻辑
}
// 执行任务,问题点在入参这里,这样写入参就只能是Task,不能传TaskA和TaskB,
// 用go有什么办法可以实现像java一样传子类做为入参
func Exec(task *Task){
// 修改任务状态为执行中
task.Status = 1
// 记录任务开始执行时间
task.StartTime = uint64(time.Now().Unix())
// 这里还会有很共性逻辑处理被省略掉了
// 执行具体任务的逻辑
task.exec()
// 修改任务状态为执行结束
task.Status = 2
// 记录任务执行结束时间
task.EndTime = uint64(time.Now().Unix())
// 这里也是还会有很共性逻辑处理被省略掉了
}
func main(){
ta := TaskA{}
tb := TaskB{}
// 这里要怎么才能传子类到函数里面执行????
Exec(&ta)
Exec(&tb)
}
```
你看这样会不会好点, `Task` 作为执行者,实际 `exec` 可以根据需求设置为实现 `TaskExec` 的对象。
```
type Task struct {
exec TaskExec
Status int
Name string
StartTime int64
EndTime int64
}
func NewTask(exec TaskExec) *Task {
return &Task{
exec: exec,
}
}
type TaskExec interface {
exec()
}
type TaskA struct {
ParamA string
}
type TaskB struct {
ParamA string
}
func (TaskA) exec() {
// 执行任务A的逻辑
}
func (TaskB) exec() {
// 执行任务B的逻辑
}
// 执行任务,问题点在入参这里,这样写入参就只能是Task,不能传TaskA和TaskB,
// 用go有什么办法可以实现像java一样传子类做为入参
func (t *Task) Exec() {
// 修改任务状态为执行中
t.Status = 1
// 记录任务开始执行时间
t.StartTime = time.Now().Unix()
// 这里还会有很共性逻辑处理被省略掉了
// 执行具体任务的逻辑
t.exec.exec()
// 修改任务状态为执行结束
t.Status = 2
// 记录任务执行结束时间
t.EndTime = time.Now().Unix()
// 这里也是还会有很共性逻辑处理被省略掉了
}
func main() {
ta := NewTask(&TaskA{})
tb := NewTask(&TaskB{})
// 这里要怎么才能传子类到函数里面执行????
ta.Exec()
tb.Exec()
}
```
#2
更多评论
或许这么写可以满足你的想法(公共逻辑可以绑定到父结构体Task上)
package main
import (
"log"
"time"
)
type Task struct {
TaskExec
Status int
Name string
StratTime int64
EndTime int64
}
func (t Task) start() {
// 修改任务状态为执行中
t.Status = 1
// 记录任务开始执行时间
t.StratTime = time.Now().Unix()
// 这里还会有很共性逻辑处理被省略掉了
}
func (t Task) end() {
// 修改任务状态为执行结束
t.Status = 2
// 记录任务执行结束时间
t.EndTime = time.Now().Unix()
}
type TaskExec interface {
exec()
}
type TaskA struct {
Task
ParamA string
}
type TaskB struct {
Task
ParamA string
}
func (a TaskA) exec() {
// 执行任务A的逻辑
a.start()
//A特有逻辑
log.Println("A特有逻辑")
a.end()
}
func (b TaskB) exec() {
b.start()
//B特有逻辑
log.Println("B特有逻辑")
b.end()
}
// 执行任务,问题点在入参这里,这样写入参就只能是Task,不能传TaskA和TaskB,
// 用go有什么办法可以实现像java一样传子类做为入参
func Exec(task TaskExec) {
// 这里也是还会有很共性逻辑处理被省略掉了
//具体逻辑
task.exec()
}
func main() {
ta := TaskA{}
tb := TaskB{}
// 这里要怎么才能传子类到函数里面执行????
Exec(&ta)
Exec(&tb)
}
#1
你这个接近我描述需要的要求,但我实际要实现逻辑要复杂一点,这里只是简化了。实际具体的任务逻辑还有几个函数要实现的,例如前置后置通知,异常通知等,你这样实现每个任务的执行方法都要重复这个代码逻辑,我大概要实现10来个任务,还是会有很多冗余代码,不过还是感谢回复
#3