hibernate annotation 之mappedBy 与 @JoinColumn区别

最新推荐文章于 2022-05-24 13:56:56 发布

原创最新推荐文章于 2022-05-24 13:56:56 发布 · 604 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

jpa & hibernate & mybatis

本文详细介绍了ORM中一对一、一对多及多对多的映射方式，包括如何通过注解实现不同映射关系，并探讨了关联关系的维护策略。

1.一对多的映射(one-to-many)

[java]view plaincopy 
   
 @Entity  
 @Table(name="t_classroom")  
 public class ClassRoom  
 {  
     private int id;  
     private String className;  
     private Set<Student> students;  
    
     @OneToMany(mappedBy="room")　　  
     --->OneToMany指定了一对多的关系，mappedBy="room"指定了由多的那一方来维护关联关系，mappedBy指的是多的一方对一的这一方的依赖的属性，  
     (注意：如果没有指定由谁来维护关联关系，则系统会给我们创建一张中间表)  
     @LazyCollection(LazyCollectionOption.EXTRA)　　  
     --->LazyCollection属性设置成EXTRA指定了当如果查询数据的个数时候，只会发出一条 count(*)的语句，提高性能  
     public Set<Student> getStudents()  
     {  
         return students;  
     }  
      
 }  
   
 @Entity  
 @Table(name="t_student")  
 public class Student  
 {  
     private int id;  
     private String name;  
     private int age;  
     private ClassRoom room;  
       
     @ManyToOne(fetch=FetchType.LAZY)　　  
     ---> ManyToOne指定了多对一的关系，fetch=FetchType.LAZY属性表示在多的那一方通过延迟加载的方式加载对象(默认不是延迟加载)  
     @JoinColumn(name="rid")　　  
     --->通过 JoinColumn 的name属性指定了外键的名称 rid　(注意：如果我们不通过JoinColum来指定外键的名称，系统会给我们声明一个名称)  
     public ClassRoom getRoom()  
     {  
         return room;  
     }  
      
 }  

在判断到底是谁维护关联关系时，可以通过查看外键，哪个实体类定义了外键，哪个类就负责维护关联关系。

2.一对一映射(One-to-One)

[java]view plaincopy 
   
 @Entity  
 @Table(name="t_person")  
 public class Person  
 {  
     private int id;  
     private String name;  
     private IDCard card;  
       
     @OneToOne(mappedBy="person")　　  
     --->指定了OneToOne的关联关系，mappedBy同样指定由对方来进行维护关联关系  
     public IDCard getCard()  
     {  
         return card;  
     }  
 }  
   
 @Entity  
 @Table(name="t_id_card")  
 public class IDCard  
 {  
     private int id;  
     private String no;  
     private Person person;  
     
     @OneToOne　　  
     --->OnetoOne指定了一对一的关联关系，一对一中随便指定一方来维护映射关系，这里选择IDCard来进行维护  
     @JoinColumn(name="pid")　　  
     --->指定外键的名字 pid  
     public Person getPerson()  
     {  
         return person;  
     }     
 }  

3.Many-to-Many映射(多对多映射关系)

3.1通过中间表由任一一个多的一方来维护关联关系

[java]view plaincopy 
   
 @Entity  
 @Table(name="t_teacher")  
 public class Teacher  
 {  
     private int id;  
     private String name;  
     private Set<Course> courses;  
        
     @ManyToMany(mappedBy="teachers")　　  
     --->表示由Course那一方来进行维护  
     public Set<Course> getCourses()  
     {  
         return courses;  
     }      
 }  
   
 @Entity  
 @Table(name="t_course")  
 public class Course  
 {  
     private int id;  
     private String name;  
     private Set<Teacher> teachers;  
         
     @ManyToMany　　　--->　ManyToMany指定多对多的关联关系  
     @JoinTable(name="t_teacher_course", joinColumns={ @JoinColumn(name="cid")}, inverseJoinColumns={ @JoinColumn(name = "tid") })　　  
     --->因为多对多之间会通过一张中间表来维护两表直接的关系，所以通过 JoinTable 这个注解来声明，name就是指定了中间表的名字，  
     JoinColumns是一个 @JoinColumn类型的数组，表示的是我这方在对方中的外键名称，我方是Course，所以在对方外键的名称就是 rid，  
     inverseJoinColumns也是一个 @JoinColumn类型的数组，表示的是对方在我这放中的外键名称，对方是Teacher，所以在我方外键的名称就是 tid  
     public Set<Teacher> getTeachers()  
     {  
         return teachers;  
     }  
 }  

3.2 将Many-to-Many拆分成两个One-to-Many的映射(Admin、Role、AdminRole)

[java]view plaincopy 
   
 @Entity  
 @Table(name="t_admin")  
 public class Admin  
 {  
     private int id;  
     private String name;  
     private Set<AdminRole> ars;  
      
     public Admin()  
     {  
         ars = new HashSet<AdminRole>();  
     }  
     public void add(AdminRole ar)  
     {  
         ars.add(ar);  
     }  
     
     @OneToMany(mappedBy="admin")　　  
     --->OneToMany关联到了AdminRole这个类，由AdminRole这个类来维护多对一的关系，mappedBy="admin"  
     @LazyCollection(LazyCollectionOption.EXTRA)　　  
     public Set<AdminRole> getArs()  
     {  
         return ars;  
     }   
 }  
   
 @Entity  
 @Table(name="t_role")  
 public class Role  
 {  
     private int id;  
     private String name;  
     private Set<AdminRole> ars;  
   
     public Role()  
     {  
         ars = new HashSet<AdminRole>();  
     }  
     public void add(AdminRole ar)  
     {  
         ars.add(ar);  
     }  
      
     @OneToMany(mappedBy="role")　　  
     --->OneToMany指定了由AdminRole这个类来维护多对一的关联关系，mappedBy="role"  
     @LazyCollection(LazyCollectionOption.EXTRA)  
     public Set<AdminRole> getArs()  
     {  
         return ars;  
     }   
 }  
   
   
 @Entity  
 @Table(name="t_admin_role")  
 public class AdminRole  
 {  
     private int id;  
     private String name;  
     private Admin admin;  
     private Role role;  
      
     @ManyToOne　　--->　　ManyToOne关联到Admin  
     @JoinColumn(name="aid")　　  
     public Admin getAdmin()  
     {  
         return admin;  
     }  
      
     @ManyToOne　　--->　　  
     @JoinColumn(name="rid")  
     public Role getRole()  
     {  
         return role;  
     }   
 }  

通过hibernate来进行插入操作的时候，不管是一对多、一对一还是多对多，都只需要记住一点，在哪个实体类声明了外键，就由哪个类来维护关系，

在保存数据时，总是先保存的是没有维护关联关系的那一方的数据，后保存维护了关联关系的那一方的数据，如：

[java]view plaincopy 
   
 Person p = new Person();  
 p.setName("xiaoluo");  
 session.save(p);  
               
 IDCard card = new IDCard();  
 card.setNo("1111111111");  
 card.setPerson(p);  
 session.save(card);  