hibernate 实体上的参数化构造函数

Question

TL;DR

Is there any way to cleanly pass some arguments to a hibernate-instantiated object post-load?

What I have

@Entity
public class MyEntity {
    @Lob
    private String mapAsJson;

    @Transient
    private Map<Long, Double> map = new HashMap<>();

    // Getters, null-checks, and all that. Always keeping these two in sync, or at least before it persists
}

What I want

@Entity
public class MyEntity {
    @Embedded
    private MyEmbedded<Long, Double> embeddedMap = new MyEmbedded<>();
}

@Embeddable
public class MyEmbedded<K, V> {
    @Lob
    private String mapAsJson;
    @Transient
    private final Map<K, V> map = new HashMap<>();

    @PreUpdate @PrePersist
    private void storeAsJson() {
        // JsonUtil encapsulates com.fasterxml.jackson.databind.ObjectMapper logic
        mapAsJson = JsonUtil.toString(map);
    }

    @PostLoad
    private void loadFromJson() {
        map.clear();
        if (mapAsJson != null) 
            // JsonUtil encapsulates com.fasterxml.jackson.databind.ObjectMapper logic
            map.putAll(JsonUtil.fromString(mapAsJson, HashMap.class));
    }
}

Why do I want it

Just to nicely encapsulate the hydration to/from this working map object. If I were to have 2 more other fields like this, it would be a lot of repeated code. This is a very specific example, of course, but it could be extended to other objects other than map.

Why it doesn't work

This JsonUtil.fromString(mapAsJson, HashMap.class) is basically guessing the types. It currently returns a map of <String, Integer> , but I'm actually needing Double .

Possible failed solution #1

This of course does not work because hibernate has no idea what my parameters for the embedded object are.

@Entity
public class MyEntity {
    @Embedded
    private MyEmbedded<Long, Double> embeddedMap = new MyEmbedded<>(Long.class, Double.class);
}

@Embeddable
public class MyEmbedded<K, V> {
    @NotNull
    private Class<K> keyClass;
    @NotNull
    private Class<V> valClass;

    protected MyEmbedded() {

    }

    public MyEmbedded(Class<K> keyClass, Class<V> valClass) {
        this.keyClass = keyClass;
        this.valClass = valClass;
    }

    // [...]

    @PostLoad
    private void loadFromJson() {
        map.clear();
        if (mapAsJson != null)
            // NOTICE THIS DIFFERENT LINE
            map.putAll(JsonUtil.fromString(mapAsJson, HashMap.class, keyClass, valClass));
    }
}

Possible solution #2

@Embeddable
public class MyEmbedded<K, V> {
    @NotNull
    private Class<K> keyClass;
    @NotNull
    private Class<V> valClass;

    // [...]

    // Call this in the entity once, on the embedded. Maybe on @PostLoad?
    public MyEmbedded<K, V> init(Class<K> keyClass, Class<V> valClass) {
        this.keyClass = keyClass;
        this.valClass = valClass;
    }
}

Answer 1

Due to you further specifying that JsonUtil is an own class, I would suggest the following signature for JsonUtil.fromString :

public static <K, V> Map<K, V> fromString(String json, Class<K> keyClass,
        Class<V> valueClass, @SuppressWarnings("rawtypes") Class<? extends Map> mapClass) {
// ...

This way, your returned map will be inferred with the correct types, and you can use your 'What I want'-variant. You can have differnent named signatures for other, less bulky access, that delegates to that method:

public static <V> Map<V> fromStringLongKey(String json,
        Class<V> valueClass, @SuppressWarnings("rawtypes") Class<? extends Map> mapClass) {
    return fromString(json, Long.class, valueClass, mapClass);
}
//...