0. 关联关系映射
关联关系映射，是映射关系中比较复杂的一种映射关系，总的说来有一对一、一对多和多对多几种关系。细分起来他们又有单向和双向之分。下面我们逐一介绍一下。
整个项目的代码，以及用到的类库，我就不一一介绍了，可以参考我的github，在workspace下有许多项目，对应关系如下表所示：
| 项目名称 | 描述 |
|---|---|
| HibernateOne2OneUNI | 单向一对一 |
| HibernateOne2OneBI | 双向一对一 |
| HibernateOne2ManyUNI | 单向一对多 |
| HibernateMany2OneUNI | 单向多对一 |
| HibernateOne2ManyBI | 双向一对多 |
| HibernateMany2ManyUNI | 单向多对多 |
| HibernateMany2ManyBI | 双向多对多 |
具体的代码和测试可以参考我的Github，链接为：GitHub地址
1. @OneToOne 单向关联
Hasband 对Wife： OneToOne Husband单向拥有Wife。
- Hasband.java:
@Entity
public class Husband {
private int id;
private String name;
private Wife wife;
@Id
@GeneratedValue(strategy =GenerationType.IDENTITY)
public int getId() {
return id;
}
public String getName() {
return name;
}
@OneToOne
public Wife getWife() {
return wife;
}
public void setWife(Wife wife) {
this.wife = wife;
}
public void setName(String name) {
this.name = name;
}
public void setId(int id) {
this.id = id;
}
}
- Wife.java:
@Entity
public class Wife {
private int id;
private String name;
@Id
@GeneratedValue(strategy =GenerationType.IDENTITY)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
2. @OneToOne 双向关联
双向关系有一方为关系的拥有端，另一方是关系的反端，也就是“Inverse”端。在这里例子中 Husband拥有这个关系，而 Wife就是关系的“Inverse”端。Wife中我们定义了一个 husband属性，在这个属性上我们使用了 @OneToOne 注解并且定义了他的“mappedBy”属性，这个在双向关系的“Inverse”端是必需的，在下面将要介绍的双向关系中也要用到这个属性。Hasband.java与单向关系一样， Wife.java如下。
- Wife.java
@Entity
public class Wife {
private int id;
private String name;
private Husband huaband;
@OneToOne(mappedBy = "wife")
public Husband getHuaband() {
return huaband;
}
public void setHuaband(Husband huaband) {
this.huaband = huaband;
}
@Id
@GeneratedValue(strategy =GenerationType.IDENTITY)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
3. @ManyToOne 单向关联
只需在单这一方写@ManyToOne注解，这里我们用学生和课程举例，学生是One这一方，课程是Many一方。
- Course.java
@Entity
public class Course {
private int id;
private String name;
private Student student;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@ManyToOne
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
}
- Student.java
@Entity
public class Student {
private int id;
private String name;
...
4. @OneToMany 单向关联
只写@OneToMany，Hibernate会认为存在一张中间表，要加@Joincolumn。@Joincolumn的name是studentId，不要写成courseId，因为他出现在course这张表里，表示的是course表中student的ID
这里我们用学生和课程举例，学生是One这一方，课程是Many一方。
- Student.java
@Entity
public class Student {
private int id;
private String name;
private List<Course> courses = new ArrayList<Course>();
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToMany(cascade = CascadeType.ALL)
@JoinColumn(name = "studentid")
public List<Course> getCourses() {
return courses;
}
public void setCourses(List<Course> courses) {
this.courses = courses;
}
}
- Course.java
@Entity
public class Course {
private int id;
private String name;
@Id
@GeneratedValue(strategy =GenerationType.IDENTITY)
...
5. @ManyToOne 双向关联
还是一样，这里我们用学生和课程举例，学生是One这一方，课程是Many一方。双向非常简单，只需要在单的一方加上mappedBy即可。
- Student.java
@Entity
public class Student {
private int id;
private String name;
private List<Course> courses = new ArrayList<Course>();
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToMany(mappedBy="student")
public List<Course> getCourses() {
return courses;
}
public void setCourses(List<Course> courses) {
this.courses = courses;
}
}
Course.java
@Entity
public class Course {
private int id;
private String name;
private Student student;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@ManyToOne
public Student getStudent() {
return student;
}
public void setStudent(Student sutdent) {
this.student = sutdent;
}
}
6. @ManyToMany 单向关联
使用@ManyToMany， 表示的意思是一个学生可以选多门课程。
@JoinTable(name = "s_c", joinColumns = { @JoinColumn(name = "student_id") }, inverseJoinColumns = { @JoinColumn(name = "course_id") }为中间表的表名和列名
- Student.java
@Entity
public class Student {
private int id;
private String name;
private List<Course> courses = new ArrayList<Course>();
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@ManyToMany
@JoinTable(name = "s_c", joinColumns = { @JoinColumn(name = "student_id") }, inverseJoinColumns = {
@JoinColumn(name = "course_id") })
public List<Course> getCourses() {
return courses;
}
public void setCourses(List<Course> courses) {
this.courses = courses;
}
}
- Course.java
@Entity
public class Course {
private int id;
private String name;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
7. @ManyToMany 双向关联使用
@ManyToMany， 表示的意思是一个学生可以选多门课程。一门课程可以有多个学生选择，关系被维护方需要加mappedBy。@JoinTable的解释看第6节。
- Student.java
@Entity
public class Student {
private int id;
private String name;
private List<Course> courses = new ArrayList<Course>();
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@ManyToMany
@JoinTable(name = "s_c", joinColumns = { @JoinColumn(name = "student_id") }, inverseJoinColumns = {
@JoinColumn(name = "course_id") })
public List<Course> getCourses() {
return courses;
}
public void setCourses(List<Course> courses) {
this.courses = courses;
}
}
- Course.java
@Entity
public class Course {
private int id;
private String name;
private List<Student> students = new ArrayList<Student>();
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@ManyToMany(mappedBy = "courses")
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
}
7. 关键字
MappedBy
mappedBy的意思就是“被映射”，即mappedBy这方不用管关联关系，关联关系交给另一方处理
规律：
凡是双向关联，mapped必设，因为根本都没必要在2个表中都存在一个外键关联，在数据库中只要定义一边就可以了
- 只有OneToOne,OneToMany，ManyToMany上才有mappedBy属性，ManyToOne不存在该属性；
- mappedBy标签一定是定义在the owned side(被拥有方的)，他指向the owning side(拥有方)；
- mappedBy的含义，应该理解为，拥有方能够自动维护 跟被拥有方的关系；
当然，如果从被拥有方，通过手工强行来维护拥有方的关系也是可以做到的。 - mappedBy跟JoinColumn/JoinTable总是处于互斥的一方，可以理解为正是由于拥有方的关联被拥有方的字段存在，拥有方才拥有了被 拥有方。mappedBy这方定义的JoinColumn/JoinTable总是失效的，不会建立对应的字段或者表
Cascade
hibernate一对多关系中,会用到级联操作.即:有collection的一端操作，被关联的表被自动操作.
这时有collection一端需要配置<set cascade="?">，即用在一对多的一方。
Cascade 属性值：
- none:在保存、删除修改对象的时候，不考虑其附属物的操作。
- save-update:在保存、更新当前对象时，级联保存、更新附属物。
- delete:在删除当前对象时，级联删除附属物。
- all: 包含save-update和delete的操作，但不包括delete-orphan的操作。
- delete-orphan:删除和当前对象解除关系的附属对象。
- all-delete-orphan:所用情况。
fetch
fetch = FetchType.EAGER： 那么表示取出这条数据时，它关联的数据也同时取出放入内存中，因为在内存里，所以在session外也可以取。
fetch = FetchType.LAZY：取出这条数据时，它关联的数据并不取出来，在同一个session中，什么时候要用，就什么时候取(再次访问数据库)。 但是，在session外，就不能再取了。用EAGER时。
一般只在一边设Eager，JPA接口默认为一对多为Lazy，多对一为Eager，但是Hibernate反向工程生成Entity时，多对一为Lazy，需要手动改为Eager。
而两边都设Eager，那么代码中取一条记录时，会发2次SQL。
