I have Handler classes which accepts Queries and returns Results. Handlers is anemic. They accept input data bag and returns output data bag. Handlers can be many so I created common generic interface for handlers and common interfaces for query bags and result bags. Additionally, I created HandlerManager class, which accepts Query instance and using pattern matching, decide, which instance of Handler need to use:
sealed class Query {
class QueryA(val data: Int) : Query()
class QueryB(val data: Double) : Query()
class QueryC(val data: String) : Query()
}
sealed class Result {
class ResultA(val data: Int) : Result()
class ResultB(val data: Double) : Result()
class ResultC(val data: String) : Result()
}
interface Handler<Q : Query, R : Result> {
fun handle(query: Q): R
}
class HandlerA : Handler<Query.QueryA, Result.ResultA> {
override fun handle(query: Query.QueryA): Result.ResultA {
return Result.ResultA(query.data)
}
}
class HandlerB : Handler<Query.QueryB, Result.ResultB> {
override fun handle(query: Query.QueryB): Result.ResultB {
return Result.ResultB(query.data)
}
}
class HandlerC : Handler<Query.QueryC, Result.ResultC> {
override fun handle(query: Query.QueryC): Result.ResultC {
return Result.ResultC(query.data)
}
}
class HandlerManager() {
private val handlerA = HandlerA()
private val handlerB = HandlerB()
private val handlerC = HandlerC()
fun handle(query: Query): Result {
return when (query) {
is Query.QueryA -> handlerA.handle(query)
is Query.QueryB -> handlerB.handle(query)
is Query.QueryC -> handlerC.handle(query)
}
}
}
Question is simple: is this model is suitable and valid? Or there are OOP-style/Rich domain alternatives?