Hibernate实体关系映射—Annotation

转载自 Hibernate实体关系映射—Annotation

hibernate实体关系映射分为：

    单边一对一，双边一对一；

    单边一对多，单边多对一；

    双边一对多，双边多对一；

    单边多对多，双边多对多；

    以及主键相同的单双边一对一。下面分别总结这几种关系映射的注解方法：

1.  单边一对一和双边一对一

    单边一对一：比如一个学生（Student）有一个学生证（StudentCard），且Student类中有一个StudentCard对象：

[java] view plain copy

print ?

1. @Entity    
2. @Table(name = "student")    
3. public class Student {    
4.     @Id    
5.     @GeneratedValue(strategy = GenerationType.IDENTITY)     
6.     private String id;    
7.      
8.     private String name;    
9.      
10.     @OneToOne(cascade = {CascadeType.ALL})    
11.     @JoinColumn(name = "student_id", unique = true)    
12.     private StudentCard stuCard;    
13.      
14.     //省略set,get方法，注解本应该放在get方法上，这里为了方便，放在成员变量上了。    
15. }    
16.      
17. @Entity    
18. @Table(name = "studentid")    
19. public class StudentCard {    
20.     @Id    
21.     @GeneratedValue(strategy = GenerationType.IDENTITY)     
22.     private String id;    
23.      
24.     private int num;    
25. }   

@Entity  
@Table(name = "student")  
public class Student {  
    @Id  
    @GeneratedValue(strategy = GenerationType.IDENTITY)   
    private String id;  
   
    private String name;  
   
    @OneToOne(cascade = {CascadeType.ALL})  
    @JoinColumn(name = "student_id", unique = true)  
    private StudentCard stuCard;  
   
    //省略set,get方法，注解本应该放在get方法上，这里为了方便，放在成员变量上了。  
}  
   
@Entity  
@Table(name = "studentid")  
public class StudentCard {  
    @Id  
    @GeneratedValue(strategy = GenerationType.IDENTITY)   
    private String id;  
   
    private int num;  
} 

    @Table中name属性表示指定实体对应 的表名，可以不指定。   

    @GeneratedValue表示主键自增长类型，有AUTO, TABLE, SEQUENCE, IDENTITY四种方式：

        GenerationType.AUTO：自动方式，根据底层数据库自动选择；

        GenerationType.TABLE：使用指定的表来决定主键的取值，一般结合@TableGenerator使用；

        GenerationType.SEQUECE：使用Sequece来决定主键的取值，适合Oracle、DB2、PostgreSQL、SAP DB等支持Sequence的数据库，一般结合@SequenceGnerator使用；

        GenerationType.IDENTITY：支持DB2、MySQL、MS SQL Server、Sybase与HypersonicSQL数据库的identity类型主键。

    @OneToOne表示一对一，cascade配置级联方式，有PERSIST、REMOVE、MERGE、REFRESH等几种取值，分别表示在保存、删除、修改、刷新Student类时，会自动在数据库    

    中保存、删除、修改、刷新属于它的StudentCard对象，ALL则表示所有动作皆级联。即级联后可以通过操作Student类来操作StudentCard类。

    双边一对一：比如丈夫（Husband）和妻子（Wife），每个类中皆有对方的类对象：

[java] view plain copy

print ?

1. @Entity    
2. public class Husband {    
3.     @Id    
4.     @GeneratedValue(strategy = GenerationType.IDENTITY)    
5.     private int id;    
6.      
7.     private String name;    
8.      
9.     @OneToOne    
10.     @JoinColumn(name="wifeId")//wifeId作为外键字段，关联wife表中的主键    
11.     private Wife wife;    
12. }    
13.      
14. @Entity    
15. public class Wife {    
16.     @Id    
17.     @GeneratedValue(strategy = GenerationType.IDENTITY)    
18.     private int id;    
19.      
20.     private String name;    
21.      
22.     @OneToOne(mappedBy = "wife")//表示已经在Husband类中对wife做了映射了。一般有双向关联的都要设置mappedBy     
23.     private Husband husband;    
24. }    

    @Entity  
    public class Husband {  
        @Id  
        @GeneratedValue(strategy = GenerationType.IDENTITY)  
        private int id;  
       
        private String name;  
       
        @OneToOne  
        @JoinColumn(name="wifeId")//wifeId作为外键字段，关联wife表中的主键  
        private Wife wife;  
    }  
       
    @Entity  
    public class Wife {  
        @Id  
        @GeneratedValue(strategy = GenerationType.IDENTITY)  
        private int id;  
       
        private String name;  
       
        @OneToOne(mappedBy = "wife")//表示已经在Husband类中对wife做了映射了。一般有双向关联的都要设置mappedBy   
        private Husband husband;  
    }  

2. 单边一对多和单边多对一

    单边一对多：比如一个组（Group）里有多个用户（User），Group类中有存储User的集合：

[java] view plain copy

print ?

1. @Entity    
2. @Table(name="t_group")//group在sql中是关键词，避免冲突    
3. public class Group {    
4.     @Id    
5.     @GeneratedValue(strategy = GenerationType.IDENTITY)    
6.     private int id;    
7.      
8.     private String name;    
9.      
10.     @OneToMany(cascade = {CascadeType.ALL}, fetch = FetchType.LAZY)    
11.     @JoinColumn(name="groupid")//表示t_user表中有个叫group_id的外键字段    
12.     private Set<User> users = new HashSet<User>();    
13. }    
14.      
15. @Entity    
16. @Table(name="t_user")    
17. public class User {    
18.     @Id    
19.     @GeneratedValue(strategy = GenerationType.IDENTITY)     
20.     private int id;    
21.      
22.     private String name;    
23. }    

    @Entity  
    @Table(name="t_group")//group在sql中是关键词，避免冲突  
    public class Group {  
        @Id  
        @GeneratedValue(strategy = GenerationType.IDENTITY)  
        private int id;  
       
        private String name;  
       
        @OneToMany(cascade = {CascadeType.ALL}, fetch = FetchType.LAZY)  
        @JoinColumn(name="groupid")//表示t_user表中有个叫group_id的外键字段  
        private Set<User> users = new HashSet<User>();  
    }  
       
    @Entity  
    @Table(name="t_user")  
    public class User {  
        @Id  
        @GeneratedValue(strategy = GenerationType.IDENTITY)   
        private int id;  
       
        private String name;  
    }  

    fetch属性有两个值：EAGER和LAZY。分别表示即时加载和延迟加载，这是ORM框架引入的概念。

        fetch = FetchType.LAZY表示加载group时不加载user，一般一对多的时候，在一方默认为LAZY，因为如果多方数据太多，会导致大量数据的加载，影响性能  

    单边多对一：比如一个组（Group）里有多个用户（User），User类中有Group类的成员变量：

[java] view plain copy

print ?

1. @Entity    
2. @Table(name="t_group")//group在sql中是关键词，避免冲突    
3. public class Group {    
4.     @Id    
5.     @GeneratedValue(strategy = GenerationType.IDENTITY)    
6.     private int id;    
7.      
8.     @Column(unique = true)//利用unique约束禁止重复数据    
9.     private String name;    
10. }    
11.      
12. @Entity    
13. @Table(name="t_user")    
14. public class User {    
15.     @Id    
16.     @GeneratedValue(strategy = GenerationType.IDENTITY)     
17.     private int id;    
18.      
19.     private String name;    
20.      
21.     @ManyToOne(cascade = {CascadeType.ALL}, fetch = FetchType.EAGER)    
22.     @JoinColumn(name = "group_id")    
23.     private Group group;    
24. }    

    @Entity  
    @Table(name="t_group")//group在sql中是关键词，避免冲突  
    public class Group {  
        @Id  
        @GeneratedValue(strategy = GenerationType.IDENTITY)  
        private int id;  
       
        @Column(unique = true)//利用unique约束禁止重复数据  
        private String name;  
    }  
       
    @Entity  
    @Table(name="t_user")  
    public class User {  
        @Id  
        @GeneratedValue(strategy = GenerationType.IDENTITY)   
        private int id;  
       
        private String name;  
       
        @ManyToOne(cascade = {CascadeType.ALL}, fetch = FetchType.EAGER)  
        @JoinColumn(name = "group_id")  
        private Group group;  
    }  

   fetch = FetchType.EAGER表示加载user时加载group，多对一的时候，默认为EAGER

3. 双边一对多、多对一

    比如一个组（Group）里有多个用户（User），Group类中有存储User的集合，User类中有Group类的成员变量：

[java] view plain copy

print ?

1. @Entity    
2. @Table(name="t_group")    
3. public class Group {    
4.     @Id    
5.     @GeneratedValue(strategy = GenerationType.IDENTITY)    
6.     private int id;    
7.      
8.     private String name;    
9.      
10.     @OneToMany(mappedBy = "group")//表示已经在User类中对group做了映射了。一般有双向关联的都要设置mappedBy     
11.     private Set<User> users = new HashSet<User>();    
12. }    
13.      
14. @Entity    
15. @Table(name="t_user")    
16. public class User {    
17.     @Id    
18.     @GeneratedValue(strategy = GenerationType.IDENTITY)     
19.     private int id;    
20.      
21.     private String name;    
22.      
23.     @ManyToOne(cascade = {CascadeType.ALL}, fetch = FetchType.EAGER)    
24.     @JoinColumn(name = "group_id")    
25.     private Group group;    
26. }    

    @Entity  
    @Table(name="t_group")  
    public class Group {  
        @Id  
        @GeneratedValue(strategy = GenerationType.IDENTITY)  
        private int id;  
       
        private String name;  
       
        @OneToMany(mappedBy = "group")//表示已经在User类中对group做了映射了。一般有双向关联的都要设置mappedBy   
        private Set<User> users = new HashSet<User>();  
    }  
       
    @Entity  
    @Table(name="t_user")  
    public class User {  
        @Id  
        @GeneratedValue(strategy = GenerationType.IDENTITY)   
        private int id;  
       
        private String name;  
       
        @ManyToOne(cascade = {CascadeType.ALL}, fetch = FetchType.EAGER)  
        @JoinColumn(name = "group_id")  
        private Group group;  
    }  

    双边关系中，控制权一般交给多方，因此这里@OneToMany没有配置数据库的外键列，而只配置了一个mappyedBy属性，告诉Hibernate，配置信息要到Student类中的group属性中去找。 

4. 单边多对多和双边多对多

    单边多对多：比如老师（Teacher）有多个（Student），学生也有多个老师，但是只有Teacher类中有存储Student类的集合：

[java] view plain copy

print ?

1. @Entity    
2. public class Teacher {    
3.     @Id    
4.     @GeneratedValue(strategy = GenerationType.IDENTITY)     
5.     private int id;    
6.      
7.     private String name;        
8.      
9.     @ManyToMany    
10.     @JoinTable(    
11.         name = "t_s",//第三张中间表名    
12.         joinColumns = {@JoinColumn(name="teacher_id")},//第三张表中针对本表主键字段名称    
13.         inverseJoinColumns = {@JoinColumn(name="student_id")}//第三张表中针对对方(student)表中主键名称    
14.         )    
15.     private Set<Student> students = new HashSet<Student>();    
16. }    
17.      
18. @Entity    
19. public class Student {    
20.     @Id    
21.     @GeneratedValue(strategy = GenerationType.IDENTITY)      
22.     private int id;    
23.      
24.     private String name;    
25. }    

    @Entity  
    public class Teacher {  
        @Id  
        @GeneratedValue(strategy = GenerationType.IDENTITY)   
        private int id;  
       
        private String name;      
       
        @ManyToMany  
        @JoinTable(  
            name = "t_s",//第三张中间表名  
            joinColumns = {@JoinColumn(name="teacher_id")},//第三张表中针对本表主键字段名称  
            inverseJoinColumns = {@JoinColumn(name="student_id")}//第三张表中针对对方(student)表中主键名称  
            )  
        private Set<Student> students = new HashSet<Student>();  
    }  
       
    @Entity  
    public class Student {  
        @Id  
        @GeneratedValue(strategy = GenerationType.IDENTITY)    
        private int id;  
       
        private String name;  
    }  

    双边多对多只要在Student类中添加存储Teacher类的集合即可，并配有mappedBy属性。

[java] view plain copy

print ?

1. @ManyToMany(mappedBy="students")    
2. private Set<Teacher> teachers = new HashSet<Teacher>();    

    @ManyToMany(mappedBy="students")  
    private Set<Teacher> teachers = new HashSet<Teacher>();  

5. 主键相同的单边一对一和双边一对一

    由于两个实体类是一对一的关系，因此可以设置两个实体类使用相同的主键。反过来，具有相同主键的实体被视为一对一的关系。

    针对上面一对一关系的例子，通过主键相同的方法如下：

    单边一对一：

[java] view plain copy

print ?

1. @Entity    
2. @Table(name = "student")    
3. public class Student {    
4.     @Id    
5.     @GeneratedValue(strategy = GenerationType.IDENTITY)     
6.     private String id;    
7.      
8.     private String name;    
9.      
10.     @OneToOne(cascade = {CascadeType.ALL})    
11.     @PrimaryKeyJoinColumn    
12.     private StudentCard stuCard;    
13. }    
14.      
15. @Entity    
16. @Table(name = "studentid")    
17. public class StudentCard {    
18.     @Id    
19.     //这里不能使用自增长了     
20.     private String id;    
21.      
22.     private int num;    
23. }    

    @Entity  
    @Table(name = "student")  
    public class Student {  
        @Id  
        @GeneratedValue(strategy = GenerationType.IDENTITY)   
        private String id;  
       
        private String name;  
       
        @OneToOne(cascade = {CascadeType.ALL})  
        @PrimaryKeyJoinColumn  
        private StudentCard stuCard;  
    }  
       
    @Entity  
    @Table(name = "studentid")  
    public class StudentCard {  
        @Id  
        //这里不能使用自增长了   
        private String id;  
       
        private int num;  
    }  

    双边一对一：

[java] view plain copy

print ?

1. @Entity    
2. public class Husband {    
3.     @Id    
4.     @GeneratedValue(strategy = GenerationType.IDENTITY)    
5.     private int id;    
6.      
7.     private String name;    
8.      
9.     @OneToOne    
10.     @PrimaryKeyJoinColumn    
11.     private Wife wife;    
12. }    
13.      
14. @Entity    
15. public class Wife {    
16.     @Id    
17.     //这里不能使用自增长了     
18.     private int id;    
19.      
20.     private String name;    
21.      
22.     @OneToOne    
23.     @PrimaryKeyJoinColumn    
24.     private Husband husband;    
25. }    

    @Entity  
    public class Husband {  
        @Id  
        @GeneratedValue(strategy = GenerationType.IDENTITY)  
        private int id;  
       
        private String name;  
       
        @OneToOne  
        @PrimaryKeyJoinColumn  
        private Wife wife;  
    }  
       
    @Entity  
    public class Wife {  
        @Id  
        //这里不能使用自增长了   
        private int id;  
       
        private String name;  
       
        @OneToOne  
        @PrimaryKeyJoinColumn  
        private Husband husband;  
    }  

        要注意的是save Husband和Wife的时候，先session.save(husband)，在session.save(wife)之前要先设置wife的id和husband相同，即：wife.setId(husband.getId())  

        以上就是hibernate中实体关系映射的几种情况。如有错误，欢迎留言指正~

_____________________________________________________________________________________________________________________________________________________

-----乐于分享，共同进步！

-----更多文章请看：http://blog.csdn.net/eson_15