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。

@GeneratedValue

理解JPA注解@GeneratedValue

Hibernate 映射关系