jpa和hibernate注解

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

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

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



手机号实体 

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


users映射文件

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.   
  6. <hibernate-mapping >  
  7.   
  8.         <class name="com.own.model.Users"  table="users"  dynamic-update="true"  dynamic-insert="true"     >  
  9.             
  10.            <id name="id"  column="id" >  
  11.               <generator class="native"></generator>  
  12.            </id>  
  13.              
  14.             <property name="username"  column="username"   ></property>    
  15.             <property name="password"  column="password" type="string"  ></property>    
  16.               
  17.             <!-- 这里是一对一映射 级联为所有 -->  
  18.             <one-to-one name="phoneNumber" class="com.own.model.CellphoneNumber" cascade="all"  >  
  19.               
  20.             </one-to-one>      
  21.               
  22.         </class>  
  23. </hibernate-mapping>  


cellPhone映射文件

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.   
  6. <hibernate-mapping >  
  7.   
  8.         <class name="com.own.model.CellphoneNumber"  table="cellphone"  dynamic-update="true"  dynamic-insert="true"   >  
  9.            <!-- 这里设置外键关联 -->  
  10.            <id name="cellPhoneId"  column="id" >  
  11.               <generator class="foreign">  
  12.                   <!-- 这里设置用引用user实体的主键  -->  
  13.                 <param name="property">user</param>  
  14.               </generator>  
  15.            </id>  
  16.             <property name="number"  column="cellphoneNumber" ></property>    
  17.             <property name="attribution"  column="attribution"   ></property>    
  18.             <property name="cellphonoeType"  column="numberType"   ></property>    
  19.             <!-- 加上外键约束  ,使Cellphone的主键引用user表行的主键 -->  
  20.             <one-to-one name="user" constrained="true"  class="com.own.model.Users"  ></one-to-one>  
  21.         </class>  
  22. </hibernate-mapping>  


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

Java代码  收藏代码
  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  

Java代码  收藏代码
  1.   package com.own.model;  
  2.   
  3.   
  4. import java.io.Serializable;  
  5.   
  6. import javax.persistence.CascadeType;  
  7. import javax.persistence.Column;  
  8. import javax.persistence.Entity;  
  9. import javax.persistence.GeneratedValue;  
  10. import javax.persistence.Id;  
  11. import javax.persistence.OneToOne;  
  12. import javax.persistence.PrimaryKeyJoinColumn;  
  13. import javax.persistence.Table;  
  14. @Entity  
  15. @org.hibernate.annotations.Entity(dynamicInsert=true,dynamicUpdate=true)  
  16. @Table(name="users")  
  17. public class Users implements Serializable{  
  18.     private static final long serialVersionUID = 1381652232198529039L;  
  19.     private int id;  
  20.     private String username;  
  21.     private String password;  
  22.     private CellphoneNumber cellphone;  
  23.       
  24.     @OneToOne(cascade={CascadeType.ALL})  
  25.     @PrimaryKeyJoinColumn  
  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.       
  42.     @Column(name="username")  
  43.     public String getUsername() {  
  44.         return username;  
  45.     }  
  46.       
  47.     public void setUsername(String username) {  
  48.         this.username = username;  
  49.     }  
  50.       
  51.     @Column(name="password")  
  52.     public String getPassword() {  
  53.         return password;  
  54.     }  
  55.       
  56.     public void setPassword(String password) {  
  57.         this.password = password;  
  58.     }  
  59.   
  60.       
  61. }  



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

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.   
  6. <hibernate-mapping >  
  7.         <class name="com.own.model.Users"  table="users"  dynamic-update="true"  dynamic-insert="true" >  
  8.            <id name="id"  column="id" >  
  9.               <generator class="native"></generator>  
  10.            </id>  
  11.             <property name="username"  column="username"   ></property>    
  12.             <property name="password"  column="password" type="string"  ></property>   
  13.             <!-- 加上唯一约束，使这个关系成为真正的一对一 -->   
  14.             <many-to-one name="phoneNumber" cascade="all" class="com.own.model.CellphoneNumber"  column="cell_id"    
  15.               unique="true"  >  
  16.             </many-to-one>  
  17.         </class>  
  18. </hibernate-mapping>  
  19.   
  20.    



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

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


手机实体类 
 

Java代码  收藏代码
  1.    
  2.  @OneToOne(mappedBy="cellphone")  
  3. ublic Users getU() {  
  4. return u;  


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

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.   
  6. <hibernate-mapping >  
  7.         <class name="com.own.model.Users"  table="users"  dynamic-update="true"  dynamic-insert="true" >  
  8.            <id name="id"  column="id" >  
  9.               <generator class="native"></generator>  
  10.            </id>  
  11.             <property name="username"  column="username"   ></property>    
  12.             <property name="password"  column="password" type="string"  ></property>   
  13.             <!-- 加上唯一约束，使这个关系成为真正的一对一 -->   
  14.             <!-- optional 告诉hibernate这个关系是可选的 ，当这个属性为空时，可以不插入关联表 -->  
  15.             <join table="user_cellphoneNumber"      >  
  16.               <key column="user_id"    unique="true"  />  
  17.                <many-to-one name="phoneNumber"  cascade="save-update"      class="com.own.model.CellphoneNumber"   column="cell_id"    
  18.               unique="true"     >  
  19.             </many-to-one>  
  20.             </join>  
  21.         </class>     
  22. </hibernate-mapping>  


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

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


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

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.   
  6. <hibernate-mapping >  
  7.         <class name="com.own.model.Category"  table="category"  dynamic-insert="true" dynamic-update="false"      >  
  8.            <id name="category_id"  column="id" >  
  9.               <generator class="native"></generator>  
  10.            </id>  
  11.             <property name="categoryName"  column="category_name" type="string"  ></property>   
  12.                
  13.             <set name="goodsSet" inverse="true"  cascade="save-update"   >    <!-- 用key column 的名字表示关联表的外键的名称  -->  
  14.                <key column="category_id"    />   
  15.                <one-to-many  class="com.own.model.Goods"   />   
  16.               </set>   
  17.         </class>  
  18. </hibernate-mapping>  


many端的映射文件 

Java代码  收藏代码
  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.   
  6. <hibernate-mapping   >  
  7.         <class name="com.own.model.Goods"  table="goods"  dynamic-insert="true" dynamic-update="false"      >  
  8.            <id name="id"  column="goods_id" >  
  9.               <generator class="native"></generator>  
  10.            </id>  
  11.             <property name="price"  column="goods_price" type="double"  ></property>    
  12.             <property name="goodsName"  column="goods_name" type="string"  ></property>    
  13.             <property name="goodsDescription"  column="goods_description" type="string"  ></property>    
  14.             <many-to-one name="category"      fetch="join"    class="com.own.model.Category"  column="category_id"      >  
  15.             </many-to-one>  
  16.         </class>  
  17.    
  18. </hibernate-mapping>  


jpa元数据注解 
Category实体 

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



Goods实体

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



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

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.   
  6. <hibernate-mapping >  
  7.         <class name="com.own.model.Student"  table="student"  dynamic-update="true"  dynamic-insert="true" >  
  8.            <id name="studentId"  column="id" >  
  9.               <generator class="native"></generator>  
  10.            </id>  
  11.             <property name="studentName"  column="student_name"   ></property>    
  12.             <property name="studentNum"  column="student_no" type="string"  ></property>   
  13.             <set name="cosrseSet"    table="student_course"  >  
  14.            <!--  引用当前实体主键的外键名称   -->     
  15.           <key  column="student_id"   />  
  16.               <many-to-many column="course_id"  class="com.own.model.Course"   ></many-to-many>  
  17.             </set>  
  18.         </class>  
  19. </hibernate-mapping>  


course映射文件

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.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.               
  13.           <set name="studentSet"  inverse="true"  cascade="all"    table="student_course"    >  
  14.               <key  column="course_id"   />  
  15.               <many-to-many column="student_id"  class="com.own.model.Student"   ></many-to-many>  
  16.            </set>  
  17.         </class>  
  18. </hibernate-mapping>  


jpa元数据 
Student实体

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


Course实体

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



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

Java代码  收藏代码
  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来表示有那方来维护关联关系

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/JAYIT/p/6170416.html