如何在休眠中存儲枚舉數組

Question

我想使用Hibernate持久化枚舉數組。值得注意的是，如果可能的話，我寧願不使用集合。到目前爲止我在網上找到的答案是存儲集合，而不是數組。

我收到一個運行時錯誤，抱怨缺少@OrderColumn或@IndexColumn。我不想按字母順序排列數組。我希望它以相同的順序返回。

枚舉的字面上儘可能簡單，但你可以要求，但Enum.name（）不是按字母順序，所以似乎沒有一個自然的「Order」列。

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

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

根據定義，我使用的實際位置的陣列中，以指示我正在考慮的數量，並且所述枚舉定義評價該數目的狀態。例如，一個典型的陣列可能是......

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

但我遇到的挑戰是，所有的，我可以在網上找到的例子，Hibernate文檔，似乎只是解決您身在何處的情況使用Java集合;這不是我想要做的。

@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

我想出了一個答案，但請告訴我在JPA或Hibernate中有更好的方法來做到這一點。

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