Hibernate annotation 的各种关系

转的：

 

一、@OneToOne

Java代码   

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 

Java代码   

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，不写其他配置，那么，会生成3张表，其中一张为关系表(默认为多对多)

所以最好是加上@JoinColumn(name="**id")

@ManyToOne中Many指的是本类（也就是声明@ManeyToOne的类），One是指关联类，也就是To前边的对应本类，后边的对应关联类。如果方法返回的是单数关联类则定义@ManyToOne，例如： 

Java代码   

1. @ManyToOne   
2. public  Department getDepartment() {  
3. return  department;  
4. }  

方法返回的是Department，为单数关联类，对应@ManyToOne中的One； 
如果返回的是复数关联类则定义@OneToMany，例如： 

Java代码   

1. @OneToMany (mappedBy= "department" )  
2. public  Collection<Employee> getEmployees() {  
3. return  employees;  
4. }  

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

三、@ManyToMany 

Java代码   

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.   
20. @ManyToMany (mappedBy= "authors" )  
21. public  Set<Book> getBooks(){  
22. return  books;  
23. }  
24.   
25. Public void  setBooks(Set<Book> books){  
26.    This.books = books;  
27. }  
28. }  

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