Serialization of Transient fields with public getters not happening

[rohitbansal03]

In reference to: #296

Recently I upgraded fasterxml version from 2.0.0 to 2.3.3 and with this, facing a major impacting change throughout the application. The @transient fields with public getters were serialized before, but now none of these is being serialized.

With above change, I would have to create explicitly @JsonProperty over getters of each and every transient field to be able to serialize as before. Looking for a better approach or some flag in SerializationFeature to be able to do this.

Any help appreciated!

[cowtowncoder]

Can you share a test case or sample code? Whether field is transient should not directly affect use of getters or setters, unless there is a bug somewhere.

[rohitbansal03]

Here is the complete JUnit test for the same:

We have a custom object mapper, through which I am serializing the Person POJO through mixins.
'age' is a Transient annotated field which is not serialized by default though we have public getters and setters for the same.

However, as said above, I would have to explicitly define for Transient fields in mixins to achieve the same. This was unlike the previous version of fasterxml as mentioned. Any better object or some flag through which I could control the behavior would be very helpful.

/* TestTransientFieldsSerialization.java */

package com.test.fasterxml;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.junit.Test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.test.fasterxml.mixin.PersonMixin;
import com.test.fasterxml.pojo.Person;

public class TestTransientFieldsSerialization {

    @Test
    public void testSerialization() throws IOException {

        Map<Class<?>, Class<?>> mixinMap = new HashMap<Class<?>, Class<?>>();
        mixinMap.put(Person.class, PersonMixin.class);

        Person person = new Person();
        person.setAge(24);
        person.setName("Rohit");

        System.out.println(serializeJson(person, mixinMap));
    }

    private static String serializeJson(Object object, Map<Class<?>, Class<?>> classMaps) throws IOException {
        ObjectMapper mapper = new CustomTestObjectMapper(classMaps);
        return mapper.writeValueAsString(object);
    }

}

/* CustomTestObjectMapper.java */

package com.test.fasterxml;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Map;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.hibernate4.Hibernate4Module;

public class CustomTestObjectMapper extends ObjectMapper{

    private static final long serialVersionUID = 1L;

    public CustomTestObjectMapper(){
        this(null);
    }

    public CustomTestObjectMapper(Map<Class<?>, Class<?>> classMaps){
        DateFormat formatter = new SimpleDateFormat("MM/dd/yyyy");
        setDateFormat(formatter);
        if(classMaps != null) {
            setMixInAnnotations(classMaps);
        }
        Hibernate4Module hibernateModule = new Hibernate4Module();
        hibernateModule.configure(Hibernate4Module.Feature.FORCE_LAZY_LOADING, true);
        registerModule(hibernateModule);
    }

}

/* Person.java */

package com.test.fasterxml.pojo;

import javax.persistence.Transient;

public class Person {

    @Transient
    private int age;

    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

package com.test.fasterxml.mixin;

/* PersonMixin.java */

public interface PersonMixin {

    /* Commenting this would not allow transient annotated field to be serialized */

    // @JsonProperty
    // public int getAge(); 

}

Output on uncommenting the lines from PersonMixin (i.e. explicitly asking to serialize transient fields)
{"name":"Rohit","age":24}

And, after commenting the lines:
{"name":"Rohit"}

[rohitbansal03]

Tested the above with older pom versions of fasterxml - 2.0.0 and updated versions on 2.3.3
In older version, the transient annotated fields were also serialized but in updated jars this feature is removed/changed. Hence facing issues with it.

com.fasterxml.jackson.core
jackson-annotations
2.0.0

com.fasterxml.jackson.core
jackson-core
2.0.0

com.fasterxml.jackson.core
jackson-databind
2.0.0

com.fasterxml.jackson.datatype
jackson-datatype-hibernate4
2.2.0

[cowtowncoder]

Oh, so this is not Java transient keyword, but Hibernate/JPA @Transient annotation, handling of which is done by Jackson hibernate module (https://github.com/FasterXML/jackson-datatype-hibernate).

So the issue was that versions prior to 2.2 were not handling @Transient, which with 2.2 is taken to mean "do not serialize" (similar to how JDK considered transient keyword for JDK serialization).

However, if you do not want it to be used, you need to disable feature on hibernate module:

module.disable(Hibernate4Module.Feature.USE_TRANSIENT_ANNOTATION);

[ssunzulily]

The choice for Jackson to even care about hibernate's annotation is beyond me. Are these guys high or something?

[cowtowncoder]

@ssunzulily perhaps it could be taken as a compliment that Jackson would be aware of various annotations of other frameworks :)

[ssunzulily]

@cowtowncoder This kind of tightly couple yet weakly documented things with questionable value? No.

[cowtowncoder]

@ssunzulily Um, I am not sure I get your meaning here. No, jackson-databind does not read such annotations. Optional jackson-datatype-hibernate module does. Latter makes sense. Someone perhaps thought former does; not so.

[ssunzulily]

@cowtowncoder I apologize if that is the case. I was using dropwizard. I guess that included the optional module