使用Hibernate从Postgres到Java的枚举

Question

我想要在数据库上有一个枚举类型并将其转换为java，我写了一个EnumUserType类来执行转换，但它不能识别PGobject类。

public Object nullSafeGet(ResultSet rs, String[] names, SessionImplementor si, Object owner) 
     throws HibernateException, SQLException { 
    Object object = rs.getObject(names[0]); 
    if (rs.wasNull()) { 
     return null; 
    } 

    if (object instanceof PGobject) { 
     //code doesn't reach this line 
    } 

    log.info(object.getClass()); // prints class org.postgresql.util.PGobject 
    return null; 
} 

我检查了，我有完全相同的postgresql驱动程序版本。 我看到这篇文章：Java enum with Eclipselink。这是一个我也会尝试的解决方案，但我的主要问题是：显然它是同一个班级，为什么它不被认可？我可以拥有两个具有相同名称和包的不同类吗？如果我仍然需要在Postgres中使用枚举，我该如何解决它以正确映射到我的Java枚举？

编辑：

我试图做一个：

PGobject pg = (PGobject) object; 

，它抛出一个类转换异常：

org.postgresql.util.PGobject cannot be cast to org.postgresql.util.PGobject 

感谢

Answer 1

我用一个泛型类使用作为映射枚举的类型。然后，可以使用它映射所有的枚举。

类是这样的：

public class GenericEnumUserType implements UserType, ParameterizedType { 

private static final String DEFAULT_IDENTIFIER_METHOD_NAME = "name"; 
private static final String DEFAULT_VALUE_OF_METHOD_NAME = "valueOf"; 

private Class enumClass; 
private Class identifierType; 
private Method identifierMethod; 
private Method valueOfMethod; 
private NullableType type; 
private int[] sqlTypes; 

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

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

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

    type = (NullableType) TypeFactory.basic(identifierType.getName()); 

    if (type == null) { 
     throw new HibernateException("Unsupported identifier type " + identifierType.getName()); 
    } 

    sqlTypes = new int[] { type.sqlType() }; 

    String valueOfMethodName = parameters.getProperty("valueOfMethod", DEFAULT_VALUE_OF_METHOD_NAME); 

    try { 
     valueOfMethod = enumClass.getMethod(valueOfMethodName, new Class[] { identifierType }); 
    } catch (Exception e) { 
     throw new HibernateException("Failed to obtain valueOf method", e); 
    } 
} 

@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 (rs.wasNull()) { 
     return null; 
    } 

    try { 
     return valueOfMethod.invoke(enumClass, new Object[] { identifier }); 
    } catch (Exception e) { 
     throw new HibernateException("Exception while invoking " + "valueOf method " + valueOfMethod.getName() 
       + " of enumeration class " + enumClass, e); 
    } 
} 

@Override 
public void nullSafeSet(PreparedStatement st, Object value, int index) throws HibernateException, SQLException { 
    try { 
     if (value == null) { 
      st.setNull(index, type.sqlType()); 
     } else { 
      Object identifier = identifierMethod.invoke(value, new Object[0]); 
      type.set(st, identifier, index); 
     } 
    } catch (Exception e) { 
     throw new HibernateException("Exception while invoking identifierMethod " + identifierMethod.getName() 
       + " of enumeration class " + enumClass, e); 
    } 
} 

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

@Override 
public boolean isMutable() { 
    return false; 
} 

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

Enum类应该是这样的：

public enum AccountStatus { 
ACTIVE(1), BLOCKED(2), DELETED(3); 

private AccountStatus(int id) { 
    this.id = id; 
} 

private int id; 

public int getId() { 
    return id; 
} 

public void setId(int id) { 
    this.id = id; 
} 

public static AccountStatus valueOf(int id) { 
    switch (id) { 
    case 1: 
     return ACTIVE; 
    case 2: 
     return BLOCKED; 
    case 3: 
     return DELETED; 
    default: 
     throw new IllegalArgumentException(); 
    } 
}} 

静态方法 “的valueOf” 有必要从存储在数据库中的Java对象ID转换。

然后，Hibernate映射是这样的：

<hibernate-mapping> 
<typedef class="path.to.GenericEnumUserType" name="accountStatusType"> 
    <param name="enumClassName">com.systemonenoc.hermes.ratingengine.persistence.constants.AccountStatus</param> 
    <param name="identifierMethod">getId</param> 
</typedef> 
<class name="package.to.class.with.enum.Account" table="account" schema="public"> 
    <property name="accountStatus" type="accountStatusType" column="account_status" not-null="true" /> 
[...] 
</hibernate-mapping> 

所以，你必须声明为一个类型的类GenericEnumUserType用typedef和方法获取枚举的ID（在这种情况下，的getId（ ））。在你的数据库中，将把id作为值存储在一个整数列中，而在java中你将拥有枚举对象。