Stratégie d'héritage SINGLE_TABLE utilisant des énumérations comme valeur discriminante

Question

Est-il possible d'utiliser une énumération comme valeur discriminante lors de l'utilisation de la stratégie d'héritage SINGLE_TABLE?

Answer 1

À ma connaissance, il est impossible avec les annotations:

• valeur discriminante doit être de type String
• valeur discriminante doit être une compilation constante de temps, à savoir les valeurs de retour des méthodes sur énumérations sont interdit.

Answer 2

yup, lorsque vous définissez discriminateur l'option de l'annotation sont nom et discrimatorType

@DiscriminatorColumn (name="MYDISCRIMINATOR", discriminatorType= DiscriminatorType.INTEGER) 

dont DiscriminatorType ne peut être:

DiscriminatorType.STRING 
DiscriminatorType.CHAR 
DiscriminatorType.INTEGER 

malheureux je ne voyais pas hier, mais bien . C'est comme ça

Answer 3

Non, malheureusement vous ne pouvez pas. Si vous essayez d'utiliser une valeur enum discriminator, vous obtiendrez une exception d'incompatibilité de type ("impossible de convertir MyEnum en String"), car les seuls types de discriminateurs autorisés sont String, Char et Integer. Ensuite, j'ai essayé d'utiliser un nom d'enum et un ordinal combinés avec DiscriminatorType.STRING et DiscriminatorType.INTEGER, respectivement. Mais cela ne fonctionne pas non plus, comme l'annotation @DiscriminatorValue (comme tout autre) nécessite une expression constante:

Cela ne fonctionne pas:

@Entity 
@Inheritance(strategy=InheritanceType.SINGLE_TABLE) 
@DiscriminatorColumn(name="FREQUENCY", 
    discriminatorType=DiscriminatorType.STRING 
)  
public abstract class Event {} 

@Entity 
@DiscriminatorValue(value=Frequency.WEEKLY.name()) 
public class WeeklyEvent extends Event { 
    // Exception: The value for annotation attribute DiscriminatorValue.value must be a constant expression 
} 

ne fonctionne pas non plus:

@Entity 
@Inheritance(strategy=InheritanceType.SINGLE_TABLE) 
@DiscriminatorColumn(name="FREQUENCY", 
    discriminatorType=DiscriminatorType.INTEGER 
) 
public abstract class Event {} 

@Entity 
@DiscriminatorValue(value=Frequency.WEEKLY.ordinal()) 
public class WeeklyEvent extends Event { 
    // Exception: The value for annotation attribute DiscriminatorValue.value must be a constant expression 
} 

Answer 4

Vous pouvez utiliser DiscriminatorType.INTEGER et mapper chaque sous-classe avec @DiscriminatorValue("X"), où X doit être la valeur ordinale de l'énumération (0,1,2,3 ...).

doit doit être la valeur comme une constante Chaîne. Vous ne pouvez pas utiliser YourEnum.SOME_VALUE.ordinal(), car les valeurs d'attribut d'annotation doivent être des constantes. Oui, c'est fastidieux. Oui, il est sujet aux erreurs. Mais ça fonctionne.

Answer 5

Si vous essayez de ne pas dupliquer les valeurs du discriminateur, il existe une solution de contournement simple.

@Entity 
@Inheritance(strategy=InheritanceType.SINGLE_TABLE) 
@DiscriminatorColumn(name="FREQUENCY", 
    discriminatorType=DiscriminatorType.STRING 
)  
public abstract class Event { 
} 

@Entity 
@DiscriminatorValue(value=Frequency.Values.WEEKLY) 
public class WeeklyEvent extends Event { 
    … 
} 

public enum Frequency { 
    DAILY(Values.DAILY), 
    WEEKLY(Values.WEEKLY), 
    MONTHLY(Values.MONTHLY); 

    private String value; 

    … 

    public static class Values { 
     public static final String DAILY = "D"; 
     public static final String WEEKLY = "W"; 
     public static final String MONTHLY = "M"; 
    } 
} 

Pas super élégant, mais mieux que d'avoir à maintenir les valeurs à plusieurs endroits.

Answer 6

Je voulais juste améliorer la bonne réponse de @asa à propos de la solution de contournement. Habituellement, nous aimons souvent utiliser la colonne discriminante comme un attribut de la classe abstraite, et mappé avec un enum bien sûr. Nous pouvons toujours utiliser la solution mentionnée ci-dessus et forcer certaines consistances entre enum noms (utilisés pour mapper la colonne) et String valeurs (utilisées comme valeurs discriminantes).Voici ma suggestion:

public enum ELanguage { 
    JAVA(Values.JAVA), GROOVY(Values.GROOVY); 

    private ELanguage (String val) { 
    // force equality between name of enum instance, and value of constant 
    if (!this.name().equals(val)) 
     throw new IllegalArgumentException("Incorrect use of ELanguage"); 
    } 

    public static class Values { 
    public static final String JAVA= "JAVA"; 
    public static final String GROOVY= "GROOVY"; 
    } 
} 

Et pour les entités, voici le code:

@Entity 
@Inheritance(strategy=InheritanceType.SINGLE_TABLE) 
@DiscriminatorColumn(name="LANGUAGE_TYPE", discriminatorType=DiscriminatorType.STRING)  
public abstract class Snippet { 
    // update/insert is managed by discriminator mechanics 
    @Column(name = "LANGUAGE_TYPE", nullable = false, insertable = false, updatable = false) 
    @Enumerated(EnumType.STRING) 
    public ELanguage languageType 
} 

@Entity 
@DiscriminatorValue(value=ELanguage.Values.JAVA) 
public class JavaSnippet extends Snippet { 
    … 
} 

pas encore parfait, mais un peu mieux, je pense.