Il est là pour spécifier une autre colonne comme la colonne id par défaut de l’autre table, par ex.

 TableA id int identity tableb_key varchar TableB id int identity key varchar unique // in class for TableA @JoinColumn(name="tableb_key", referencedColumnName="key") 

La propriété “namedColumnName” est le nom de la colonne de la table à laquelle vous faites référence avec la colonne que vous notifiez. Ou de manière succincte: c’est la colonne référencée dans la table de destination. Imaginez quelque chose comme ceci: voitures et personnes. Une personne peut avoir beaucoup de voitures, mais une seule voiture appartient à une seule personne (désolé, je n’aime pas les autres conducteurs de voiture).

Personne table
nom char (64) clé primaire
age int

Voiture de table
car_registration char (32) clé primaire
car_brand (caractère 64)
car_model (char64)
owner_name char (64) références de clés étrangères Personne (nom)

Lorsque vous implémentez des classes, vous aurez quelque chose comme

 class Person{ ... } class Car{ ... @ManyToOne @JoinColumn(columnName="owner_name", referencedColumnName="name") private Person owner; } 

J’espère que cela t’aides.

API de citations sur namedColumnName :

Nom de la colonne référencée par cette colonne de clé étrangère.

Valeur par défaut (s’applique uniquement si une colonne de jointure unique est utilisée): le même nom que la colonne de clé primaire de la table référencée.

Q / A

Où cela serait-il utilisé?

Lorsqu’il existe une PK composite dans la table référencée , vous devez spécifier le nom de la colonne que vous référencez.

• name atsortingbut name pointe sur la colonne contenant l’association, c’est-à-dire le nom de la colonne de la clé étrangère
• referencedColumnName atsortingbut referencedColumnName pointe vers la colonne associée dans l’entité associée / associée, c’est-à-dire le nom de la colonne primaire

Vous n’êtes pas obligé de remplir le nom de colonne referencedColumnName si l’entité référencée a une seule colonne en tant que PK, car il n’y a aucun doute sur la colonne de référence (c’est-à-dire l’ID de colonne unique d’ Address ).

 @ManyToOne @JoinColumn(name="ADDR_ID") public Address getAddress() { return address; } 

Toutefois, si l’entité référencée possède une PK qui s’étend sur plusieurs colonnes, l’ordre dans lequel vous spécifiez les annotations @JoinColumn est important. Il peut fonctionner sans le referencedColumnName NomColonne, mais c’est par chance. Donc, vous devriez cartographier comme ceci:

 @ManyToOne @JoinColumns({ @JoinColumn(name="ADDR_ID", referencedColumnName="ID"), @JoinColumn(name="ADDR_ZIP", referencedColumnName="ZIP") }) public Address getAddress() { return address; } 

ou dans le cas de ManyToMany :

 @ManyToMany @JoinTable( name="CUST_ADDR", joinColumns= @JoinColumn(name="CUST_ID"), inverseJoinColumns={ @JoinColumn(name="ADDR_ID", referencedColumnName="ID"), @JoinColumn(name="ADDR_ZIP", referencedColumnName="ZIP") } ) 

Exemple de vie réelle

Deux requêtes générées par Hibernate du même mappage de table de jointure, toutes deux sans colonne référencée spécifiée. Seul l’ordre des annotations @JoinColumn été modifié.

 /* load collection Client.emails */ select emails0_.id_client as id1_18_1_, emails0_.rev as rev18_1_, emails0_.id_email as id3_1_, email1_.id_email as id1_6_0_ from client_email emails0_ inner join email email1_ on emails0_.id_email=email1_.id_email where emails0_.id_client='2' and emails0_.rev='18' 

 /* load collection Client.emails */ select emails0_.rev as rev18_1_, emails0_.id_client as id2_18_1_, emails0_.id_email as id3_1_, email1_.id_email as id1_6_0_ from client_email emails0_ inner join email email1_ on emails0_.id_email=email1_.id_email where emails0_.rev='2' and emails0_.id_client='18' 

Nous interrogeons une table de jointure pour obtenir les emails du client. Le {2, 18} est l’ID composite du client. L’ordre des noms de colonnes est déterminé par votre ordre d’annotations @JoinColumn . L’ordre des deux entiers est toujours le même, probablement sortingé par hibernation et c’est pourquoi un alignement correct avec les colonnes de la table de jointure est nécessaire et nous ne pouvons ou ne devons pas nous fier à l’ordre de mappage.

La chose intéressante est que l’ordre des entiers ne correspond pas à l’ordre dans lequel ils sont mappés dans l’entité – dans ce cas, j’attendrais {18, 2} . Il semble donc que Hibernate sortinge les noms des colonnes avant de les utiliser dans la requête. Si cela est vrai et que vous commandez votre @JoinColumn de la même manière que vous n’auriez pas besoin de @JoinColumn , mais je ne le dis que pour illustration.

Les atsortingbuts correctement referencedColumnName bien remplis de ColumnName donnent exactement la même requête sans ambiguïté, dans mon cas la deuxième requête ( rev = 2 , id_client = 18 ).

Pour un exemple d’utilisation JPA 2.x pour le cas général de deux tables, avec une @OneToMany unidirectionnelle @OneToMany voir https://en.wikibooks.org/wiki/Java_Persistence/OneToMany#Example_of_a_JPA_2.x_unidirectional_OneToMany_relationship_annotations

Capture d’écran de cet article JPA de WikiBooks: Exemple d’une firebase database de relations OneToMany unidirectionnelle JPA 2.x