Jackson, deserialize class with private fields and arg-constructor without annotations

问题:

It is possible to deserialize to a class with private fields and a custom argument constructor without using annotations and without modifying the class, using Jackson?

I know it's possible in Jackson when using this combination: 1) Java 8, 2) compile with "-parameters" option, and 3) the parameters names match JSON. But it's also possible in GSON by default without all these restrictions.

For example:

public class Person {     private final String firstName;     private final String lastName;     private final int age;      public Person(String firstName, String lastName, int age) {         this.firstName = firstName;         this.lastName = lastName;         this.age = age;     }      public static void main(String[] args) throws IOException {         String json = "{firstName: \"Foo\", lastName: \"Bar\", age: 30}";          System.out.println("GSON: " + deserializeGson(json)); // works fine         System.out.println("Jackson: " + deserializeJackson(json)); // error     }      public static Person deserializeJackson(String json) throws IOException {         ObjectMapper mapper = new ObjectMapper();         mapper.enable(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES);         mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);         return mapper.readValue(json, Person.class);     }      public static Person deserializeGson(String json) {         Gson gson = new GsonBuilder().create();         return gson.fromJson(json, Person.class);     } } 

Wich works fine for GSON, but Jackson throws:

Exception in thread "main" com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of `jacksonParametersTest.Person` (no Creators, like default construct, exist): cannot deserialize from Object value (no delegate- or property-based Creator)  at [Source: (String)"{firstName: "Foo", lastName: "Bar", age: 30}"; line: 1, column: 2]     at com.fasterxml.jackson.databind.exc.InvalidDefinitionException.from(InvalidDefinitionException.java:67) 

It's possible in GSON, so I would expect that there must be some way in Jackson without modifying the Person class, without Java 8, and without an explicit custom deserializer. Does anybody know a solution?

- Update, additional info

Gson seems to skip the argument constructor, so it must be creating a no-argument constructor behind the scenes using reflections.

Also, there exists a Kotlin Jackson module which is able to do this for Kotlin data classes, even without the "-parameters" compiler flag. So it is strange that such a solution doesn't seem to exist for Java Jackson.

This is the (nice and clean) solution available in Kotlin Jackson (which IMO should also become available in Java Jackson via a custom module):

val mapper = ObjectMapper()     .enable(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES)     .registerModule(KotlinModule())       val person: Person = mapper.readValue(json, Person::class.java) 

回答1:

Solution with mix-in annotations

You could use mix-in annotations. It's a great alternative when modifying the classes is not an option. You can think of it as kind of aspect-oriented way of adding more annotations during runtime, to augment statically defined ones.

Assuming that your Person class is defined as follows:

public class Person {      private final String firstName;     private final String lastName;     private final int age;      public Person(String firstName, String lastName, int age) {         this.firstName = firstName;         this.lastName = lastName;         this.age = age;     }      // Getters omitted } 

First define a mix-in annotation abstract class:

public abstract class PersonMixIn {      PersonMixIn(@JsonProperty("firstName") String firstName,                 @JsonProperty("lastName") String lastName,                 @JsonProperty("age") int age) {     } } 

Then configure ObjectMapper to use the defined class as a mix-in for your POJO:

ObjectMapper mapper = new ObjectMapper(); mapper.enable(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES); mapper.addMixIn(Person.class, PersonMixIn.class); 

And deserialize the JSON:

String json = "{firstName: \"Foo\", lastName: \"Bar\", age: 30}"; Person person = mapper.readValue(json, Person.class); 

回答2:

Since there is no default constructor, jackson or gson want create instance by there own. you should tell to the API how to create such instance by providing custom deserialize.

here an snippet code

public class PersonDeserializer extends StdDeserializer<Person> {      public PersonDeserializer() {         super(Person.class);     }       @Override     public Person deserialize(JsonParser jp, DeserializationContext ctxt)              throws IOException, JsonProcessingException {         try {             final JsonNode node = jp.getCodec().readTree(jp);             final ObjectMapper mapper = new ObjectMapper();             final Person person = (Person) mapper.readValue(node.toString(),                     Person.class);             return person;         } catch (final Exception e) {             throw new IOException(e);         }     } } 

Then register simple module as to handle your type

final ObjectMapper mapper = jacksonBuilder().build(); SimpleModule module = new SimpleModule(); module.addDeserializer(Person.class, new PersonDeserializer()); 

回答3:

Jackson provides the module jackson-modules-java8 for solve your problem.

You must built your ObjectMapper as following:

ObjectMapper mapper = new ObjectMapper()         .enable(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES)         .registerModule(new ParameterNamesModule(JsonCreator.Mode.PROPERTIES)); 

You must add -parameters as compiler argument.

Example for maven:

 <plugin>        <groupId>org.apache.maven.plugins</groupId>        <artifactId>maven-compiler-plugin</artifactId>        <version>3.5.1</version>        <configuration>            <!--somecode-->             <compilerArgument>-parameters</compilerArgument>         </configuration>  </plugin> 

For gradle:

compileJava {   options.compilerArgs << "-parameters" } 

文章来源: Jackson, deserialize class with private fields and arg-constructor without annotations