如何强制初始化子级-父级关系？

Question

我有一个配置元素的层次结构，它们都实现了一个接口（简化了）：

interface Configuration {
    val elements: Long
    val data: Long?
    var parent: Configuration?
}

实现将由jackson-kotlin读取如下所示的Yaml文件来构建：

checks:
  elements: 10
  data: 1234
  ports:
    elements: 5

代码可能会执行同样的操作：

CheckConfig(elements = 10, data = 1234, portConfig = PortConfig(elements = 5))

inline fun <reified T: Configuration> T.updateChildLinks() {
    (this::class as KClass<T>).memberProperties.forEach {
        if (it.returnType.isSubtypeOf(Configuration::class.createType(nullable = true))) {
            it.isAccessible = true
            val config: Configuration = it.get(this) as Configuration
            config.parent = this
        }
    }
}

并在每个父级的init块中调用它。我能做得更好吗（特别是，我不喜欢我必须记住在init阶段调用helper函数）？

编辑后添加：以前，我有一个只使用代码的解决方案，它将数据沿链传递：

CheckConfig(elements = 10, data = 1234, 
        portConfig = PortConfig(elements = 5, parentData = 1234))

然后使用data查看parentdata,但我在使用Jackson时遇到了麻烦。

Answer 1

因此，为了将来的参考，下面是我的结论：

诀窍是承认我的数据类不能有指向其父类的链接，因为子类将在其父类之前构造。

但是，我可以利用Jackson来解决最初的回退问题，方法是实现一个自定义的反序列化器，该反序列化器跟踪父属性值并应用它（如果缺少该值）。

唯一的缺点是，反序列化器只知道属性值被反序列化之后（显然），所以不能将它传递给可能需要它的子值。因此，这将错误地给出123，而它应该是345:

top:
  data: 123
  sub:
    subsub:
      important: false
    data: 345

但如果您可以控制，那么您可以使用以下命令：

class PropInheritance : JsonDeserializer<Long>() {
    override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Long {
        val currentContextName = p.parsingContext
                .pathAsPointer().toString()
                // cut the last "prop" variable name
                .replaceAfterLast("/", "")
        val prop = p.longValue
        val propStack = initStackIfNeeded(ctxt)
        propStack.push(currentContextName to prop)
        return prop
    }

    override fun getNullValue(ctxt: DeserializationContext): Long {
        val propStack = initStackIfNeeded(ctxt)

        // here, the prop name is missing the context is just the parent
        val currentContextName = ctxt.parser.parsingContext
                .pathAsPointer().toString()
        // find a prop on stack that has the same path
        while (propStack.isNotEmpty() 
                && !currentContextName.startsWith(propStack.peek().first)) {
            propStack.pop()
        }

        val prop = if (propStack.isNotEmpty()) 
                       propStack.peek().second
                   else 
                       ctxt.getAttribute("default") as Long

        // record current prop on the stack so potential children can find it
        propStack.push(currentContextName to prop)
        return prop
    }

    private fun initStackIfNeeded(ctxt: DeserializationContext)
            : Deque<Pair<String, Long>> {
        if (ctxt.getAttribute("stack") == null) {
            ctxt.setAttribute("stack", ArrayDeque<Pair<String, Long>>())
        }
        return ctxt.getAttribute("stack") as Deque<Pair<String, Long>>
    }
}

在我的示例中，我使用了一个混合项来将@JsonDeserialize(using=PropInherity::class)应用于我的接口方法的getter：

interface HasProp {
    val prop: Long
}

interface HasPropMixin {
    @JsonDeserialize(using = PropInheritance::class)
    fun getProp(): Long
}

mapper = ObjectMapper(YAMLFactory()).registerModule(KotlinModule())
    .addMixin(HasProp::class.java, HasPropMixin::class.java)