使用Kotlin数据类在Jackson的缺失属性中区分null

Question

bounty到期在4天内。该问题的答案有资格获得+ 50声望赏金。Kyle McCormick希望对此问题引起更多关注：“使所有测试通过，而无需修改测试或模型类（仅修改映射器）。”

我想使用Jackson来反序列化，然后使用Kotlin的数据类序列化json。重要的是，我必须保持显式null属性与原始json中省略的属性之间的区别。

我有一个几乎完全由Kotlin数据类构建的大型域模型（50多个类）。 Kotlin的数据类提供了许多有用的功能，我需要在程序的其他位置使用这些功能，因此，我想保留它们而不是转换模型。

我目前已使该代码正常工作，但仅适用于Java类或使用Kotlin类主体中声明的Kotlin属性，而不适用于构造函数中声明的属性。为了使Kotlin的数据类实用程序功能正常工作，必须在构造函数中声明所有属性。

这是我的对象映射器设置代码：

val objectMapper = ObjectMapper()

objectMapper.registerModule(KotlinModule())
objectMapper.registerModule(Jdk8Module())

objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS)
objectMapper.configOverride(Optional::class.java).includeAsProperty =
    JsonInclude.Value.construct(JsonInclude.Include.NON_NULL, null)

objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, true)

objectMapper.configure(JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN, true)

objectMapper.configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, true)
objectMapper.nodeFactory = JsonNodeFactory.withExactBigDecimals(true)

这是我的测试班：

TestClass1.java

public class TestClass1 {
    public TestClass1() {}
    public TestClass1(int intVal, Optional<Double> optDblVal) {
        this.intVal = intVal;
        this.optDblVal = optDblVal;
    }
    public Integer intVal;
    public Optional<Double> optDblVal;
}

TestClasses.kt

data class TestClass2(val intVal: Int?, val optDblVal: Optional<Double>?)

class TestClass3(val intVal: Int?, val optDblVal: Optional<Double>?)

class TestClass4 {
    val intVal: Int? = null
    val optDblVal: Optional<Double>? = null
}

这是我的测试：

JsonReserializationTests.kt

@Test
fun `Test 1 - Explicit null Double reserialized as explicit null`() {
    val inputJson = """
        {
          "intVal" : 7,
          "optDblVal" : null
        }
        """.trimIndent()

    val intermediateObject = handler.objectMapper.readValue(inputJson, TestClassN::class.java)
    val actualJson = handler.objectMapper
        .writerWithDefaultPrettyPrinter()
        .writeValueAsString(intermediateObject)
        .replace("\r", "")

    assertEquals(inputJson, actualJson)
}

@Test
fun `Test 2 - Missing Double not reserialized`() {
    val inputJson = """
        {
          "intVal" : 7
        }
        """.trimIndent()

    val intermediateObject = handler.objectMapper.readValue(inputJson, TestClassN::class.java)
    val actualJson = handler.objectMapper
        .writerWithDefaultPrettyPrinter()
        .writeValueAsString(intermediateObject)
        .replace("\r", "")

    assertEquals(inputJson, actualJson)
}

每个课程的测试结果

Answer 1

让我们谈谈TestClass2。

如果将Kotlin代码转换为Java代码，则可以找到原因。

Intellij提供了Kotlin的转换工具。您可以从菜单Tools -> Kotlin -> Show Kotlin Bytecode.

中找到它

这里是TestClass2 Kotlin代码中的Java代码。

public final class TestClass2 {
   @Nullable
   private final Integer intVal;
   @Nullable
   private final Optional optDblVal;

   @Nullable
   public final Integer getIntVal() {
      return this.intVal;
   }

   @Nullable
   public final Optional getOptDblVal() {
      return this.optDblVal;
   }

   public TestClass2(@Nullable Integer intVal, @Nullable Optional optDblVal) {
      this.intVal = intVal;
      this.optDblVal = optDblVal;
   }

   @Nullable
   public final Integer component1() {
      return this.intVal;
   }

   @Nullable
   public final Optional component2() {
      return this.optDblVal;
   }

   @NotNull
   public final TestClass2 copy(@Nullable Integer intVal, @Nullable Optional optDblVal) {
      return new TestClass2(intVal, optDblVal);
   }

   // $FF: synthetic method
   public static TestClass2 copy$default(TestClass2 var0, Integer var1, Optional var2, int var3, Object var4) {
      if ((var3 & 1) != 0) {
         var1 = var0.intVal;
      }

      if ((var3 & 2) != 0) {
         var2 = var0.optDblVal;
      }

      return var0.copy(var1, var2);
   }

   @NotNull
   public String toString() {
      return "TestClass2(intVal=" + this.intVal + ", optDblVal=" + this.optDblVal + ")";
   }

   public int hashCode() {
      Integer var10000 = this.intVal;
      int var1 = (var10000 != null ? var10000.hashCode() : 0) * 31;
      Optional var10001 = this.optDblVal;
      return var1 + (var10001 != null ? var10001.hashCode() : 0);
   }

   public boolean equals(@Nullable Object var1) {
      if (this != var1) {
         if (var1 instanceof TestClass2) {
            TestClass2 var2 = (TestClass2)var1;
            if (Intrinsics.areEqual(this.intVal, var2.intVal) && Intrinsics.areEqual(this.optDblVal, var2.optDblVal)) {
               return true;
            }
         }

         return false;
      } else {
         return true;
      }
   }

原始代码太长，因此这里仅是构造函数。

public TestClass2(@Nullable Integer intVal, @Nullable Optional optDblVal) {
      this.intVal = intVal;
      this.optDblVal = optDblVal;
}

由于Jackson库无法创建没有参数的实例，因为没有非参数构造函数，因此它将尝试创建带有某些参数的新实例。对于测试用例2，JSON仅具有一个参数，因此它将寻找一个单参数构造函数，但是没有，因此它将引发异常。这也是通过测试用例1的原因。

因此，您要做的就是必须将所有默认值赋予数据类的所有参数，以使非参数构造函数像下面的代码一样。

data class TestClass2(val intVal: Int? = null, val optDblVal: Optional<Double>? = null)

然后，如果您在Java代码中看到，则该类将具有非参数构造函数。

   public TestClass2(@Nullable Integer intVal, @Nullable Optional optDblVal) {
      this.intVal = intVal;
      this.optDblVal = optDblVal;
   }

   // $FF: synthetic method
   public TestClass2(Integer var1, Optional var2, int var3, DefaultConstructorMarker var4) 
   {
      if ((var3 & 1) != 0) {
         var1 = (Integer)null;
      }

      if ((var3 & 2) != 0) {
         var2 = (Optional)null;
      }

      this(var1, var2);
   }

   public TestClass2() {
      this((Integer)null, (Optional)null, 3, (DefaultConstructorMarker)null);
   }

因此，如果您仍然想使用Kotlin数据类，则必须为所有变量提供默认值。