Hibernate-Lookup-Tabelle mit Enum

Question

Ich versuche derzeit Hibernate zu lernen und habe ein Problem festgestellt, das aus Sicht von OOP und DB vernünftig aussieht, und dennoch kann ich keine Lösung finden.

Mein Java-Teil sieht mehr oder weniger wie folgt aus:

@Entity 
@Table (name = "Vehicles") 
class Vehicle { 
    @Id 
    @Column (name = "UUID") 
    UUID id; 
    VehicleType type 

    (getters, setters, other values, etc.) 
} 

enum VehicleType { 
    TRUCK, 
    TRAILER, 
    OTHER; 
} 

und mein DB Teil hat zwei Tabellen - eine für Fahrzeuge und Lookup-Tabelle für Fahrzeugtypen:

Fahrzeuge

UUID VARCHAR (PK) 
vehicle_type_id INT (FK to VehicleTypes) 

VehicleTypes

vehicle_type_id INT (PK) 
vehicle_type VARCHAR 

Meine Frage ist, ist es möglich, dies in der dargestellten Weise zu arrangieren? Wenn es möglich ist, wie man es implementiert (Anmerkungen, etc.). Wenn nicht, was ist der beste Weg, eine ähnliche Struktur zu implementieren?

----- ----- EDIT

habe ich es geschafft, mein Ziel zu erreichen (mehr oder weniger) solution von Anthony Patricio beschrieben ist.

DB Teil gleich geblieben, während Java-Teil wie folgt aussieht:

@Entity 
@Table (name = "Vehicles") 
class Vehicle { 
    @Id 
    @Column (name = "UUID") 
    UUID id; 
    @Column (name = "vehicle_type_id") 
    @Type (type = "VehicleEnumUserType") 
    VehicleType type 

    (getters, setters, other values, etc.) 
} 

enum VehicleType { 
    TRUCK(1), 
    TRAILER(2), 
    OTHER(0); 

    private int value; 
    VehicleType(int value){ 
     this.value = value; 
    } 

    public int getValue() { 
     return value; 
    } 

    public static VehicleType fromValue(int value){ 
     for (VehicleType type : VehicleType.values()){ 
      if (value == type.value) return type; 
     } 
     throw new IllegalArgumentException("Value not mapped by VehicleType enum"); 
    } 
} 

VehicleEnumUserType implements UserType{ 
    private static final int[] SQL_TYPES = {Types.INTEGER}; 

    public Object nullSafeGet(ResultSet resultSet, String[] strings, SharedSessionContractImplementor sharedSessionContractImplementor, Object o) 
      throws HibernateException, SQLException { 
     int number = resultSet.getInt(strings[0]); 
     return resultSet.wasNull() ? null : VehicleType.fromValue(number); 
    } 

    public void nullSafeSet(PreparedStatement preparedStatement, Object o, int i, SharedSessionContractImplementor sharedSessionContractImplementor) 
      throws HibernateException, SQLException { 
     if (o == null){ 
      preparedStatement.setNull(i, Types.INTEGER); 
     } else { 
      preparedStatement.setInt(i, ((VehicleType)o).getValue()); 
     } 
    } 
    // other mandatory methods required by UserType interface 
} 

Diese Lösung paßt meine Anforderungen - Fahrzeugtyp beschränkt ist, sowohl auf der Seite DB (durch Lookup-Tabelle Einschränkung) und auf Java-Seite (von Fahrzeugtyp enum). Darüber hinaus wird der Fahrzeugtyp als Ganzzahl gespeichert, wodurch der zum Speichern von Daten erforderliche Speicherplatz reduziert wird. Last but not least, erlaubt diese Lösung eine ziemlich sichere Hinzufügung neuer Fahrzeugtypen (z. B. Probleme im Zusammenhang mit EnumType.ORDINAL).

Hoffnung jemand findet diese Lösung nützlich.

Answer 1

können Sie „Aufzählungs“ Anmerkung

@Enumerated(EnumType.STRING) 
VehicleType type