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属性。