clé primaire

Annotation @ID

Chaque entité Entity dans Hibernate doit avoir un champ qui sera la clé primaire : il contient une valeur unique pour tous les objets de cette classe. En règle générale, ce champ est annoté avec l' annotation @Id .

Forme générale:

@Id
Class Name;

Exemple:

@Entity
@Table(name="user")
class User
{
   @Id
   @Column(name="id")
   public Integer id;

   @Embedded
   public UserAddress address;

   @Column(name="created_date")
   public Date createdDate;
}

Placement des annotations

Au fait, vous pouvez écrire des annotations @Column non seulement pour les champs, mais aussi pour les méthodes : pour les getters ou les setters. Exemple:

@Entity
@Table(name="user")
class User
{
    public Integer id;
    public Date createdDate;

   @Id
   @Column(name="id")
   public Integer getId() {
   	return this.id;
   }
   public void setId(Integer id)    {
  	this.id = id;
   }

   @Column(name="created_date")
   public Date getDate() {
  	return this.createdDate;
   }
   public void setCreatedDate(Date date) {
      this. createdDate = date;
   }
}

Cette approche est apparue lorsque des annotations ont commencé à être ajoutées non seulement aux classes, mais également aux interfaces. L'interface n'a pas de champs de classe, mais il existe des méthodes : les getters et les setters. Hibernate prend en charge ces deux normes.

Important! Si une classe a l' annotation @Entity , alors tous ses champs sont traités par Hibernate comme des champs persistants (sauf s'ils ont l' annotation @Transient spécifiée ). Même si les champs n'ont aucune annotation : dans ce cas, le nom de la colonne est considéré comme égal au nom du champ de classe.

C'est là que l' annotation @Id joue un rôle important. Si l'annotation est placée sur un champ de classe, alors Hibernate regardera les noms et les types des champs. Si l' annotation @Id est placée sur une méthode, alors Hibernate examinera les noms et les types des méthodes.

Exemple 1:

@Entity
@Table(name="user")
class User
{
   @Id
    public Integer id;
    public Date createdDate;  //this field will be treated as if it had @Column(name=" createdDate ")

}

Exemple 2 :

@Entity
@Table(name="user")
class User
{
    public Integer id;
    public Date createdDate;

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

   public Date getDate() { //this field will be treated as if it had @Column(name=”date ”)
  	return this.createdDate;
   }
   public void setCreatedDate(Date date) {
  	this. createdDate = date;
   }

}

Annotation @GeneratedValue

Vous pouvez attribuer vous-même un identifiant à vos nouveaux objets ou le laisser à la merci d'Hibernate. Pour qu'Hibernate comprenne mieux comment attribuer des identifiants à vos objets, il a une annotation spéciale :

@GeneratedValue

Cette annotation marque généralement le même champ que l' annotation @Id . Elle a 4 stratégies d'attribution d'ID possibles :

• AUTO
• IDENTITÉ
• SÉQUENCE
• TABLEAU

Exemple d'annotation avec la stratégie spécifiée :

@Entity
@Table(name="user")
class User
{
    @Id
	@GeneratedValue(strategy = GenerationType.AUTO)
    public Integer id;

    public Date createdDate;
}

Si aucune valeur de stratégie n'est spécifiée, la stratégie AUTO sera sélectionnée. La stratégie AUTO signifie qu'Hibernate attribuera l'ID lui-même, en se basant principalement sur le type de données du champ ID.

Pourquoi sur type ? Oui, car les types d'ID peuvent être très différents, par exemple, String ou GUID. Exemple:

@Entity
@Table(name="user")
class User
{
    @Id
	@GeneratedValue
    public UUID id;

    public Date createdDate;
}

Remarque : Un GUID en Java est appelé un UUID, historiquement parlant. Et Hibernate peut générer des UUID uniques pour vos objets si vous le lui demandez.

Diverses stratégies @GeneratedValue

Si vous spécifiez le type GeneratedValue(strategy = GenerationType.IDENTITY) , alors Hibernate délègue le paramètre ID à la couche de base de données. En règle générale, cela utilise une colonne intitulée PRIMARY KEY, AUTOINCREMENT.

Mais si vous souhaitez que vos identifiants soient uniques et générés selon un algorithme spécialement spécifié, vous pouvez utiliser l' annotation GeneratedValue(strategy = GenerationType.SEQUENCE) , par exemple :

@Entity
@Table(name="user")
public class User {
	@Id
	@GeneratedValue(generator = "sequence-generator")
	@GenericGenerator(
  	name = "sequence-generator",
  	strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator",
  	parameters = {
    	@Parameter(name = "sequence_name", value = "user_sequence"),
    	@Parameter(name = "initial_value", value = "4"),
    	@Parameter(name = "increment_size", value = "1")
    	}
	)
	private long userId;

	// ...
}

Il existe de nombreuses autres façons de générer un ID. Par exemple, vous pouvez avoir une clé unique composite composée de plusieurs colonnes. Et lors de l'écriture d'un objet dans la base de données, vous devez remplir toutes ces colonnes.

Je ne vais pas les détailler. Pourtant, le but de nos conférences est de se familiariser avec Hibernate, et non de redire la documentation officielle.