How can I store enums with fixed values in play

Question

I'm trying to convert a grails-project to the playframework. In Grails you can define an id so the the id will be stored in the database (see Enhanced Enum Support in the release notes). I saw a similar question, but with no acceptable solution. If I change the type the CRUD-module get a problem, because the information that a Enum should be shown is lost.

So I wonder if there exists a nice solution with play, which based on Hibernate. Perhaps with hacking the JPAPlugin?

[Update 1] I started to try the second solution with @type-annotation. Unfortunately this become broken with hibernate 3.6 (which is used by play 1.2.2). TypeFactory.basic() is not available any more. But following the documentation I can't find a work around.

[Update 2] There was a solution for hibernate 3.6.1, but it's really clumsy to define the type at each usage of enum.

@Type(type="hibernatehelper.GenericEnumUserType", 
            parameters= {
            @Parameter(
                    name  = "enumClass",                      
                    value = "models.Geschlecht"),
        })
public Geschlecht geschlecht = Geschlecht.WEIBLICH;

Why is that solution not acceptable? What's exactly the problem you see in CRUD? — Pere Villega, Jul 21 '11 at 10:59
well the CRUD-Module assume it's an int and so it only shows a file for an int and not a combobox with appropriate values. — niels, Jul 21 '11 at 11:50
You can use code similar to http://stackoverflow.com/questions/2751733/map-enum-in-jpa-with-fixed-values/2751896#2751896. I think it's obvious that the CRUD-module must fail, because it looks on the type of the attribute not of the parameter and return type of the getter and setter. — niels, Jul 21 '11 at 13:36

score 4 · Accepted Answer · edited May 23 '17 at 12:08

Not sure if it's really work, but one possible solution could be the following:

Wrote a generic type mapper:

package hibernatehelper;

import java.io.Serializable;
import java.lang.reflect.Method;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
import org.hibernate.HibernateException;
import org.hibernate.type.AbstractSingleColumnStandardBasicType;
import org.hibernate.type.TypeResolver;
import org.hibernate.usertype.ParameterizedType;
import org.hibernate.usertype.UserType;


public class GenericEnumUserType implements UserType, ParameterizedType {

    private Class <? extends Enum> enumClass;

    private Class <?> identifierType;

    private Method identifierMethod;

    private Method valueOfMethod;

    private static final String defaultIdentifierMethodName = "getId";

    private static final String defaultValueOfMethodName = "parseId";

    private AbstractSingleColumnStandardBasicType type;

    private int[] sqlTypes;

    @Override
    public void setParameterValues(Properties parameters) {
        String enumClassName = parameters.getProperty("enumClass");
        try {
            enumClass = Class.forName(enumClassName).asSubclass(Enum.class);
        } catch (ClassNotFoundException exception) {
            throw new HibernateException("Enum class not found", exception);
        }

        String identifierMethodName =
                parameters.getProperty("identifierMethod",
                        defaultIdentifierMethodName);

        try {
            identifierMethod =
                    enumClass.getMethod(identifierMethodName, new Class[0]);
            identifierType = identifierMethod.getReturnType();
        } catch (Exception exception) {
            throw new HibernateException("Failed to optain identifier method",
                    exception);
        }

        TypeResolver tr = new TypeResolver();
        type =
                (AbstractSingleColumnStandardBasicType) tr.basic(identifierType
                        .getName());
        if (type == null) {
            throw new HibernateException("Unsupported identifier type "
                    + identifierType.getName());
        }
        sqlTypes = new int[] {type.sqlType()};

        String valueOfMethodName = parameters.getProperty("valueOfMethod",
                defaultValueOfMethodName);
        try {
            valueOfMethod = enumClass.getMethod(valueOfMethodName,
                            new Class[] {identifierType});
        } catch (Exception exception) {
            throw new HibernateException("Failed to optain valueOf method",
                    exception);
        }
    }

    @Override
    public Class returnedClass() {
        return enumClass;
    }

    @Override
    public Object nullSafeGet(ResultSet rs, String[] names, Object owner)
            throws HibernateException, SQLException {
        Object identifier = type.get(rs, names[0]);
        if (identifier == null) {
            return null;
        }

        if (valueOfMethod == null) {

        }

        try {
            return valueOfMethod.invoke(enumClass, new Object[] {identifier});
        } catch (Exception exception) {
            throw new HibernateException(
                    "Exception while invoking valueOfMethod of enumeration class: ",
                    exception);
        }
    }

    public void nullSafeSet(PreparedStatement st, Object value, int index)
            throws HibernateException, SQLException {
        try {
            Object identifier =
                    value != null ? identifierMethod.invoke(value,
                            new Object[0]) : null;
            st.setObject(index, identifier);
        } catch (Exception exception) {
            throw new HibernateException(
                    "Exception while invoking identifierMethod of enumeration class: ",
                    exception);

        }
    }

    @Override
    public int[] sqlTypes() {
        return sqlTypes;
    }

    @Override
    public Object assemble(Serializable cached, Object owner)
            throws HibernateException {
        return cached;
    }

    @Override
    public Object deepCopy(Object value) throws HibernateException {
        return value;
    }

    @Override
    public Serializable disassemble(Object value) throws HibernateException {
        return (Serializable) value;
    }

    @Override
    public boolean equals(Object x, Object y) throws HibernateException {
        return x == y;
    }

    @Override
    public int hashCode(Object x) throws HibernateException {
        return x.hashCode();
    }

    public boolean isMutable() {
        return false;
    }

    public Object replace(Object original, Object target, Object owner)
            throws HibernateException {
        return original;
    }
}

Wrote an Enhancer which look for every attribute which is from Type Enum and look if this type has a static-method parseId. than add the following annotation with javaassist:

@Type(type="hibernatehelper.GenericEnumUserType", 
    parameters= {
    @Parameter(
            name  = "enumClass",                      
            value = "<fullqualified classname of the enum class>"),
})

But I'm unsure if this not to much magic for such a problem. Perhaps someone can give me an advice.

The same approach does not work with spring boot 2 jars. Any other approach to use Enum ordinals? — Abhi.G, Nov 21 '18 at 09:56

How can I store enums with fixed values in play

1 Answers1