jpa和hibernate注解

时间：2022-09-04 18:10:23

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来表示有那方来维护关联关系

jpa和hibernate注解的更多相关文章

  1. Hibernate注解与JPA

    Hibernate注解与JPA - charming的专栏 - CSDN博客http://blog.csdn.net/zxc123e/article/details/51499652 之前记录的一些东 ...

  2. hibernate注解JPA

    1.JPA与hibernate 什么是JPA ? java persistence api :java持久化api,同一的ORM规范,是由sun公司指定的规范接口,hibernate实现了JPA规范. ...

  3. Hibernate注解使用以及Spring整合

    Hibernate注解使用以及Spring整合 原文转自:http://wanqiufeng.blog.51cto.com/409430/484739 (1) 简介: 在过去几年里,Hibernate ...

  4. 【maven &plus; hibernate&lpar;注解&rpar; &plus;spring &plus;springMVC】 使用maven搭建项目

    研究,百度,查资料+好友帮助,使用MyEcplise2015工具,通过maven搭建hibernate+springMVC+spring的项目,数据库采用MySql5.5 不过使用的版本会在项目搭建过 ...

  5. JPA与Hibernate的关系

    1.JPA JPA全称: Java Persistence API  JPA通过JDK 5.0注解或XML描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中.  JPA的出现?  JPA ...

  6. 谈论Hibernate级联删除——JPA根据Hibernate实现许多级联删除CascadeType&period;DELETE&lowbar;ORPHAN

    声明: 1.这篇文章是原创.非复制或转载过来. 2.在本文中,参数都亲自做过实验证明. 3.这篇文章谈到了Hibernate配置基于注释的方法.hbm语法不可用. 不清JPA.Hibernate.EJ ...

  7. 利用Eclipse的JPA自动生成注解实体

    新公司用的SSH(springmvc)框架,看代码的时候,发现没有hbm.xml文件,全部使用的注解形式.在一次闲聊的时候问同事,这么多entity  写起来不麻烦么.同事说根据数据库自动生成的.于是 ...

  8. 三。Hibernate 注解形式

    Hibernate支持JPA注解的jar包 JPA全称: Java Persistence API JPA和Hibernate之间的关系,可以简单的理解为JPA是标准接口,Hibernate是实现. ...

  9. SpringMVC&plus;Apache Shiro&plus;JPA（hibernate）整合配置

    序: 关于标题: 说是教学,实在愧不敢当,但苦与本人文笔有限,实在找不到更合理,谦逊的词语表达,只能先这样定义了. 其实最真实的想法,只是希望这个关键词能让更多的人浏览到这篇文章,也算是对于自己写文章 ...

随机推荐

  1. 详解C语言的类型转换

    1.自动类型转换 字符型变量的值实质上是一个8位的整数值,因此取值范围一般是-128-127,char型变量也可以加修饰符unsigned,则unsigned char 型变量的取值范围是0-255( ...

  2. SharePoint配置搜索服务和指定搜索范围

    转载:http://constforce.blog.163.com/blog/static/163881235201201211843334/ 一.配置SharePoint Foundation搜索 ...

  3. 使用MVVM框架时，如何处理在页面动态渲染完之后需要发生的事件呢？

    在项目实践过程中,当我们使用如avalon这样的MVVM框架时,通常会发现一直会有个问题. 过往的经验告诉我们,想在页面加载完之后处理些事件我们可以绑定document的ready方法或者使用jque ...

  4. iframe 使用

    iframe框架中的页面与主页面之间的通信方式根据iframe中src属性是同域链接还是跨域链接,有明显不同的通信方式,同域下的数据交换和DOM元素互访就简单的多了,而跨域的则需要一些巧妙的方式来实现 ...

  5. OpenCV 之 数字图像

    1  数字图像 数字图像可看作一个数值矩阵, 其中的每个元素代表一个像素点,如下图所示: 2  存储 M行N列图像的存储位数: b = M * N * k   ( L=2k, l ∈ [0, L-1] ...

  6. web前端笔试题

    1, 判断字符串是否是这样组成的,第一个必须是字母,后面可以是字母.数字.下划线,总长度为5-20 var reg = /^[a-zA-Z][a-zA-Z_0-9]{4,19}$/; reg.test ...

  7. 够快网盘支持与iOS-ASIHTTPRequest框架学习

    够快网盘支持与iOS-ASIHTTPRequest框架学习 前段时间在公司的产品中支持了够快网盘,用于云盘存储. 在这个过程中,学习到了很多新的知识,也遇到了很多问题,在此记录一下. 首先就够快的AP ...

  8. Chapter 1 First Sight——28

    "Which one is the boy with the reddish brown hair?" 那个红褐色头发的男孩是谁? I asked. I peeked at him ...

  9. ViewSwitcher的功能与用法

    ViewSwtcher代表了视图切换组件,它本身继承了FrameLayout,因此可以将多个View层叠在一起,每次只显示一个组件.当程序控制从一个View切换到另一个View时,ViewSwitch ...

  10. angular&period;isArray&lpar;&rpar;

    <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title> ...

相关文章