Dalam hal apa Anda menggunakan @JoinTable
anotasi JPA ?
sumber
Dalam hal apa Anda menggunakan @JoinTable
anotasi JPA ?
EDIT 2017-04-29 : Seperti yang ditunjukkan oleh beberapa komentator, JoinTable
contohnya tidak memerlukan mappedBy
atribut anotasi. Bahkan, versi terbaru dari Hibernate menolak untuk memulai dengan mencetak kesalahan berikut:
org.hibernate.AnnotationException:
Associations marked as mappedBy must not define database mappings
like @JoinTable or @JoinColumn
Mari kita berpura-pura bahwa Anda memiliki entitas bernama Project
dan entitas lain bernama Task
dan setiap proyek dapat memiliki banyak tugas.
Anda bisa mendesain skema database untuk skenario ini dengan dua cara.
Solusi pertama adalah membuat tabel bernama Project
dan tabel lain bernama Task
dan menambahkan kolom kunci asing ke tabel tugas bernama project_id
:
Project Task
------- ----
id id
name name
project_id
Dengan cara ini, akan mungkin untuk menentukan proyek untuk setiap baris di tabel tugas. Jika Anda menggunakan pendekatan ini, di kelas entitas Anda, Anda tidak perlu tabel bergabung:
@Entity
public class Project {
@OneToMany(mappedBy = "project")
private Collection<Task> tasks;
}
@Entity
public class Task {
@ManyToOne
private Project project;
}
Solusi lain adalah dengan menggunakan tabel ketiga, misalnya Project_Tasks
, dan menyimpan hubungan antara proyek dan tugas dalam tabel itu:
Project Task Project_Tasks
------- ---- -------------
id id project_id
name name task_id
The Project_Tasks
tabel disebut "Join Table". Untuk mengimplementasikan solusi kedua ini di JPA Anda perlu menggunakan@JoinTable
anotasi. Misalnya, untuk menerapkan asosiasi satu-ke-satu yang uni-directional, kita dapat mendefinisikan entitas kita sebagai berikut:
Project
kesatuan:
@Entity
public class Project {
@Id
@GeneratedValue
private Long pid;
private String name;
@JoinTable
@OneToMany
private List<Task> tasks;
public Long getPid() {
return pid;
}
public void setPid(Long pid) {
this.pid = pid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Task> getTasks() {
return tasks;
}
public void setTasks(List<Task> tasks) {
this.tasks = tasks;
}
}
Task
kesatuan:
@Entity
public class Task {
@Id
@GeneratedValue
private Long tid;
private String name;
public Long getTid() {
return tid;
}
public void setTid(Long tid) {
this.tid = tid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Ini akan membuat struktur database berikut:
The @JoinTable
penjelasan juga memungkinkan Anda menyesuaikan berbagai aspek tabel bergabung. Misalnya, sudahkah kami memberi anotasi pada tasks
properti seperti ini:
@JoinTable(
name = "MY_JT",
joinColumns = @JoinColumn(
name = "PROJ_ID",
referencedColumnName = "PID"
),
inverseJoinColumns = @JoinColumn(
name = "TASK_ID",
referencedColumnName = "TID"
)
)
@OneToMany
private List<Task> tasks;
Database yang dihasilkan akan menjadi:
Akhirnya, jika Anda ingin membuat skema untuk asosiasi banyak-ke-banyak, menggunakan tabel bergabung adalah satu-satunya solusi yang tersedia.
@JoinTable/@JoinColumn
dapat dijelaskan pada bidang yang sama denganmappedBy
. Jadi contoh yang benar harus menjagamappedBy
diProject
, dan memindahkan@JoinColumn
keTask.project
(atau sebaliknya)Project_Tasks
membutuhkanname
dariTask
juga, yang menjadi tiga kolom:project_id
,task_id
,task_name
, bagaimana untuk mencapai hal ini?Caused by: org.hibernate.AnnotationException: Associations marked as mappedBy must not define database mappings like @JoinTable or @JoinColumn:
Juga lebih bersih untuk digunakan
@JoinTable
ketika Entitas dapat menjadi anak dalam beberapa hubungan orang tua / anak dengan berbagai jenis orang tua. Untuk menindaklanjuti dengan contoh Behrang, bayangkan Tugas dapat menjadi anak dari Proyek, Orang, Departemen, Studi, dan Proses.Haruskah
task
tabel memiliki 5nullable
bidang kunci asing? Saya pikir tidak...sumber
Ini satu-satunya solusi untuk memetakan asosiasi ManyToMany: Anda memerlukan tabel gabungan antara tabel dua entitas untuk memetakan asosiasi.
Ini juga digunakan untuk asosiasi OneToMany (biasanya searah) ketika Anda tidak ingin menambahkan kunci asing di tabel banyak sisi dan dengan demikian tetap independen dari satu sisi.
Cari @JoinTable di dokumentasi hibernate untuk penjelasan dan contoh.
sumber
Ini memungkinkan Anda menangani hubungan Many to Many. Contoh:
Bergabung dengan Tabel memungkinkan Anda membuat pemetaan menggunakan:
akan membuat tabel:
sumber
@ManyToMany
asosiasiPaling sering, Anda harus menggunakan
@JoinTable
anotasi untuk menentukan pemetaan hubungan tabel banyak-ke-banyak:Jadi, anggap Anda memiliki tabel database berikut:
Di
Post
entitas, Anda akan memetakan hubungan ini, seperti ini:The
@JoinTable
penjelasan digunakan untuk menentukan nama tabel melaluiname
atribut, serta kolom Foreign Key yang referensi yangpost
tabel (misalnya,joinColumns
) dan kolom Foreign Key dipost_tag
tabel link yang referensi yangTag
entitas melaluiinverseJoinColumns
atribut.@OneToMany
Asosiasi searah@OneToMany
Asosiasi searah , yang kurang a@JoinColumn
pemetaan, berperilaku seperti hubungan tabel banyak-ke-banyak, bukan satu-ke-banyak.Jadi, dengan asumsi Anda memiliki pemetaan entitas berikut:
Hibernate akan mengasumsikan skema database berikut untuk pemetaan entitas di atas:
Seperti yang sudah dijelaskan,
@OneToMany
pemetaan JPA searah berperilaku seperti asosiasi banyak-ke-banyak.Untuk menyesuaikan tabel tautan, Anda juga dapat menggunakan
@JoinTable
anotasi:Dan sekarang, tabel tautan akan dipanggil
post_comment_ref
dan kolom Kunci Asing akanpost_id
, untukpost
tabel, danpost_comment_id
, untukpost_comment
tabel.sumber