在我们做数据库设计的时候，最烦的就是各种表之间的关联关系了，关联关系有：一对多，多对一，一对一，其中还有单向和双向的区别.

　　1.双向一对多及多对一映射:既然是双向，那么就是同一类的了：双向一对多关系中，必须存在一个关系维护端，在 JPA 规范中，要求 many 的一方作为关系的维护端(owner side), one 的一方作为被维护端(inverse side)。 可以在 one 方指定 @OneToMany 注释并设置 mappedBy 属性，以指定它是这一关联中的被维护端，many 为维护端。 在 many 方指定 @ManyToOne 注释，并使用 @JoinColumn 指定外键名称，讲的比较难理解，下面是代码：

　　

User.java:    @OrderBy("id")//指的是取出数据的时候，按照哪一个字段来进行排列，我们这里是按照user表的id字段排序,默认是ASC，完整用法：@OrderBy(value= "group_name ASC, name DESC")       @OneToMany(targetEntity=Phone.class,mappedBy="user")//mappedBy说的就是上面说的被维护端，多的那一端就是维护端，注意mappedBy="xxx" xxx表示的是在另外一个类中关联这个类的那个属性名，在这个例子中是user(需要注意，这里必须是相同的名称，如果不同的话，是会报错的) public Set
     
       getPhones() {        return phones;    } Phone.java　　@JoinColumn(name="user_id")//指定在本实体所映射的那个表中关联的外键    @ManyToOne(targetEntity=User.class)//    public User getUser() {        return user;    }
     

 顺带讲一下，单向多对一的怎么做，对于上面的代码来说，我们只要将User中将被维护的注解给去掉，当然Set<Phone>也需要去掉。

下面再讲一下单向一对多:

JPA单向一对多只需要在多的一端使用如下注解：

@OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY)//级联保存、更新、删除、刷新;延迟加载36   @JoinColumn(name="author_id")//在book表增加一个外键列来实现一对多的单向关联private Set
    
      books = new HashSet
     
      ();
     
    

 

而在Book.java里头不需要任何有关author的信息。

但是经过测试发现，在Book表中，author_id需要设置允许为空，因为JPA是先往两张表插入新数据，然后再更新Book表中的author_id字段的。

所以不可以在数据库中设置该外键为空。

推荐使用双向关系

 

2.双向一对一映射：基于外键的 1-1 关联关系：在双向的一对一关联中，需要在关系被维护端(inverse side)中的 @OneToOne 注释中指定 mappedBy，以指定是这一关联中的被维护端。同时需要在关系维护端(owner side)建立外键列指向关系被维护端的主键列。

　　

User.java:    @OneToOne(mappedBy="user")//因为需要指定其中一方为被维护段，我们设置user为被维护段，和双向一对多相同，这个名称必须和FirstLover定义User属性的名称一样    public FirstLover getFirstLover() {        return firstLover;    }    FirstLover.java:        //使用OneToOne进行一对一的映射，name表示的是关联关系表的外键,注意的是，这个外键是被维护段的主键，所以是unqie的    @JoinColumn(unique=true,name="user_id")    @OneToOne    public User getUser() {        return user;    }

在关联关系中，延迟加载经常是我们考虑的问题，可以使用在我们的这个例子中，可以使用：

@JoinColumn(unique=true,name="user_id")    @OneToOne(fetch=FetchType.LAZY)    public User getUser() {        return user;    }

但是，有这样的情况:user可以不关联firstLover（因为外键是定义在FirstLover表中的），如果有 FirsetLover 关联就设置为代理对象而延迟加载, 如果不存在关联的 FirsetLover 就设置 null, Hibernate 在不读取 FirsetLover  表的情况是无法判断是否有关联有 FirsetLover , 因此无法判断设置 null 还是代理对象, 而统一设置为代理对象,也无法满足不关联的情况, 所以无法使用延迟加载,只 有显式读取 FirsetLover .

单向一对一的话只需要在上面增加注解就可以了

@OneToOne(fetch=FetchType.EAGER)    protected User updateUser;//这样就是将user的id作为我们现在这个注解了的表的外键了。这样子就单向的关联上了

 

最后一种就是多对多的关联关系的情况，在双向多对多关系中，我们必须指定一个关系维护端(owner side),可以通过 @ManyToMany 注释中指定 mappedBy 属性来标识其为关系维护端。为了测试，我定义了两个类：

Student.java:package com.hotusm.commom.entity;import java.util.HashSet;import java.util.Set;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.JoinColumn;import javax.persistence.JoinTable;import javax.persistence.ManyToMany;@Entitypublic class Student {        private Integer id;        private String name;    private String sex;        private String school;    private Set
     
       teachers=new HashSet<>();        @GeneratedValue    @Id    public Integer getId() {        return id;    }    public void setId(Integer id) {        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getSex() {        return sex;    }    public void setSex(String sex) {        this.sex = sex;    }    public String getSchool() {        return school;    }    public void setSchool(String school) {        this.school = school;    }            @JoinTable(name="teach_stu",//指定中间表的表名，如果没有指定表名，那么默认的名字是：tab1_tab2            joinColumns={@JoinColumn(name="teacher_id",//指定本类的主键在中间表的外键的字段名称，            referencedColumnName="ID")},//指定本类的主键是什么，在这个例子中，teach_stu的teacher的id就是本类的主键值            inverseJoinColumns={@JoinColumn(name="student_id",//和上面是一样的含义，指明另外一个类主键在中间表的名称                referencedColumnName="ID" //指定另外一个类的主键是什么，这里都是ID                    )}            )    @ManyToMany//加上多对多的标示    public Set
      
        getTeachers() {        return teachers;    }    public void setTeachers(Set
       
         teachers) {        this.teachers = teachers;    }    @Override    public String toString() {        return this.name;    }}Teacher:package com.hotusm.commom.entity;import java.util.HashSet;import java.util.Set;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.ManyToMany;@Entitypublic class Teacher {        private Integer id;        private String name;            private String subjectName;        private Set
        
          students=new HashSet<>();        @GeneratedValue    @Id    public Integer getId() {        return id;    }        public void setId(Integer id) {        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    @Column(name="SUBJECT_NAME")    public String getSubjectName() {        return subjectName;    }    public void setSubjectName(String subjectName) {        this.subjectName = subjectName;    }        @ManyToMany(mappedBy="teachers")//指定维护的一方，注意这里的名称是另外一个类的属性名： private Set
         
           teachers=new HashSet<>();    public Set
          
            getStudents() { return students; } public void setStudents(Set
           
             students) { this.students = students; } @Override public String toString() { return this.name; }}
           
          
         
        
       
      
     

 基本上，关联关系也就几种了。