new icon example borderfactory java hibernate enums orm

example - my icon java



Asignación de enumeración a una tabla con anotación de hibernación (5)

Tengo una tabla DEAL y una tabla DEAL_TYPE. Me gustaría mapear este código:

public class Deal { DealType type; } public enum DealType { BASE("Base"), EXTRA("Extra"); }

El problema es que los datos ya existen en la base de datos. Y estoy teniendo dificultades para asignar las clases a la base de datos.

La base de datos se ve algo así:

TABLE DEAL { Long id; Long typeId; } TABLE DEAL_TYPE { Long id; String text; }

Sé que podría usar una relación simple @OneToMany de acuerdo a trato, pero preferiría usar una enumeración. es posible?

Casi lo tengo funcionando usando un tipo EnumType.ORDINAL. Pero desafortunadamente, mis ID en la tabla de tipo de transacción no son secuenciales, y no comienzan en 1.

¿Alguna sugerencia?


Aunque lejos de ser ideal, mi solución a este problema era usar EnumStringType y una vista actualizable desnormalizada.


He creado una clase similar como la sugerida por hibernación solo que es configurable y no hay necesidad de crear un nuevo tipo solo para esta persistencia.

Puede ser utilizado como

@Type(type = "ro.raisercostin.hibernate.EnumUserType", parameters = @Parameter(name = "type", value = "DealType")) DealType dealType;

Agregué una implementación de ParameterizedType para admitir el parámetro pasado.

public class EnumUserType implements UserType, ParameterizedType { private static final int[] SQL_TYPES = { Types.VARCHAR }; private Class clazz = null; public EnumUserType() { } @Override public void setParameterValues(Properties parameters) { String className = (String) parameters.get("type"); try { this.clazz = Class.forName(className); } catch (ClassNotFoundException e) { throw new RuntimeException("Couldn''t get the class for name [" + className + "].", e); } } public int[] sqlTypes() { return SQL_TYPES; } public Class returnedClass() { return clazz; } public Object nullSafeGet(ResultSet resultSet, String[] names, Object owner) throws HibernateException, SQLException { String name = resultSet.getString(names[0]); Object result = null; if (!resultSet.wasNull()) { result = Enum.valueOf(clazz, name); } return result; } public void nullSafeSet(PreparedStatement preparedStatement, Object value, int index) throws HibernateException, SQLException { if (null == value) { preparedStatement.setNull(index, Types.VARCHAR); } else { preparedStatement.setString(index, ((Enum) value).name()); } } public Object deepCopy(Object value) throws HibernateException { return value; } public boolean isMutable() { return false; } public Object assemble(Serializable cached, Object owner) throws HibernateException { return cached; } public Serializable disassemble(Object value) throws HibernateException { return (Serializable) value; } public Object replace(Object original, Object target, Object owner) throws HibernateException { return original; } public int hashCode(Object x) throws HibernateException { return x.hashCode(); } public boolean equals(Object x, Object y) throws HibernateException { if (x == y) { return true; } if ((null == x) || (null == y)) { return false; } return x.equals(y); } }


Hibernate es algo terrible en Enums. Es una extraña falla de un ORM por lo demás bastante bueno. La forma "más fácil" de solucionarlo es declarar a su Enum un tipo de hibernación personalizado. Afortunadamente, Hibernate escribió una implementación de ejemplo que puede incluir en su aplicación:

http://www.hibernate.org/265.html

Incluso incluyen instrucciones sobre cómo usarlo. Este es el patrón que utilizo cuando termino con la necesidad de persistir las enumeraciones.


Podría anotar la enumeración con @Entity y usar un tuplizer de custoumn para crear las instancias de la enumeración con Enum.valueOf

La declaración de enumeración se ve entonces como:

@Entity @Table(name = "node_interface_type") @Tuplizer(impl = EnumTuplizer.class) public enum Type { WIRED, WIRELESS, WIRELESS_SENSOR_NODE; @Id public String name = toString(); }

Y el Tuplizer es:

public class EnumTuplizer extends PojoEntityTuplizer { public EnumTuplizer(EntityMetamodel entityMetamodel, PersistentClass mappedEntity) { super(entityMetamodel, mappedEntity); } @Override protected Instantiator buildInstantiator(final PersistentClass persistentClass) { return new Instantiator() { @Override public Object instantiate(Serializable id) { try { return Enum.valueOf( (Class) persistentClass.getClass().getClassLoader().loadClass(persistentClass.getClassName()), (String) id ); } catch (ClassNotFoundException e) { throw new AssertionError(e); } } @Override public Object instantiate() { throw new UnsupportedOperationException(); } @Override public boolean isInstance(Object object) { throw new UnsupportedOperationException(); } }; } }


Si desea utilizar la entidad solo de lectura, puede usar @Formula y @Enumerated . Intenta algo como:

@Entity public class Deal { @Formula("(select text from DEAL_TYPE dt where dt.id = typeId)") @Enumerated(EnumType.STRING) DealType type; }