如何在休眠中存储枚举数组

我想使用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]; 
    ... 
}

来源

2017-02-15 A. Rick

FWIW“enum”不是“@ Embeddable”。这是一种基本类型。 –

谢谢。这很有帮助;删除它至少改变了我得到的错误。最终，我刚刚投入，并进行了下文所述的破解。 –

我想出了一个答案，但请告诉我在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; 
    } 
}

来源

2017-02-23 00:27:34

如何在休眠中存储枚举数组

回答

相关问题