example - my icon java

Asignación de enumeración a una tabla con anotación de hibernación

Question

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?

Answer 1

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

Answer 2

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);
}
}

Answer 3

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.

Answer 4

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();
}
};
}
}

Answer 5

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