• 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来表示有那方来维护关联关系
  • 相关阅读:
    Thread.sleep(0)的意义& 多线程详解
    .NET AOP的实现
    UML详解
    asp.net事件委托易理解实例
    2个或多个datable类似于sql inner join 合并查询
    web.cofing（新手必看）
    JS操作URL
    .net对象转Datable
    NPOI读写Excel
    RSA加密
  • 原文地址：https://www.cnblogs.com/JAYIT/p/6170416.html
Copyright © 2020-2023  润新知