Option 1 : Just annotate the getter method of the Foo1.class

@JsonProperty("comments")
        public List getComments() {
            List list = new ArrayList();
            list.add(comments);
            return list;
        }

 @JsonProperty("attachments")
        public List getAttachments() {
            List list = new ArrayList();
            list.add(attachments);
            return list;
        }


Foo1 foo1 = new Foo1(Long.valueOf(1),"a","aaa",true,"abc","def");
System.out.println(new ObjectMapper().writeValueAsString(foo1));
Foo2 foo2 = new ObjectMapper().convertValue(foo1, Foo2.class);
System.out.println(new ObjectMapper().writeValueAsString(foo2));

Option 2 : use jackson-custom-serialization

ObjectMapper mapper = new ObjectMapper();
SimpleModule simpleModule = new SimpleModule();
simpleModule.addSerializer(Foo1.class,new ListSerializer());
mapper.registerModule(simpleModule);


public class ListSerializer extends StdSerializer<Foo1> {

    public ListSerializer() {
        this(null);
    }

    protected ListSerializer(Class<Blah.Foo1> t) {
        super(t);
    }

    public void serialize(Blah.Foo1 foo1, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        jsonGenerator.writeStartObject();
        List list = new ArrayList();
        list.add(foo1.getComments());

        List list1 = new ArrayList();
        list1.add(foo1.getAttachments());

        jsonGenerator.writeObjectField("id",foo1.getId());
        jsonGenerator.writeObjectField("code",foo1.getCode());
        jsonGenerator.writeObjectField("name",foo1.getName());
        jsonGenerator.writeObjectField("rState",foo1.getrState());
        jsonGenerator.writeObjectField("comments",list);
        jsonGenerator.writeObjectField("attachments",list1);
        jsonGenerator.writeEndObject();
    }
}


Foo1 foo1 = new Foo1(Long.valueOf(1),"a","aaa",true,"abc","def");
System.out.println(mapper.writeValueAsString(foo1));
Foo2 foo2 = mapper.convertValue(foo1, Foo2.class);
System.out.println(new ObjectMapper().writeValueAsString(foo2));

There is no "better". There are practical differences. But first, both options use type casting, and this raises the question "how are these two considered alternatives at all?"

Casting will only work if some object passes the instanceof Map test (first option), or if o passes the instanceof String test (second option).

In other words, the answer depends on the runtime class of some object.

So either this will fail with a class cast exception:

Copy(Map<String, Object>) o;

Or this will fail with the same exception:

Copy(String) o 

Assuming the type checks will pass one way or the other, there are differences to be considered:

• If some object is compatible with Map<String, Object>, then casting should be preferred as it offers a performance advantage (considering objectMapper.convertValue as the alternative). In fact, readValue isn't even an option as the cast to string will fail.
• If some object is a String, then you have no choice but to call readValue, as you need to parse JSON.

As noted above, there's also objectMapper.convertValue, which in a smart way checks first instanceof before performing the conversion through JSON parsing. It's meant to convert objects from one type to another, if the two types have the same fields.