hibernate关系映射

一对一外键关联：

单向：

在husband表中加入一个wife-id字段，和Wife表的主键相关联

@Entity

@Table(name= "_husband")

public classHusband {

private int id;

private String name;

private Wife wife;

@OneToOne

@JoinColumn(name = "wife-id")

public Wife getWife() {

    return wife;

}

双向：

Huaband表如上，Wife表如下(以huasband为主导)

@Entity

@Table(name= "_wife")

public classWife {

private int id;

private String name;

private Husband husband;

@OneToOne(mappedBy = "wives")//这里wives和huasband表中Wife引用名对应

public Husband getHusband() {

    return husband;

}

一对一联合主键单向外键：

1.      联合主键类正常建(实现java.io.Serializable接口，复写equals和hasCode方法)

 

 

 

 

 

 

 

 

2.

@Entity

@Table(name= "_husband")

public classHusband {

private int id;

private String name;

private Wife wife;

@OneToOne

@JoinColumns(

        {//语法（想要的外键字段名，对应的关联字段名）

            @JoinColumn(name="wife_Id",referencedColumnName="_id"),

            @JoinColumn(name="wife_Name",referencedColumnName="_name")

        }

     )

效果：生成的huasband表含有wife_Id和wife_Name两个字段作为外键

组件映射

1.      huasband表如下

@Entity

public class Husband {

private int id;

privateString name;

private int age;

privateWife wife;

@Embedded

publicWife getWife() {

return wife;

}

2.       Wife表中不要有主键(@id标示)，尽量不要和Hasband中的字段重名

重点：多对一与一对多

关键：总是会以多的一方为中心

1.    多对一

以Group(一)和User(多)表为例：Group正常写(@Table(name = “t_group”),注意group为关键词)就可以，User表如下：

//在多的一方加外键，对应少的一方的对象

@Entity

public classUser {

private int id;

private String name;

private Group group;

@ManyToOne

@JoinColumn(name = "t_group_id")

public Group getGroup() {

    return group;

}

2.    一对多

User正常写，Group如下：

//一对多时，一的一方有多的一方的容器属性,在一的这方为多的一方加入外键

@Entity

public classGroup {

private int id;

private String name;

private Set<User> users = newHashSet<User>();

@OneToMany

@JoinColumn(name="group_Id")

public Set<User> getUsers() {

    return users;

}

3.    双向

关键：只要是双向关系，必须在弱的一方加入mapped=“”的语句。举例如下，User表

@Entity

@Table(name = "t_user")

public classUser {

    private int id;

    private String name;

    private Group group;

    @ManyToOne

@JoinColumn(name ="group-id")

    public Group getGroup() {

        return group;

    }

Group:

@Entity

@Table(name="t_group")

public classGroup {

    private int id;

    private String name;

    private Set<User> users = new HashSet<User>();

    @OneToMany(mappedBy="group")//对应强的一方里的属性名

   

    public Set<User>getUsers() {

        return users;

    }

如此就会在强的表中加入弱的表的外键

重点：多对多

关键：中间表的构成

1.    单向

Teacher如下，student表正常

@Entity

@Table(name = "t_teacher")

public class Teacher {

private int id;

privateString name;

privateSet<Student> students = newHashSet<Student>();

@ManyToMany

@JoinTable(name="t_s",//中间表的名字

     joinColumns={

     @JoinColumn(name = "teacher_id")//中间表的teacher关联字段

     },

     inverseJoinColumns={

     @JoinColumn(name = "student_id")//中间表的student关联字段

     }

)

publicSet<Student> getStudents() {

return students;

}

2.    双向（用的少）

Student表：

@Entity

@Table(name= "t_student")

public classStudent {

    private int id;

    private String name;

    private Set<Teacher> teachers = newHashSet<Teacher>();

    @ManyToMany(mappedBy="students")

    public Set<Teacher> getTeachers() {

        return teachers;

    }

Teacher表和上面一样.

一对多多对一的CRUD

默认：在多的一方被读出来后，少的一方也会被取出，反之，取出少的一方，多的一方不会被取出。可以通过修改fetch的值来进行改变.

再用load读取时，当把多的一方fetch设置为lazy时，当要读取多的一方和少的一方的名字时，会先取多的一方，再通过关联取少的一方，取两次。fetch默认的话，只会取一次。