How can I store enums with fixed values in play

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; 

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

1. 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;
       }
   }
   

2. 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.