Jackson ObjectMapper majuscules/minuscules questions

Quand je sérialiser/désérialiser un objet quelconque, tous les noms de champ sont convertis en minuscules.
Est-il une configuration pour définir qui fait Jackson garder les noms de champ exactement comme ils sont? À la fois pour la sérialisation et la désérialisation?

(Je sais a propos de @JsonProperty, mais cela ne semble pas être de droite, depuis ce que j'ai besoin est juste pour Jackson, de respecter ce qui existe déjà)

Mon code de test:

import java.io.Serializable;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.cfg.MapperConfig;
import com.fasterxml.jackson.databind.introspect.AnnotatedField;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
public class Test {
static class Example implements Serializable {
private String Test;
private String ABC;
private String XyZ;
public String getTest() { return Test; }
public void setTest(String test) { Test = test; }
public String getABC() { return ABC; }
public void setABC(String abc) { ABC = abc; }
public String getXyZ() { return XyZ; }
public void setXyZ(String xyz) { XyZ = xyz; }
}
static class MyPropertyNamingStrategy extends PropertyNamingStrategy {
@Override
public String nameForField(MapperConfig<?> config, AnnotatedField field, String defaultName) {
return convert(defaultName);
}
@Override
public String nameForGetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName) {
return convert(defaultName);
}
@Override
public String nameForSetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName) {
return convert(defaultName);
}
private String convert(String input) {
return input;
}
}
public static void main(String[] args) throws Exception {
ObjectMapper objectMapper = new ObjectMapper()
.setPropertyNamingStrategy(new MyPropertyNamingStrategy())
.enable(SerializationFeature.INDENT_OUTPUT)
.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);      
//From OBJECT to JSON
Example ex = new Example();
ex.setTest("1");
ex.setABC("2");
ex.setXyZ("3");
System.out.println(objectMapper.writeValueAsString(ex));
//FROM JSON to OBJECT
String jsonString = "{ \"Test\":\"0\", \"ABC\":\"1\", \"XyZ\":\"2\" }";
Example fEx = objectMapper.readValue(jsonString, Example.class);
}   
}

Grâce à @BlueLettuce16, j'ai réussi à construire une "amélioration" de la version de la PropertyNamingStrategy. Ici, il est:

import java.lang.reflect.Modifier;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.cfg.MapperConfig;
import com.fasterxml.jackson.databind.introspect.AnnotatedField;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
public class CustomPropertyNamingStrategy extends PropertyNamingStrategy {
@Override
public String nameForField(MapperConfig<?> config, AnnotatedField field, String defaultName) {
return convertForField(defaultName);
}
@Override
public String nameForGetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName) {
return convertForMethod(method, defaultName);
}
@Override
public String nameForSetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName) {
return convertForMethod(method, defaultName);
}
private String convertForField(String defaultName) {
return defaultName;
}
private String convertForMethod(AnnotatedMethod method, String defaultName) {
if (isGetter(method)) {
return method.getName().substring(3);
}
if (isSetter(method)) {
return method.getName().substring(3);
}
return defaultName;
}
private boolean isGetter(AnnotatedMethod method) {
if (Modifier.isPublic(method.getModifiers()) && method.getGenericParameterTypes().length == 0) {
if (method.getName().matches("^get[A-Z].*") && !method.getGenericReturnType().equals(void.class))
return true;
if (method.getName().matches("^is[A-Z].*") && method.getGenericReturnType().equals(boolean.class))
return true;
}
return false;
}
private boolean isSetter(AnnotatedMethod method) {
return Modifier.isPublic(method.getModifiers()) && method.getGenericReturnType().equals(void.class) && method.getGenericParameterTypes().length == 1
&& method.getName().matches("^set[A-Z].*");
}
}

implémente un custom PropertyNamingStrategy, peut-être
Comment êtes-vous à l'aide de @JsonProperty? Êtes-vous en passant la Chaîne de nom de champ?
Je ne vois pas un moyen de mettre en œuvre les PropertyNamingStrategy de faire correspondre les noms de champs correctement. Si un champ est nommé "ABC", un Autre est nommé XYz, elles ne correspondent PAS à l'JSON lors de la sérialisation/désérialisation.

OriginalL'auteur Barni | 2014-11-04

Je pense que c'est la solution (à l'aide personnalisée PropertyNamingStrategy):

import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.cfg.MapperConfig;
import com.fasterxml.jackson.databind.introspect.AnnotatedField;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
public class MyPropertyNamingStrategy extends PropertyNamingStrategy {
@Override
public String nameForField(MapperConfig<?> config, AnnotatedField field, String defaultName) {
return convert(field.getName());
}
@Override
public String nameForGetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName) {
return convert(method.getName().toString());
}
@Override
public String nameForSetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName) {
return convert(method.getName().toString());
}
private String convert(String input) {
return input.substring(3);
}
}

Test

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.io.IOException;
import java.io.StringWriter;
public class MyPropertyNamingStrategyTest {
public static void main(String[] args) {
PrivatePerson privatePerson = new PrivatePerson();
privatePerson.setFirstName("John");
privatePerson.setLastName("Smith");
ObjectMapper mapper = new ObjectMapper();
mapper.setPropertyNamingStrategy(new MyPropertyNamingStrategy());
mapper.enable(SerializationFeature.INDENT_OUTPUT);
StringWriter sw = new StringWriter();
try {
mapper.writeValue(sw, privatePerson);
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(sw.toString());
}
}

PrivatePerson

public class PrivatePerson {
private String firstName;
private String lastName;
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getFirstName() {
return firstName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getLastName() {
return lastName;
}
}

Maintenant, les champs sont convertis en majuscules. La sérialisation et la Désérialisation ne fonctionnera que si les champs de classe sont convertis en majuscules.
Avez-vous essayé de changer de convertir méthode de retour d'entrée? private String convertir(String input) { return; }
Oui je l'ai fait. La diffence est qu'ils sont tous mis en minuscule maintenant. Le cas n'est jamais respecté, ou elles sont toutes Haut, en Bas, ou Pascal (première lettre en majuscule)... Mais tout en RESPECTANT l'affaire n'est pas une option.
J'ai trouvé la solution et à l'édition de code. J'ai changé ce qui est retourné à partir de nameForField, nameForGetterMethod et nameForSetterMethod.
J'ai testé votre classe et j'obtiens pour de l'objet json: { "Test" : "1", "ABC" : "2", "XyZ" : "3" } et de json pour objet: Exemple{Test='0', ABC='1', XyZ='2'} qu'attendez-vous? Si vous attendez la même chose et le résultat est différent, alors vous n'avez pas de copie de la dernière solution.

OriginalL'auteur BlueLettuce16

J'ai eu le même problème.

C'est ma solution:

public class MyNamingStrategy extends PropertyNamingStrategy {
@Override
public String nameForField(MapperConfig<?> config, AnnotatedField field, String defaultName) {
return field.getName();
}
@Override
public String nameForGetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName) {
return convert(method, defaultName);
}
@Override
public String nameForSetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName) {
return convert(method, defaultName);
}
private String convert(AnnotatedMethod method, String defaultName) {
Class<?> clazz = method.getDeclaringClass();
List<Field> flds = FieldUtils.getAllFieldsList(clazz);
for (Field fld : flds) {
if (fld.getName().equalsIgnoreCase(defaultName)) {
return fld.getName();
}
}
return defaultName;
}
}

Dans ce cas, vous obtiendrez le nom exact de l'établissement, et ne pas avoir à dépendre les noms corrects des méthodes.

OriginalL'auteur Bobby

1

Vous pouvez configurer Jackson à être le cas de la sensibilité de pannes:
```
ObjectMapper mapper = new ObjectMapper();
mapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);
```
Cudos à https://stackoverflow.com/a/32842962/1639556

cela aidera pour la sérialisation, ou tout simplement pour la désérialisation?
J'ai essayé ce pour la désérialisation demande entrante. Mais il n'a pas de sens pour moi qu'il aurait une incidence sur la sérialisation. Vous avez déjà l'objet et il doit être sérialisé seulement une certaine manière à chaque fois.
En effet, il ne permet pas de résoudre le problème de l'OP est - il veut avoir l'original versions pour la sérialisation et la désérialisation.
Vous avez raison, j'ai manqué le cadre. De toute façon ma réponse peut être utile pour les googlers à l'avenir. Je l'ai trouvé plus tôt que l'autre solution.

OriginalL'auteur Leos Literak
0

Même si @JsonProperty ne fonctionne pas, j'ai été en mesure d'utiliser @JsonSetter et @JsonGetter à la carte capitalisés json noms de champ.
```
@JsonSetter("ABC")
public void setABC(String ABC) {
this.ABC= ABC;
}
```
Printemps maintenant sérialiser l'objet champ "ABC" et non pas "abc".

OriginalL'auteur Ethan

Vous devez vous connecter pour publier un commentaire.