jpa和hibernate注解

http://www.objectdb.com/api/java/jpa/JoinColumns

用hibernate和jpa annotation 大概一年多了，今天闲来无事，对他们关联关系元数据写法做一个总结。 
1.一对一主键关联 
这个在实际项目中用的比较少，大部分是通过用外键做关联的，这里用用户和手机号举个例子，用户和手机号是一对一的关系，代码如下： 
User实体

1. package com.own.model;
2. import java.io.Serializable;
3. public class Users implements Serializable{
4. private static final long serialVersionUID = 1381652232198529039L;
5. private int id;
6. private String username;
7. private String password;
8. private CellphoneNumber phoneNumber;
9. public CellphoneNumber getPhoneNumber() {
10. return phoneNumber;
11. }
12. public void setPhoneNumber(CellphoneNumber phoneNumber) {
13. this.phoneNumber = phoneNumber;
14. }
15. public int getId() {
16. return id;
17. }
18. public void setId(int id) {
19. this.id = id;
20. }
21. public String getUsername() {
22. return username;
23. }
24. public void setUsername(String username) {
25. this.username = username;
26. }
27. public String getPassword() {
28. return password;
29. }
30. public void setPassword(String password) {
31. this.password = password;
32. }
33. }

手机号实体

1. package com.own.model;
2. import java.io.Serializable;
3. public class CellphoneNumber implements Serializable {
4. private static final long serialVersionUID = -1029364968566042141L;
5. private Integer cellPhoneId;
6. private String number;
7. private String attribution;//手机归属地
8. private String cellphonoeType;//移动或者联通
9. private Users user ;
10. public Users getUser() {
11. return user;
12. }
13. public void setUser(Users user) {
14. this.user = user;
15. }
16. public Integer getCellPhoneId() {
17. return cellPhoneId;
18. }
19. public void setCellPhoneId(Integer cellPhoneId) {
20. this.cellPhoneId = cellPhoneId;
21. }
22. public String getNumber() {
23. return number;
24. }
25. public void setNumber(String number) {
26. this.number = number;
27. }
28. public String getAttribution() {
29. return attribution;
30. }
31. public void setAttribution(String attribution) {
32. this.attribution = attribution;
33. }
34. public String getCellphonoeType() {
35. return cellphonoeType;
36. }
37. public void setCellphonoeType(String cellphonoeType) {
38. this.cellphonoeType = cellphonoeType;
39. }
40. @Override
41. public boolean equals(Object anotherObject){
42. if(anotherObject == null || anotherObject.getClass() != this.getClass()){
43. return false;
44. }
45. if(this == anotherObject){
46. return true;
47. }
48. CellphoneNumber another = (CellphoneNumber) anotherObject;
49. if(another.cellPhoneId.equals(this.cellPhoneId)){
50. return true  ;
51. }
52. return false;
53. }
54. public int hashCode(){
55. return cellPhoneId.hashCode();
56. }
57. }

users映射文件

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping >
6. <class name="com.own.model.Users"  table="users"  dynamic-update="true"  dynamic-insert="true"     >
7. <id name="id"  column="id" >
8. <generator class="native"></generator>
9. </id>
10. <property name="username"  column="username"   ></property>
11. <property name="password"  column="password" type="string"  ></property>
12. <!-- 这里是一对一映射 级联为所有 -->
13. <one-to-one name="phoneNumber" class="com.own.model.CellphoneNumber" cascade="all"  >
14. </one-to-one>
15. </class>
16. </hibernate-mapping>

cellPhone映射文件

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping >
6. <class name="com.own.model.CellphoneNumber"  table="cellphone"  dynamic-update="true"  dynamic-insert="true"   >
7. <!-- 这里设置外键关联 -->
8. <id name="cellPhoneId"  column="id" >
9. <generator class="foreign">
10. <!-- 这里设置用引用user实体的主键  -->
11. <param name="property">user</param>
12. </generator>
13. </id>
14. <property name="number"  column="cellphoneNumber" ></property>
15. <property name="attribution"  column="attribution"   ></property>
16. <property name="cellphonoeType"  column="numberType"   ></property>
17. <!-- 加上外键约束  ,使Cellphone的主键引用user表行的主键 -->
18. <one-to-one name="user" constrained="true"  class="com.own.model.Users"  ></one-to-one>
19. </class>
20. </hibernate-mapping>

在调用时，要设置关联关系

1. Users u = new Users();
2. u.setPassword("admin@1973");
3. u.setUsername("floatSnow");
4. CellphoneNumber cellphone = new CellphoneNumber();
5. cellphone.setAttribution("北京");
6. cellphone.setCellphonoeType("中国移动");
7. cellphone.setNumber("13476534589");
8. //设置双向关联关系
9. u.setPhoneNumber(cellphone);
10. cellphone.setUser(u);

jpa中使用@PrimaryKeyJoinColumn

1. package com.own.model;
2. import java.io.Serializable;
3. import javax.persistence.CascadeType;
4. import javax.persistence.Column;
5. import javax.persistence.Entity;
6. import javax.persistence.GeneratedValue;
7. import javax.persistence.Id;
8. import javax.persistence.OneToOne;
9. import javax.persistence.PrimaryKeyJoinColumn;
10. import javax.persistence.Table;
11. @Entity
12. @org.hibernate.annotations.Entity(dynamicInsert=true,dynamicUpdate=true)
13. @Table(name="users")
14. public class Users implements Serializable{
15. private static final long serialVersionUID = 1381652232198529039L;
16. private int id;
17. private String username;
18. private String password;
19. private CellphoneNumber cellphone;
20. @OneToOne(cascade={CascadeType.ALL})
21. @PrimaryKeyJoinColumn
22. public CellphoneNumber getCellphone() {
23. return cellphone;
24. }
25. public void setCellphone(CellphoneNumber cellphone) {
26. this.cellphone = cellphone;
27. }
28. @Id
29. @GeneratedValue
30. @Column(name="id")
31. public int getId() {
32. return id;
33. }
34. public void setId(int id) {
35. this.id = id;
36. }
37. @Column(name="username")
38. public String getUsername() {
39. return username;
40. }
41. public void setUsername(String username) {
42. this.username = username;
43. }
44. @Column(name="password")
45. public String getPassword() {
46. return password;
47. }
48. public void setPassword(String password) {
49. this.password = password;
50. }
51. }

2.一对一外键关联 
hibernate xml文件映射，在这里使用manyToOne而不是我们想像的oneToOne,还有在  user表中加一个外键，引用另一个表的主键,这里设置双向关系，在项目中根据情况而定是否设置双向关系 
映射文件

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping >
6. <class name="com.own.model.Users"  table="users"  dynamic-update="true"  dynamic-insert="true" >
7. <id name="id"  column="id" >
8. <generator class="native"></generator>
9. </id>
10. <property name="username"  column="username"   ></property>
11. <property name="password"  column="password" type="string"  ></property>
12. <!-- 加上唯一约束，使这个关系成为真正的一对一 -->
13. <many-to-one name="phoneNumber" cascade="all" class="com.own.model.CellphoneNumber"  column="cell_id"
14. unique="true"  >
15. </many-to-one>
16. </class>
17. </hibernate-mapping>

jpa 映射使用oneToone,@joinColumn有两个属性 name 和 referencedColumnName 
，name是表示表中外键的列名，referencedColumnName表示外键引用的表的列名。 
user实体

1. @OneToOne(cascade={CascadeType.ALL})
2. @JoinColumn(name="cell_id",referencedColumnName="id")
3. public CellphoneNumber getCellphone() {
4. return cellphone;
5. }

手机实体类

1. @OneToOne(mappedBy="cellphone")
2. ublic Users getU() {
3. return u;

3.一对一可选关联 
有的时候我们的外键是可选的，也就是说user表的外键是可以为空的，这个时候我们可以把这中可选的关联映射到一张表，加一张中间表，表示实体的对应关系 
Users实体映射文件

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping >
6. <class name="com.own.model.Users"  table="users"  dynamic-update="true"  dynamic-insert="true" >
7. <id name="id"  column="id" >
8. <generator class="native"></generator>
9. </id>
10. <property name="username"  column="username"   ></property>
11. <property name="password"  column="password" type="string"  ></property>
12. <!-- 加上唯一约束，使这个关系成为真正的一对一 -->
13. <!-- optional 告诉hibernate这个关系是可选的 ，当这个属性为空时，可以不插入关联表 -->
14. <join table="user_cellphoneNumber"      >
15. <key column="user_id"    unique="true"  />
16. <many-to-one name="phoneNumber"  cascade="save-update"      class="com.own.model.CellphoneNumber"   column="cell_id"
17. unique="true"     >
18. </many-to-one>
19. </join>
20. </class>
21. </hibernate-mapping>

jpa注解把属性映射到两张表，通过使用@SecondaryTable,使属性映射到一张中间表。

1. package com.own.model;
2. import java.io.Serializable;
3. import javax.persistence.CascadeType;
4. import javax.persistence.Column;
5. import javax.persistence.Entity;
6. import javax.persistence.GeneratedValue;
7. import javax.persistence.Id;
8. import javax.persistence.JoinColumn;
9. import javax.persistence.OneToOne;
10. import javax.persistence.PrimaryKeyJoinColumn;
11. import javax.persistence.SecondaryTable;
12. import javax.persistence.Table;
13. import org.hibernate.transaction.JOnASTransactionManagerLookup;
14. @Entity
15. @org.hibernate.annotations.Entity(dynamicInsert=true,dynamicUpdate=true)
16. @Table(name="users")
17. @SecondaryTable(name="user_cellphoneNumber",pkJoinColumns={@PrimaryKeyJoinColumn(name="user_id",referencedColumnName="id")})
18. public class Users implements Serializable{
19. private static final long serialVersionUID = 1381652232198529039L;
20. private int id;
21. private String username;
22. private String password;
23. private CellphoneNumber cellphone;
24. @OneToOne(cascade={CascadeType.ALL})
25. @JoinColumn(table="user_cellphoneNumber",name="cell_id",referencedColumnName="id")
26. public CellphoneNumber getCellphone() {
27. return cellphone;
28. }
29. public void setCellphone(CellphoneNumber cellphone) {
30. this.cellphone = cellphone;
31. }
32. @Id
33. @GeneratedValue
34. @Column(name="id")
35. public int getId() {
36. return id;
37. }
38. public void setId(int id) {
39. this.id = id;
40. }
41. @Column(name="username")
42. public String getUsername() {
43. return username;
44. }
45. public void setUsername(String username) {
46. this.username = username;
47. }
48. @Column(name="password")
49. public String getPassword() {
50. return password;
51. }
52. public void setPassword(String password) {
53. this.password = password;
54. }
55. }

4.一对多关联 
一对多关联通过oneToMany和ManyToMany映射，这里的多段在java里用一个集合set来表示，这个用商品category和货物Goods来举例子。 
one端实体Category 映射xml

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping >
6. <class name="com.own.model.Category"  table="category"  dynamic-insert="true" dynamic-update="false"      >
7. <id name="category_id"  column="id" >
8. <generator class="native"></generator>
9. </id>
10. <property name="categoryName"  column="category_name" type="string"  ></property>
11. <set name="goodsSet" inverse="true"  cascade="save-update"   >    <!-- 用key column 的名字表示关联表的外键的名称  -->
12. <key column="category_id"    />
13. <one-to-many  class="com.own.model.Goods"   />
14. </set>
15. </class>
16. </hibernate-mapping>

many端的映射文件

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping   >
6. <class name="com.own.model.Goods"  table="goods"  dynamic-insert="true" dynamic-update="false"      >
7. <id name="id"  column="goods_id" >
8. <generator class="native"></generator>
9. </id>
10. <property name="price"  column="goods_price" type="double"  ></property>
11. <property name="goodsName"  column="goods_name" type="string"  ></property>
12. <property name="goodsDescription"  column="goods_description" type="string"  ></property>
13. <many-to-one name="category"      fetch="join"    class="com.own.model.Category"  column="category_id"      >
14. </many-to-one>
15. </class>
16. </hibernate-mapping>

jpa元数据注解 
Category实体

1. package com.own.model;
2. import java.io.Serializable;
3. import java.util.HashSet;
4. import java.util.Set;
5. import javax.persistence.CascadeType;
6. import javax.persistence.Column;
7. import javax.persistence.Entity;
8. import javax.persistence.GeneratedValue;
9. import javax.persistence.Id;
10. import javax.persistence.OneToMany;
11. import javax.persistence.Table;
12. @Entity
13. @org.hibernate.annotations.Entity(dynamicInsert=true,dynamicUpdate=true)
14. @Table(name="category")
15. public class Category implements Serializable {
16. private static final long serialVersionUID = 1L;
17. private Integer category_id;
18. private String categoryName;
19. private Set<Goods> goodsSet = new HashSet<Goods>();
20. @OneToMany(mappedBy="category",cascade={CascadeType.ALL})
21. public Set<Goods> getGoodsSet() {
22. return goodsSet;
23. }
24. public void setGoodsSet(Set<Goods> goodsSet) {
25. this.goodsSet = goodsSet;
26. }
27. @Id
28. @GeneratedValue
29. @Column(name="id")
30. public Integer getCategory_id() {
31. return category_id;
32. }
33. public void setCategory_id(Integer categoryId) {
34. category_id = categoryId;
35. }
36. @Column(name="category_name")
37. public String getCategoryName() {
38. return categoryName;
39. }
40. public void setCategoryName(String categoryName) {
41. this.categoryName = categoryName;
42. }
43. }

Goods实体

1. package com.own.model;
2. import java.io.Serializable;
3. import javax.persistence.Column;
4. import javax.persistence.Entity;
5. import javax.persistence.GeneratedValue;
6. import javax.persistence.GenerationType;
7. import javax.persistence.Id;
8. import javax.persistence.JoinColumn;
9. import javax.persistence.ManyToOne;
10. import javax.persistence.Table;
11. @Entity
12. @org.hibernate.annotations.Entity(dynamicInsert=true,dynamicUpdate=true)
13. @Table(name="goods")
14. public class Goods implements Serializable {
15. private static final long serialVersionUID = 1L;
16. private Integer id;
17. private  String goodsName;
18. private Double price;
19. private String goodsDescription;
20. private Category category;
21. @ManyToOne
22. @JoinColumn(name="category_id",referencedColumnName="id")
23. public Category getCategory() {
24. return category;
25. }
26. public void setCategory(Category category) {
27. this.category = category;
28. }
29. public Goods(){}
30. @Id
31. @GeneratedValue(strategy=GenerationType.AUTO)
32. @Column(name="goods_id")
33. public Integer getId() {
34. return id;
35. }
36. public void setId(Integer id) {
37. this.id = id;
38. }
39. @Column(name="goods_name",length=40,nullable=false)
40. public String getGoodsName() {
41. return goodsName;
42. }
43. public void setGoodsName(String goodsName) {
44. this.goodsName = goodsName;
45. }
46. @Column(name="goods_price")
47. public Double getPrice() {
48. return price;
49. }
50. public void setPrice(Double price) {
51. this.price = price;
52. }
53. @Column(name="goods_description")
54. public String getGoodsDescription() {
55. return goodsDescription;
56. }
57. public void setGoodsDescription(String goodsDescription) {
58. this.goodsDescription = goodsDescription;
59. }
60. @Override
61. public boolean equals(Object o) {
62. if(o == null || o.getClass() != this.getClass()){
63. return false;
64. }
65. if(o == this){
66. return true;
67. }
68. Goods goods = (Goods) o;
69. if(id == null ? goods.id == null : this.id.equals(goods.id)){
70. return true;
71. }
72. return false;
73. }
74. /*@Override
75. public int hashCode() {
76. //return this.id.hashCode();
77. return
78. }*/
79. }

5.多对多关联 
多对多关联用manyToMany来映射，这里用学生和选的课程，它们是多对多的关联，多对对 
关联通常需要一张中间表，这个表就两字段，学生id和课程id（这里中间表就两个字段） 
在java中用两set集合来表示 
student 映射文件

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping >
6. <class name="com.own.model.Student"  table="student"  dynamic-update="true"  dynamic-insert="true" >
7. <id name="studentId"  column="id" >
8. <generator class="native"></generator>
9. </id>
10. <property name="studentName"  column="student_name"   ></property>
11. <property name="studentNum"  column="student_no" type="string"  ></property>
12. <set name="cosrseSet"    table="student_course"  >
13. <!--  引用当前实体主键的外键名称   -->
14. <key  column="student_id"   />
15. <many-to-many column="course_id"  class="com.own.model.Course"   ></many-to-many>
16. </set>
17. </class>
18. </hibernate-mapping>

course映射文件

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping   >
6. <class name="com.own.model.Course"  table="course"  dynamic-update="true"     dynamic-insert="true" >
7. <id name="courseId"  column="id" >
8. <generator class="native"></generator>
9. </id>
10. <property name="courseName"  column="course_name"   ></property>
11. <property name="courseNum"   column="course_no"  ></property>
12. <set name="studentSet"  inverse="true"  cascade="all"    table="student_course"    >
13. <key  column="course_id"   />
14. <many-to-many column="student_id"  class="com.own.model.Student"   ></many-to-many>
15. </set>
16. </class>
17. </hibernate-mapping>

jpa元数据 
Student实体

1. package com.own.model;
2. import java.io.Serializable;
3. import java.util.HashSet;
4. import java.util.Set;
5. import javax.persistence.Column;
6. import javax.persistence.Entity;
7. import javax.persistence.GeneratedValue;
8. import javax.persistence.Id;
9. import javax.persistence.JoinColumn;
10. import javax.persistence.JoinTable;
11. import javax.persistence.ManyToMany;
12. import javax.persistence.Table;
13. @Entity
14. @Table(name="student")
15. public class Student implements Serializable {
16. private static final long serialVersionUID = 1L;
17. private Integer studentId;
18. private String studentName;
19. private String studentNum;
20. private Set<Course> cosrseSet = new HashSet<Course>();
21. @ManyToMany
22. @JoinTable(name="student_course",joinColumns={@JoinColumn(name="student_id")},
23. inverseJoinColumns={@JoinColumn(name="course_id")})
24. public Set<Course> getCosrseSet() {
25. return cosrseSet;
26. }
27. public void setCosrseSet(Set<Course> cosrseSet) {
28. this.cosrseSet = cosrseSet;
29. }
30. @Id
31. @GeneratedValue
32. @Column(name="id")
33. public Integer getStudentId() {
34. return studentId;
35. }
36. public void setStudentId(Integer studentId) {
37. this.studentId = studentId;
38. }
39. @Column(name="student_name")
40. public String getStudentName() {
41. return studentName;
42. }
43. public void setStudentName(String studentName) {
44. this.studentName = studentName;
45. }
46. @Column(name="student_no")
47. public String getStudentNum() {
48. return studentNum;
49. }
50. public void setStudentNum(String studentNum) {
51. this.studentNum = studentNum;
52. }
53. }

Course实体

1. package com.own.model;
2. import java.io.Serializable;
3. import java.util.HashSet;
4. import java.util.Set;
5. import javax.persistence.Column;
6. import javax.persistence.Entity;
7. import javax.persistence.GeneratedValue;
8. import javax.persistence.Id;
9. import javax.persistence.ManyToMany;
10. import javax.persistence.Table;
11. @Entity
12. @Table(name="course")
13. public class Course implements Serializable {
14. private static final long serialVersionUID = 1L;
15. private Integer courseId;
16. private String courseNum;
17. private String courseName;
18. private Set<Student> studentSet = new HashSet<Student>();
19. @ManyToMany(mappedBy="cosrseSet")
20. public Set<Student> getStudentSet() {
21. return studentSet;
22. }
23. public void setStudentSet(Set<Student> studentSet) {
24. this.studentSet = studentSet;
25. }
26. @Id
27. @GeneratedValue
28. @Column(name="id")
29. public Integer getCourseId() {
30. return courseId;
31. }
32. public void setCourseId(Integer courseId) {
33. this.courseId = courseId;
34. }
35. @Column(name="course_no")
36. public String getCourseNum() {
37. return courseNum;
38. }
39. public void setCourseNum(String courseNum) {
40. this.courseNum = courseNum;
41. }
42. @Column(name="course_name")
43. public String getCourseName() {
44. return courseName;
45. }
46. public void setCourseName(String courseName) {
47. this.courseName = courseName;
48. }
49. /* @Override
50. public boolean equals(Object o) {
51. if(o == null || o.getClass() != Course.class){
52. return false;
53. }
54. if(o == this){
55. return true;
56. }
57. Course another = (Course)o;
58. if(courseId == null ? another.courseId == null : courseId.equals(another.courseId)){
59. return true;
60. }
61. return  false;
62. }
63. @Override
64. public int hashCode() {
65. return super.hashCode();
66. // return 1;
67. }*/
68. }

在多对对关联的情况下，用的是set集合，实体要实现hashcode和equals，不然在更新关联表的时候会更新不了，比如学生不在选择这门课程，从set集合中remove掉这个课程，然后更新这个学生实体，代码如下，在不实现hashcode和equals更新不会成功，只有实现了才可以，hibernate返回了自己写的集合，PersistenceSet而不是HashSet，这也是为什么我们在实体中写set接口，不能写HashSet ... = new HashSet,要用 Set ... = new HashSet 。

1. tc = session.beginTransaction();
2. Student s1 = (Student) session.get(Student.class,9) ;
3. Course c = new Course();
4. s1.getCosrseSet().remove(c);
5. session.update(s1);//更新学生的选课
6. tc.commit();

最后讲解一下cascade和inverse这两个属性，刚用hibernate的时候也比较不理解，首先这两个属性没有任何关系，cascade表示级联，就是被关联的一段，比如cascade='save-update',级联保存和更新，在设置了cascade的端，保存这个对象，会一并保存关联的一端，省去了我们写保存关联端的代码，inverse表示有谁来维护关联，在一段设置inverse=true，则有关联对来维护关联关系，比如上面的例子，在course端设置了inverse=true，则有student来维护中间表，只有当插入student的时候，才向中间表插入数据，如果都设置inverse=true则会插入重复数据，如果不设置，则会出错，在jpa元数据注解中 用mappedBy来表示有那方来维护关联关系