Hibernate实体关系映射—Annotation

  1. 云栖社区>
  2. 博客>
  3. 正文

Hibernate实体关系映射—Annotation

shy丶gril 2016-05-26 10:50:24 浏览1314
展开阅读全文

hibernate实体关系映射分为:

    单边一对一,双边一对一;

    单边一对多,单边多对一;

    双边一对多,双边多对一;

    单边多对多,双边多对多;

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

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

    单边一对一:比如一个学生(Student)有一个学生证(StudentCard),且Student类中有一个StudentCard对象:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  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. }   
    @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
 在CODE上查看代码片派生到我的代码片
  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. }    

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

    单边一对多:比如一个组(Group)里有多个用户(User),Group类中有存储User的集合:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  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. }    
    fetch属性有两个值:EAGER和LAZY。分别表示即时加载和延迟加载,这是ORM框架引入的概念。

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

    单边多对一:比如一个组(Group)里有多个用户(User),User类中有Group类的成员变量:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  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. }    
   fetch = FetchType.EAGER表示加载user时加载group,多对一的时候,默认为EAGER

3. 双边一对多、多对一

    比如一个组(Group)里有多个用户(User),Group类中有存储User的集合,User类中有Group类的成员变量:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  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. }    
    双边关系中,控制权一般交给多方,因此这里@OneToMany没有配置数据库的外键列,而只配置了一个mappyedBy属性,告诉Hibernate,配置信息要到Student类中的group属性中去找。 

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

    单边多对多:比如老师(Teacher)有多个(Student),学生也有多个老师,但是只有Teacher类中有存储Student类的集合:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  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. }    
    双边多对多只要在Student类中添加存储Teacher类的集合即可,并配有mappedBy属性。
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. @ManyToMany(mappedBy="students")    
  2. private Set<Teacher> teachers = new HashSet<Teacher>();    

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

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

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

    单边一对一:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  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. }    

    双边一对一:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  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. }    

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

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


转载:http://blog.csdn.net/eson_15/article/details/51089666

网友评论

登录后评论
0/500
评论