So speichern Sie ein Array von Enum im Ruhezustand

Question

Ich versuche, ein Array von Enum zu erhalten, mit Hibernate. Es ist wichtig zu beachten, dass ich, wenn es möglich ist, lieber keine Sammlung verwenden möchte. Die Antworten, die ich bisher online gefunden habe, dienen zum Speichern von Sammlungen, nicht von Arrays.

Ich bekomme einen Laufzeitfehler, der sich über das Fehlen einer @OrderColumn oder @IndexColumn beschwert. Ich möchte nicht, dass das Array alphabetisch sortiert wird. Ich möchte, dass es in der gleichen Reihenfolge zurückgegeben wird.

Die enums sind buchstäblich so einfach, wie Sie fragen könnten, aber die Enum.name() sind nicht in alphabetischer Reihenfolge, so dass es keine natürliche "Order" -Spalte zu sein scheint.

@Embeddable 
public enum SudokuPossibleValueState { 
            UNDEFINED, UNKNOWN, IMPOSSIBLE, POSSIBLE, COMMITTED, AS_PUBLISHED; 

    public String toString() { 
     return name().toLowerCase(); 
    } 
} 

Per Definition verwende ich die aktuelle Position in der Anordnung, die Anzahl, um anzuzeigen, dass ich unter Berücksichtigung bin und die ENUM definiert den Zustand der Auswertung für diese Nummer. Zum Beispiel könnte ein typisches Array ...

[0] = UNDEFINED, 
[1] = UNDEFINED, 
[2] = POSSIBLE, 
[3] = POSSIBLE, 
[4] = UNKNOWN, 
[5] = UNKNOWN, 
[6] = UNKNOWN, 
[7] = IMPOSSIBLE, 
[8] = IMPOSSIBLE, 
[9] = IMPOSSIBLE. 

Aber die Herausforderung, die mir begegnet ist, ist, dass alle Beispiele, die ich online finden kann, und die Hibernate Dokumentation, scheinen nur die Situation ansprechen, wo Sie sind Verwenden einer Java-Sammlung; was ich nicht versuche zu tun.

@Entity 
@Table(name = "SudokuPossibleValues") 
public class SudokuPossibleValuesModel { 
    public static final int NUMBER_OF_POSSIBLE_VALUES_PLUS_ONE = 10; 

    @Id 
    @GeneratedValue 
    private long possibleValuesID; 

    @ElementCollection 
    @Enumerated(EnumType.STRING) 
    private SudokuPossibleValueState stateValues[] = new SudokuPossibleValueState[NUMBER_OF_POSSIBLE_VALUES_PLUS_ONE]; 
    ... 
} 

Answer 1

kam ich mit einer Antwort, aber mir bitte sagen, gibt es eine bessere Art und Weise innerhalb entweder JPA oder Hibernate, dies zu tun.

@Entity 
@Table(name = "POSSIBLE_VALUES") 
public class PossibleValues { 

    @SuppressWarnings("unused") 
    private static final long serialVersionUID     = -1L;  
    public static final int NUMBER_OF_POSSIBLE_VALUES_PLUS_ONE = 10; 

    @Id 
    @GeneratedValue(generator = "possibleValuesID") 
    @GenericGenerator(name = "possibleValuesID", strategy = "increment") 
    @Column(name = "POSSIBLE_VALUES_ID") 
    private Long possibleValuesID; 

    @Transient 
    private SudokuPossibleValueState[] values = new SudokuPossibleValueState[NUMBER_OF_POSSIBLE_VALUES_PLUS_ONE]; 
    // Ugly, disgusting hack, to deal with getting an Enumerated collection in/out of JPA/Hibernate 
    @Enumerated(EnumType.STRING) 
    private SudokuPossibleValueState zero = SudokuPossibleValueState.UNDEFINED; 
    @Enumerated(EnumType.STRING) 
    private SudokuPossibleValueState one = SudokuPossibleValueState.UNDEFINED; 
    @Enumerated(EnumType.STRING) 
    private SudokuPossibleValueState two = SudokuPossibleValueState.UNDEFINED; 
    @Enumerated(EnumType.STRING) 
    private SudokuPossibleValueState three = SudokuPossibleValueState.UNDEFINED; 
    @Enumerated(EnumType.STRING) 
    private SudokuPossibleValueState four = SudokuPossibleValueState.UNDEFINED; 
    @Enumerated(EnumType.STRING) 
    private SudokuPossibleValueState five = SudokuPossibleValueState.UNDEFINED; 
    @Enumerated(EnumType.STRING) 
    private SudokuPossibleValueState six = SudokuPossibleValueState.UNDEFINED; 
    @Enumerated(EnumType.STRING) 
    private SudokuPossibleValueState seven = SudokuPossibleValueState.UNDEFINED; 
    @Enumerated(EnumType.STRING) 
    private SudokuPossibleValueState eight = SudokuPossibleValueState.UNDEFINED; 
    @Enumerated(EnumType.STRING) 
    private SudokuPossibleValueState nine = SudokuPossibleValueState.UNDEFINED; 

    // Ugly, disgusting hack, to deal with getting an Enumerated array in/out of JPA/Hibernate 
    public PossibleValues() { 
     values[0] = zero; 
     values[1] = one; 
     values[2] = two; 
     values[3] = three; 
     values[4] = four; 
     values[5] = five; 
     values[6] = six; 
     values[7] = seven; 
     values[8] = eight; 
     values[9] = nine; 
    } 

    // Ugly, disgusting hack, to deal with getting an Enumerated array in/out of JPA/Hibernate 
    protected void setPossibleValue(short possibleValue, SudokuPossibleValueState state) { 
     switch (possibleValue) { 
     case 0: values[possibleValue] = zero = state; break; 
     case 1: values[possibleValue] = one = state; break; 
     case 2: values[possibleValue] = two = state; break; 
     case 3: values[possibleValue] = three = state; break; 
     case 4: values[possibleValue] = four = state; break; 
     case 5: values[possibleValue] = five = state; break; 
     case 6: values[possibleValue] = six = state; break; 
     case 7: values[possibleValue] = seven = state; break; 
     case 8: values[possibleValue] = eight = state; break; 
     case 9: values[possibleValue] = nine = state; break; 
     default: throw new RuntimeException("Possible Value [" + possibleValue + "] is illegal"); 
     } 
    } 

    // Ugly, disgusting hack, to deal with getting an Enumerated array in/out of JPA/Hibernate 
    @PostLoad 
    protected void syncState() { 
     values[0] = zero; 
     values[1] = one; 
     values[2] = two; 
     values[3] = three; 
     values[4] = four; 
     values[5] = five; 
     values[6] = six; 
     values[7] = seven; 
     values[8] = eight; 
     values[9] = nine; 
    } 

    public Long getPossibleValuesID() { 
     return possibleValuesID; 
    } 

    @SuppressWarnings("unused") 
    private void setPossibleValuesID(Long possibleValuesID) { 
     this.possibleValuesID = possibleValuesID; 
    } 
}