Hibernate annotation的关系定义

一、@OneToOne

 

代码
  1. @Entity  
  2. public class User{   
  3.     private Address address;   
  4.   
  5.     @OneToOne  
  6.     public Address getAddress() {   
  7.         return address;   
  8.      }   
  9.   
  10.     public void setAddress(Address address) {   
  11.         this.address = address;   
  12.      }   
  13. }   
  14.   
  15. @Entity  
  16. public class Address{   
  17.     private User user;   
  18.   
  19.     @OneToOne(mappedBy = "address")   
  20.     public User getUser() {   
  21.         return user;   
  22.      }   
  23.   
  24.     public void setUser(User user) {   
  25.         this.user = user;   
  26.      }   
  27.   
  28. }  

1、两边都定义了@OneToOne,但都没有定义mappedBy,则user和address表都会生成到对方的外键,双方都是这个关系的拥有者。 
2、两边都定义了@OneToOne,如果user定义了mappedBy,则在address表生成到user的外键,address是这个关系的拥有者;如果address定义了mappedBy,则在user表生成到address的外键,user是这个关系的拥有者。 
二、@ManyToOne和@OneToMany

 

 

代码
  1. @Entity  
  2. public class Employee {   
  3. private Department department;   
  4.   
  5. @ManyToOne  
  6. public Department getDepartment() {   
  7. return department;   
  8. }   
  9.   
  10. public void setDepartment(Department department) {   
  11. this.department = department;   
  12. }   
  13. }   
  14.   
  15. @Entity  
  16. public class Department {   
  17. private Set<Employee> employees = new HashSet<Employee>();   
  18.   
  19. @OneToMany(mappedBy="department")   
  20. public Collection<Employee> getEmployees() {   
  21. return employees;   
  22. }   
  23. public void setEmployees(Collection<Employee> employees) {   
  24. this.employees = employees;   
  25. }   
  26. }  

@ManyToOne中Many指的是本类(也就是声明@ManeyToOne的类),One是指关联类,也就是To前边的对应本类,后边的对应关联类。如果方法返回的是单数关联类则定义@ManyToOne,例如: 
代码
  1. @ManyToOne  
  2. public Department getDepartment() {   
  3. return department;   
  4. }  

方法返回的是Department,为单数关联类,对应@ManyToOne中的One; 
如果返回的是复数关联类则定义@OneToMany,例如: 
代码
  1. @OneToMany(mappedBy="department")   
  2. public Collection<Employee> getEmployees() {   
  3. return employees;   
  4. }  

方法返回的是Collection<Employee>,复数关联类,对应@OneToMany中的Many。其中定义mappedBy的是@OneToMany,也就是说One这一方是关系的拥有者。Many一方的表中生成到关联类的外键。

 

三、@ManyToMany

 

代码
  1. @Entity  
  2. public class Book {   
  3. private Set authors = new HashSet<Author>();   
  4.   
  5. @ManyToMany  
  6. public Set<Author> getAuthors(){   
  7. return authors;   
  8. }   
  9.        
  10. Public void setAuthors(Set<Author> authors){   
  11.     This.authors = authors;   
  12. }   
  13. }   
  14.   
  15. @Entity  
  16. public class Author {   
  17. private Set books = new HashSet<Book>();   
  18.   
  19. @ManyToMany(mappedBy="authors")   
  20. public Set<Book> getBooks(){   
  21. return books;   
  22. }   
  23.   
  24. Public void setBooks(Set<Book> books){   
  25.     This.books = books;   
  26. }   
  27. }   

@ManyToMany会生成中间表,具体表名和字段可以通过@AssociationTable来定义,默认的就可以了,同样关系的非拥有者,需要定义mappedBy属性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值