How to have hibernate use String.intern on attributes

Question

For some entities we need to keep loads (thousands) of detached enties permanently in memory. Many of their attributes are from a limited set of strings (though not limited enough to put it into an enumeration). Is it possible to have hibernate use String.intern for those attributes to save space?

Ideally that should work via an annotation I could put on each of those attributes, or something easily changeable, without confusing the source code too much by this implementation concern.

Answer 1

As you suggest yourself, it's perfectly doable with a JPA attribute converter. You could do it on a general level by using autoApply = true on the converter, or you could do it on a field by field level with the @Convert annotation.

import javax.persistence.AttributeConverter;
import javax.persistence.Converter;

@Converter(autoApply = true)
public class StringInternConverter implements AttributeConverter<String, String> {
    @Override
    public String convertToDatabaseColumn(String attribute) {
        return attribute;
    }

    @Override
    public String convertToEntityAttribute(String dbData) {
        return dbData != null? dbData.intern(): null;
    }
}

Tested with Hibernate 5.2.10 and works like a charm!

Answer 2

1) You can use property access for the critical properties and intern the strings in the setters:

public void setFoo(String foo) {
   this.foo = foo != null ? foo.intern() : null;
}

2) If the above solution is tedious (you may have lots of such String properties), then you could register a Hibernate interceptor and intern all of the String fields using reflection:

for (Field field : getDeclaredFields(entity)) {
    if (!isStaticOrFinal(field)) {
        field.setAccessible(true);
        Object value = field.get(entity);
        if (value instanceof String) {
            field.set(entity, ((String) value).intern());
        }
    }
}

private List<Field> getDeclaredFields(Object object) {
    List<Field> result = new ArrayList<Field>(Arrays.asList(object.getClass().getDeclaredFields()));
    for (Class<?> superclass = object.getClass().getSuperclass(); superclass != null; superclass = superclass.getSuperclass()) {
        result.addAll(Arrays.asList(superclass.getDeclaredFields()));
    }
    return result;
}

private boolean isStaticOrFinal(Field field) {
    return ((Modifier.STATIC | Modifier.FINAL) & field.getModifiers()) != 0;
}

You can execute this in the onSave and onLoad interceptor methods.