在序列化和反序列化期间JSON属性的不同名称

小开

我将两个不同的getter /setter对绑定到一个变量:

class Coordinates{
int red;


@JsonProperty("red")
public byte getRed() {
return red;
}


public void setRed(byte red) {
this.red = red;
}


@JsonProperty("r")
public byte getR() {
return red;
}


public void setR(byte red) {
this.red = red;
}
}

小开

最佳答案

刚刚测试，这是有效的:

public class Coordinates {
byte red;


@JsonProperty("r")
public byte getR() {
return red;
}


@JsonProperty("red")
public void setRed(byte red) {
this.red = red;
}
}

其思想是方法名应该是不同的，因此jackson将其解析为不同的字段，而不是一个字段。

下面是测试代码:

Coordinates c = new Coordinates();
c.setRed((byte) 5);


ObjectMapper mapper = new ObjectMapper();
System.out.println("Serialization: " + mapper.writeValueAsString(c));


Coordinates r = mapper.readValue("{\"red\":25}",Coordinates.class);
System.out.println("Deserialization: " + r.getR());

结果:

Serialization: {"r":5}
Deserialization: 25

小开

这并不是我所期望的解决方案(尽管这是一个合理的用例)。我的要求是允许一个存在bug的客户端(一个已经发布的移动应用程序)使用替代名称。

解决方案在于提供一个单独的setter方法，如下所示:

@JsonSetter( "r" )
public void alternateSetRed( byte red ) {
this.red = red;
}

小开

你可以写一个序列化类来实现:

public class Symbol


{
private String symbol;


private String name;


public String getSymbol() {
return symbol;
}
public void setSymbol(String symbol) {
this.symbol = symbol;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

public class SymbolJsonSerializer extends JsonSerializer<Symbol> {


@Override
public void serialize(Symbol symbol, JsonGenerator jgen, SerializerProvider serializers) throws IOException, JsonProcessingException {
jgen.writeStartObject();


jgen.writeStringField("symbol", symbol.getSymbol());
//Changed name to full_name as the field name of Json string
jgen.writeStringField("full_name", symbol.getName());
jgen.writeEndObject();
}
}

            ObjectMapper mapper = new ObjectMapper();


SimpleModule module = new SimpleModule();
module.addSerializer(Symbol.class, new SymbolJsonSerializer());
mapper.registerModule(module);


//only convert non-null field, option...
mapper.setSerializationInclusion(Include.NON_NULL);


String jsonString = mapper.writeValueAsString(symbolList);

小开

他们必须将此包含为一个特性，因为现在为getter和setter设置不同的@JsonProperty会导致您所期望的结果(在同一字段的序列化和反序列化期间不同的属性名)。Jackson 2.6.7版本

小开

可以有普通的getter/setter对。你只需要在@JsonProperty中指定访问模式

下面是单元测试:

public class JsonPropertyTest {


private static class TestJackson {


private String color;


@JsonProperty(value = "device_color", access = JsonProperty.Access.READ_ONLY)
public String getColor() {
return color;
};


@JsonProperty(value = "color", access = JsonProperty.Access.WRITE_ONLY)
public void setColor(String color) {
this.color = color;
}


}


@Test
public void shouldParseWithAccessModeSpecified() throws Exception {
String colorJson = "{\"color\":\"red\"}";
ObjectMapper mapper = new ObjectMapper();
TestJackson colotObject = mapper.readValue(colorJson, TestJackson.class);


String ser = mapper.writeValueAsString(colotObject);
System.out.println("Serialized colotObject: " + ser);
}
}

我得到的输出如下:

Serialized colotObject: {"device_color":"red"}

小开

你可以使用在jackson 2.9.0中引入的@jsonAlias

例子:

public class Info {
@JsonAlias({ "red" })
public String r;
}

在序列化期间使用r，但在反序列化期间允许red作为别名。不过，这仍然允许r被反序列化。

小开

你可以使用@JsonSetter和@JsonGetter的组合来分别控制属性的反序列化和序列化。这也将允许您保持标准化的getter和setter方法名，它们与您实际的字段名相对应。

import com.fasterxml.jackson.annotation.JsonSetter;
import com.fasterxml.jackson.annotation.JsonGetter;


class Coordinates {
private int red;


//# Used during serialization
@JsonGetter("r")
public int getRed() {
return red;
}


//# Used during deserialization
@JsonSetter("red")
public void setRed(int red) {
this.red = red;
}
}

编辑:更新了文档链接，因为fasterxml GitHub页面现在返回404。

小开

我知道这是一个老问题，但对我来说，当我发现它与Gson库冲突时，它就工作了，所以如果你使用Gson，那么使用@SerializedName("name")而不是@JsonProperty("name")，希望这有帮助

小开

用Jackson 2.9+引入的@JsonAlias进行注释，而不用在要用多个别名(json属性的不同名称)反序列化的项上提到@JsonProperty，就可以了。

在我的用例中，我使用com.fasterxml.jackson.annotation.JsonAlias来保持包的一致性。

例如:

@Data
@Builder
public class Chair {


@JsonAlias({"woodenChair", "steelChair"})
private String entityType;


}




@Test
public void test1() {


String str1 = "{\"woodenChair\":\"chair made of wood\"}";
System.out.println( mapper.readValue(str1, Chair.class));
String str2 = "{\"steelChair\":\"chair made of steel\"}";
System.out.println( mapper.readValue(str2, Chair.class));


}

工作得很好。

小开

你可以使用这个变体:

import lombok.Getter;
import com.fasterxml.jackson.annotation.JsonGetter;
import com.fasterxml.jackson.annotation.JsonProperty;


//...


@JsonProperty(value = "rr") // for deserialization
@Getter(onMethod_ = {@JsonGetter(value = "r")}) // for serialization
private String rrrr;

使用Lombok吸气器

小开

就我而言，我必须阅读巴西葡萄牙语的输入，并生成英语的输出。

所以，一个对我有用的变通方法是使用@JsonAlias而不是@JsonProperty:


// pseudo-java
@Value
public class User {


String username;


public User(
@JsonAlias("nome_usuario") String username) {
// ...
}


}

小开

对于Kotlin的人:

data class TestClassDTO(
@JsonProperty("user_name")
val username: String
)

你将成功地从RestControllers中的POST有效载荷处理{"user_name": "John"}

但是当您需要用相同的@JsonProperty名称进行序列化时，您可以使用这种反射方法

fun Any.forceSerialize(separator: String, sorted: Boolean = false): String {
var fieldNameToAnnotatedNameMap = this.javaClass.declaredFields.map { it.name }.associateWith { fieldName ->
val jsonFieldName =
this::class.primaryConstructor?.parameters?.first { it.name == fieldName }?.annotations?.firstOrNull { it is JsonProperty }
val serializedName = if (jsonFieldName != null) (jsonFieldName as JsonProperty).value else fieldName
serializedName
}
if (sorted)
fieldNameToAnnotatedNameMap = fieldNameToAnnotatedNameMap.toList().sortedBy { (_, value) -> value}.toMap()
return fieldNameToAnnotatedNameMap.entries.joinToString(separator) { e ->
val field = this::class.memberProperties.first { it.name == e.key }
"${e.value}=${field.javaGetter?.invoke(this)}"
}
}

小开

在属性上同时使用JsonAlias和JsonProperty。

data class PayoutMethodCard(
@JsonProperty("payment_account_id")
@JsonAlias("payout_account_id")
val payoutAccountId: Long
)

在这种情况下，paymentAccountId可以通过payment_account_id或payout_account_id从JSON序列化，但当反序列化回JSON时，将使用JSONProperty，并且将使用payment_account_id。