Possibilité d'avoir des entités JPA immuables?

Dans notre hibernate projet, les entités sont codés à l'aide de la java beans modèle. Il y a très peu d'endroits dans notre code où quelqu'un a oublié de définir un mutateur et nous obtenons une exception due à un champ NUL.

Est ce que quelqu'un l'aide d'un constructeur pour construire leurs entités ou de les rendre immuable?

J'essaie de trouver un modèle efficace qui n'est pas dans le style de la java beans modèle.

Grâce

source d'informationauteur Billworth Vandory

  1. 14

    Si vous faites vos haricots immuable, alors vous devez utiliser le champ de l'accès au niveau et cela vient avec son propre ensemble de problèmes discutés de manière approfondie ici. L'approche que nous avons pris est d'avoir un Constructeur par défaut/application/validation de la requiredness etc règles pour nous.

  2. 8

    Dans notre projet, nous utilisons la vanille constructeurs approche (@voir Effective Java). Considérons l'exemple suivant:

    @Entity
public class Person {
public static class Builder {
private String firstName;
private String lastName;
private PhoneNumber phone;
public Builder() {}
public Builder withFullName(String fullName) {
Preconditions.notNull(fullName); 
String[] split = fullName.split(" ");
if (split == null || split.length != 2) {
throw new IllegalArgumentException("Full name should contain First name and Last name. Full name: " + fullName);
}  
this.firstName = split[0];
this.lastName = split[1];
return this;
}
public Builder withPhone(String phone) {
//valueOf does validation
this.phone = PhoneNumber.valueOf(phone);
return this;
}
public Person build() {
return new Person(this);
}
}
//@Columns
private long id;//@Id
private String firstName;
private String lastName;
private String phoneNumber;
//hibernate requires default constructor
private Person() {} 
private Person(Builder builder) {
this.firstName = Preconditions.notNull(builder.firstName);
this.lastName = Preconditions.notNull(builder.lastName);
this.phoneNumber = builder.phone != null ? builder.phone : null;
}
//Getters
@Nonnull
public String getFirstName() { return firstName;}
@Nonnull
public String getLastName() { return lastName;}
@Nullable
public String getPhoneName() { return phone;}
public long getId() { return id;}
}

    Dans le cas où vous souhaitez parfois la mutation de l'entité que je recommanderais à introduire new Builder(Person person) qui copie toutes les données en arrière, de sorte que vous pouvez les transformer avec le constructeur. Bien sûr, il va produire une nouvelle entité, de sorte que l'ancien reste en lecture seule.

    L'utilisation (par mutation) est aussi simple que:

    Person.Builder personBuilder = new Person.Builder();
Person person = personBuilder.withFullName("Vadim Kirilchuk").withPhone("12345678").build();
Person modified = new Person.Builder(person).withPhone("987654321").build();

    Il est également important de noter que dans cet exemple, la Personne n'est pas à 100% immuable (et ne peut pas être) classe: d'abord parce que id sera fixé par jpa, aussi paresseux associations peuvent être récupérés au moment de l'exécution et enfin, parce que vous ne pouvez pas avoir des champs de finale(en raison nécessaire constructeur par défaut) 🙁 Le dernier point est également une préoccupation pour les environnements multithreads, c'est à dire qu'il est possible que l'entité passée à un autre thread juste après #build() peut conduire à toutes sortes d'erreurs abother fil n'est pas garanti pour voir entièrement construit de l'objet.

    La JPA 2.1 spécification, la section "2.1 La Classe d'Entité", dit:

    Pas de méthodes ou la persistance des variables d'instance de la classe d'entité peut être
    final.

    Encore une approche similaire: http://vlkan.com/blog/post/2015/03/21/immutable-persistence/

    Dans mon cas, je voudrais juste ajouter une id à la place le générateur de service de construction sur le dessus de projets..