Java DTO类设计是否可以部分持久化和序列化？

Question

I have a complex Java DTO (Data Transfer Object pattern) class with hundreds of properties. For illustration purposes consider just two

class PointlessExample {
    private int x;
    private int y;
    public ... // getters/setters
}

What is the best way to refactor this into two classes so that some subset of attributes ('x') can be persisted separately from the full class, and serialized either separately or together with the full class?

My simple idea was:

@Entity 
class PointlessBase {
    private int x;
    ...
}
class PointlessExample extends PointlessBase {
    private int y;
    ...
}

The problem however, is that objects can start their lifecyle as the full class ( PointlessExample ), and although they would always be persisted as PointlessBase , I have use-cases to serialize and deserialize as either the full or the partial object (including, deserialize a partial object from a full serialized object). There is no easy way to serialize (through Jackson) or persist (through Hibernate) only the PointlessBase fields belonging to a PointlessExample object. Or is there?

Answer 1

DTO is generally a painful concept .
Your idea of separating properties using inheritance sounds fine.
If I understand your requirements, you need something like this:

---------------------------------------
| Class            | JSON | Hibernate |
---------------------------------------
| PointlessBase    | YES  | YES       |
---------------------------------------
| PointlessExample | YES  | NO        |
---------------------------------------

In Jackson you can customise process of serialization of deserialization and generally ignore properties which comes from given type or by other filters. For example see my simple class filter:

class ClassIgnoranceIntrospector extends JacksonAnnotationIntrospector {

    private final Class<?> clazz;

    ClassIgnoranceIntrospector(Class<?> clazz) {
        this.clazz = clazz;
    }

    public boolean hasIgnoreMarker(AnnotatedMember m) {
        return m.getDeclaringClass() != clazz;
    }
}

Below you can find how to use it:

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;

import java.util.Arrays;
import java.util.List;

public class Main {

    public static void main(String[] args) throws Exception {
        ObjectMapper baseMapper = new ObjectMapper();
        baseMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        baseMapper.setAnnotationIntrospector(new ClassIgnoranceIntrospector(PointlessBase.class));

        ObjectMapper extendedMapper = new ObjectMapper();
        extendedMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        extendedMapper.setAnnotationIntrospector(new ClassIgnoranceIntrospector(PointlessExample.class));

        List<PointlessBase> list = Arrays.asList(new PointlessBase(), new PointlessExample());
        for (PointlessBase item : list) {
            System.out.println("Base only mapper for class " + item.getClass().getSimpleName() + " " + baseMapper.writeValueAsString(item));
            System.out.println("Extended only mapper for class " + item.getClass().getSimpleName() + " " + extendedMapper.writeValueAsString(item));
        }
    }
}

Above prints:

Base only mapper for class PointlessBase {"x":10}
Extended only mapper for class PointlessBase {}
Base only mapper for class PointlessExample {"x":10}
Extended only mapper for class PointlessExample {"y":11}

You can use different instance of ObjectMapper to serialize specific set of properties. If you wont to serialize/deserialize all properties use default ObjectMapper .

Another idea is using Jackson JSON Views . For more information how to handle properly inheritance with Jackson read Inheritance with Jackson .