Utilisez Enum dans le modèle de domaine (ORM) lorsque la table correspondante a défini des valeurs?

Question

J'ai une table nommée job_class qui a fixé des valeurs:

Telle est la définition de la table:

create table job_class (
    job_class_code int NOT NULL PRIMARY KEY, 
    job_class_name varchar(50) NOT NULL, 
    ext_code varchar(10) NOT NULL 
) 

Il sera toujours 3 rangs:

insert into job_class values (1, 'HOURLY', 'H') 
insert into job_class values (2, 'SALARY', 'S') 
insert into job_class values (3, 'EXECUTIVE', 'E') 

job_class Table est référencé comme un FK dans employé table:

create table employee (
    employee_id bigint NOT NULL PRIMARY KEY, 
    first_name varchar(50) NOT NULL, 
    middle_name varchar(50) NULL, 
    last_name varchar(50) NOT NULL, 
    job_class_code int NOT NULL FOREIGN KEY REFERENCES job_class (job_class_code) 
) 

maintenant pour mapper ce tableau dans le modèle de domaine (ORM), généralement je définis une classe de cette façon:

public class JobClass implements java.io.Serializable { 
    private Integer id; 
    private String name; 
    private String extCode; 

    public Integer getId() { return id; } 
    public void setId(Integer id) { this.id = id; } 

    public String getName() { return name; } 
    public void setName(String name) { this.name = name; } 

    public String getExtCode() { return extCode; } 
    public void setId(String extCode) { this.extCode = extCode; } 
} 

Mais si je définis comme Enum au lieu:

public enum JobClass { 
    HOURLY(1,"HOURLY","H"), 
    SALARY(2,"SALARY","S"), 
    EXECUTIVE(3,"EXECUTIVE","E"); 

    private Integer id; 
    private String name; 
    private String extCode; 

    private JobClass(Integer id, String name, String extCode) { 
     this.id = id; 
     this.name = name; 
     this.extCode = extCode; 
    } 

    public Integer getId() { return id; } 
    public String getName() { return name; } 
    public String getExtCode() { return extCode; } 
} 

Est-ce logique d'utiliser un Enum dans ORM? Je n'ai jamais utilisé un ENUM directement dans ORM avant cela. Est-ce une bonne pratique dans ce cas? Quelles sont les implications Serializable si vous utilisez Enum?

Answer 1

Pour utiliser une énumération, vous devez être sûr à 100% que votre table n'aura pas de nouvel enregistrement ou que son enregistrement existant est altéré, sinon vous obtiendrez une erreur.

Avec un ORM, vous serez en mesure de mapper à une énumération via l'annotation @Enumerated, il y a moyen de le faire: EnumType.ORDINAL ou EnumType.STRING.

I'll let you check the documentation for the difference.

---

Dans votre cas, puisque vous utilisez l'auto incrémentée id comme une clé FK, il ne serait pas bon d'utiliser @Enumerated(EnumType.STRING) car il vous oblige à nommer vos valeurs enum 1, 2 et 3.

Je n'aime pas vraiment utiliser @Enumerated(EnumType.ORDINAL) car il lie votre ordre enum avec l'ordre de la table de base de données. Mais dans votre cas, cela fonctionnerait.

Si vous voulez aller les miles supplémentaires, vous pouvez utiliser un convertisseur @Convert(converter = JobClassConverter.class)

Vous gardez votre ENUM tel qu'il est et JOBCLASS l'attribut de l'employé ressemblerait à ce que:

@Column(name = "job_class_code") 
    @Convert(converter = JobClassConverter.class) 
    private JobClass jobClass; 

Ensuite, vous créerait le JobClassConverter

public class JobClassConverter implements AttributeConverter<JobClass, Integer> { 

    @Override 
    public Integer convertToDatabaseColumn(final JobClass pAttribute) { 
     if (pAttribute == null) { 
      return null; 
     } else { 
      switch (pAttribute) { 
       case HOURLY: 
        return 1; 
       case SALARY: 
        return 2; 
       case EXECUTIVE: 
        return 3; 
      } 
     } 
    } 

    @Override 
    public JobClass convertToEntityAttribute(final Integer pDbData) { 
     if (pDbData == null) { 
      return null; 
     } else { 
      switch (pDbData) { 
       case 1: 
        return JobClass.HOURLY; 
       case 2: 
        return JobClass.SALARY; 
       case 3: 
        return JobClass.EXECUTIVE; 
      } 
     } 
    } 
}