如何优雅的限制方法调用者在调用某个方法之前，必须先调用多个依赖的方法

细说说业务场景.

终于遇到一个 xy problem

@Jooooooooo 就是我一个数据处理类有一些方法 A ，这些方法 A 是需要依赖外部数据的，并且这些数据需要提前处理成方法依赖的格式。我目前是在调用方法之前，先调用依赖数据处理函数，将数据处理成相应的格式，再赋值给类的属性。 方法 A 在执行的时候，再取出需要的数据。这样的问题是调用者可能忘记提前设置方法 A 需要的数据，而如果是把依赖的数据通过方法参数的形式传入，又会导致方法参数太多

f1 :: A -> B
f2 :: C -> D
f3 :: B -> D -> E
f4 :: E -> R

let b = f1(a)
let d = f2(c)
let e = f3(b, d)
let result = f4(e)

直接把业务依赖编码进类型里不就完事了？

方法参数太多可以考虑把参数整合到一个类里

@EminemW 咋可能忘记...感觉你没抓住问题的重点.

简单，用函数解决啊，你是什么语言

@Jooooooooo 可能是我设计有问题


type Handler struct {
A map[string]interface{}
B map[string]interface{}
C map[string]interface{}
D map[string]interface{}
E map[string]interface{}
}

func (a *Handler) SetA(inputList []interface{}) {
for _, input := range inputList {
a.A["key"] = input
}
}

func (a *Handler) DoA() (result map[string]string, err error) {
// do something
return
}

func (a *Handler) DoB() (result map[string]string, err error) {
// do something
return
}

func (a *Handler) DoC() (result map[string]string, err error) {
// do something
return
}

func NewHandler() Handler {
return Handler{
A: map[string]interface{}{},
B: map[string]interface{}{},
C: map[string]interface{}{},
D: map[string]interface{}{},
E: map[string]interface{}{},
}
}

func main() {
instance := NewHandler()
instance.SetA([]interface{}{})
//忘记 SetB SetC

result, err := instance.DoA()
result, err = instance.DoB()
result, err = instance.DoC()
}

@lmshl 这种方式我想过，应该是符合我需求的，缺点是，类型会多很多

@jamel Go ，可以大概解释一下吗

怎么会忘记呢，你调用处理数据的函数然后不传数据是吧。

@EminemW 一个方法里面接受一个函数参数，函数参数里面进行初始化数据，或者返回数据，再接受第二个函数参数，进行数据处理返回最终你想要的数据

感觉可以设计成 A 、B 、C 、D 、E 为内部类对象，Do 方法在内部类实现，可以抽象出来一个接口，SetA 返回 A 对象

instance.SetA().Do()

fun a(initData: () -> Unit, handlerData: () -> Map<String, String>): String {
initData()
val map = handlerData()

return ""
}

fun main() {
a({
// 初始化数据
val str = "fdsa"
}, {
// 数据处理
val substring = "fdas".substring(1, 2)
mapOf()
})
}

如果你参数是必传的，那再怎么处理，这个参数的值总得被初始化吧，你期望是怎样的呢？

middleware