hibernate和jpa註解關聯總結

用hibernate和jpa annotation 大概一年多了，今天閒來無事，對他們關聯關係元數據寫法做一個總結。 
1.一對一主鍵關聯 
這個在實際項目中用的比較少，大部分是通過用外鍵做關聯的，這裏用用戶和手機號舉個例子，用戶和手機號是一對一的關係，代碼如下： 
User實體 

  package com.own.model;

import java.io.Serializable;

public class Users implements Serializable{

      private static final long serialVersionUID = 1381652232198529039L;
    private int id;
    private String username;
    private String password;
    private CellphoneNumber phoneNumber;
    public CellphoneNumber getPhoneNumber() {
        return phoneNumber;
    }
    public void setPhoneNumber(CellphoneNumber phoneNumber) {
        this.phoneNumber = phoneNumber;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }


}

手機號實體 

  package com.own.model;

import java.io.Serializable;

public class CellphoneNumber implements Serializable {

    private static final long serialVersionUID = -1029364968566042141L;

    private Integer cellPhoneId;
    private String number;
    private String attribution;//手機歸屬地
    private String cellphonoeType;//移動或者聯通
    private Users user ;
    public Users getUser() {
        return user;
    }
    public void setUser(Users user) {
        this.user = user;
    }
    public Integer getCellPhoneId() {
        return cellPhoneId;
    }
    public void setCellPhoneId(Integer cellPhoneId) {
        this.cellPhoneId = cellPhoneId;
    }
    public String getNumber() {
        return number;
    }
    public void setNumber(String number) {
        this.number = number;
    }
    public String getAttribution() {
        return attribution;
    }
    public void setAttribution(String attribution) {
        this.attribution = attribution;
    }
    public String getCellphonoeType() {
        return cellphonoeType;
    }
    public void setCellphonoeType(String cellphonoeType) {
        this.cellphonoeType = cellphonoeType;
    }

    @Override
    public boolean equals(Object anotherObject){
        if(anotherObject == null || anotherObject.getClass() != this.getClass()){
            return false;
        }
        if(this == anotherObject){
            return true;
        }

        CellphoneNumber another = (CellphoneNumber) anotherObject;
        if(another.cellPhoneId.equals(this.cellPhoneId)){
            return true  ;
        }

        return false;
    }

    public int hashCode(){

        return cellPhoneId.hashCode();
    }


}

users映射文件

   <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping >

        <class name="com.own.model.Users"  table="users"  dynamic-update="true"  dynamic-insert="true"     >

           <id name="id"  column="id" >
              <generator class="native"></generator>
           </id>

            <property name="username"  column="username"   ></property>
            <property name="password"  column="password" type="string"  ></property>

            <!-- 這裏是一對一映射 級聯爲所有 -->
            <one-to-one name="phoneNumber" class="com.own.model.CellphoneNumber" cascade="all"  >

            </one-to-one>

        </class>
</hibernate-mapping>

cellPhone映射文件

   <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping >

        <class name="com.own.model.CellphoneNumber"  table="cellphone"  dynamic-update="true"  dynamic-insert="true"   >
           <!-- 這裏設置外鍵關聯 -->
           <id name="cellPhoneId"  column="id" >
              <generator class="foreign">
                  <!-- 這裏設置用引用user實體的主鍵  -->
                <param name="property">user</param>
              </generator>
           </id>
            <property name="number"  column="cellphoneNumber" ></property>
            <property name="attribution"  column="attribution"   ></property>
            <property name="cellphonoeType"  column="numberType"   ></property>
            <!-- 加上外鍵約束  ,使Cellphone的主鍵引用user錶行的主鍵 -->
            <one-to-one name="user" constrained="true"  class="com.own.model.Users"  ></one-to-one>
        </class>
</hibernate-mapping>

在調用時，要設置關聯關係

Users u = new Users();
    u.setPassword("admin@1973");
    u.setUsername("floatSnow");
    CellphoneNumber cellphone = new CellphoneNumber();
    cellphone.setAttribution("北京");
    cellphone.setCellphonoeType("中國移動");
    cellphone.setNumber("13476534589");
    //設置雙向關聯關係
    u.setPhoneNumber(cellphone);
    cellphone.setUser(u);

jpa中使用@PrimaryKeyJoinColumn  

  package com.own.model;


import java.io.Serializable;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
@Entity
@org.hibernate.annotations.Entity(dynamicInsert=true,dynamicUpdate=true)
@Table(name="users")
public class Users implements Serializable{
    private static final long serialVersionUID = 1381652232198529039L;
    private int id;
    private String username;
    private String password;
    private CellphoneNumber cellphone;

    @OneToOne(cascade={CascadeType.ALL})
    @PrimaryKeyJoinColumn
    public CellphoneNumber getCellphone() {
        return cellphone;
    }
    public void setCellphone(CellphoneNumber cellphone) {
        this.cellphone = cellphone;
    }
    @Id
    @GeneratedValue
    @Column(name="id")
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

    @Column(name="username")
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Column(name="password")
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }


}

2.一對一外鍵關聯 
hibernate xml文件映射，在這裏使用manyToOne而不是我們想像的oneToOne,還有在  user表中加一個外鍵，引用另一個表的主鍵,這裏設置雙向關係，在項目中根據情況而定是否設置雙向關係 
映射文件 

  <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping >
        <class name="com.own.model.Users"  table="users"  dynamic-update="true"  dynamic-insert="true" >
           <id name="id"  column="id" >
              <generator class="native"></generator>
           </id>
            <property name="username"  column="username"   ></property>
            <property name="password"  column="password" type="string"  ></property>
            <!-- 加上唯一約束，使這個關係成爲真正的一對一 -->
            <many-to-one name="phoneNumber" cascade="all" class="com.own.model.CellphoneNumber"  column="cell_id"
              unique="true"  >
            </many-to-one>
        </class>
</hibernate-mapping>

jpa 映射使用oneToone,@joinColumn有兩個屬性 name 和 referencedColumnName 
，name是表示表中外鍵的列名，referencedColumnName表示外鍵引用的表的列名。 
user實體

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

手機實體類 
 

 @OneToOne(mappedBy="cellphone")
ublic Users getU() {
return u;

3.一對一可選關聯 
有的時候我們的外鍵是可選的，也就是說user表的外鍵是可以爲空的，這個時候我們可以把這中可選的關聯映射到一張表，加一張中間表，表示實體的對應關係 
Users實體映射文件 

  <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping >
        <class name="com.own.model.Users"  table="users"  dynamic-update="true"  dynamic-insert="true" >
           <id name="id"  column="id" >
              <generator class="native"></generator>
           </id>
            <property name="username"  column="username"   ></property>
            <property name="password"  column="password" type="string"  ></property>
            <!-- 加上唯一約束，使這個關係成爲真正的一對一 -->
            <!-- optional 告訴hibernate這個關係是可選的 ，當這個屬性爲空時，可以不插入關聯表 -->
            <join table="user_cellphoneNumber"      >
              <key column="user_id"    unique="true"  />
               <many-to-one name="phoneNumber"  cascade="save-update"      class="com.own.model.CellphoneNumber"   column="cell_id"
              unique="true"     >
            </many-to-one>
            </join>
        </class>
</hibernate-mapping>

jpa註解把屬性映射到兩張表，通過使用@SecondaryTable,使屬性映射到一張中間表。 

   package com.own.model;


import java.io.Serializable;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.SecondaryTable;
import javax.persistence.Table;

import org.hibernate.transaction.JOnASTransactionManagerLookup;
@Entity
@org.hibernate.annotations.Entity(dynamicInsert=true,dynamicUpdate=true)
@Table(name="users")
@SecondaryTable(name="user_cellphoneNumber",pkJoinColumns={@PrimaryKeyJoinColumn(name="user_id",referencedColumnName="id")})
public class Users implements Serializable{
    private static final long serialVersionUID = 1381652232198529039L;
    private int id;
    private String username;
    private String password;
    private CellphoneNumber cellphone;
    @OneToOne(cascade={CascadeType.ALL})
    @JoinColumn(table="user_cellphoneNumber",name="cell_id",referencedColumnName="id")
    public CellphoneNumber getCellphone() {
        return cellphone;
    }
    public void setCellphone(CellphoneNumber cellphone) {
        this.cellphone = cellphone;
    }
    @Id
    @GeneratedValue
    @Column(name="id")
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

    @Column(name="username")
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Column(name="password")
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }


}

4.一對多關聯 
一對多關聯通過oneToMany和ManyToMany映射，這裏的多段在java裏用一個集合set來表示，這個用商品category和貨物Goods來舉例子。 
one端實體Category 映射xml 

 <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping >
        <class name="com.own.model.Category"  table="category"  dynamic-insert="true" dynamic-update="false"      >
           <id name="category_id"  column="id" >
              <generator class="native"></generator>
           </id>
            <property name="categoryName"  column="category_name" type="string"  ></property>

            <set name="goodsSet" inverse="true"  cascade="save-update"   >    <!-- 用key column 的名字表示關聯表的外鍵的名稱  -->
               <key column="category_id"    />
               <one-to-many  class="com.own.model.Goods"   />
              </set>
        </class>
</hibernate-mapping>

many端的映射文件 

    <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping   >
        <class name="com.own.model.Goods"  table="goods"  dynamic-insert="true" dynamic-update="false"      >
           <id name="id"  column="goods_id" >
              <generator class="native"></generator>
           </id>
            <property name="price"  column="goods_price" type="double"  ></property>
            <property name="goodsName"  column="goods_name" type="string"  ></property>
            <property name="goodsDescription"  column="goods_description" type="string"  ></property>
            <many-to-one name="category"      fetch="join"    class="com.own.model.Category"  column="category_id"      >
            </many-to-one>
        </class>

</hibernate-mapping>

jpa元數據註解 
Category實體 

  package com.own.model;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@org.hibernate.annotations.Entity(dynamicInsert=true,dynamicUpdate=true)
@Table(name="category")
public class Category implements Serializable {
    private static final long serialVersionUID = 1L;
    private Integer category_id;
    private String categoryName;
    private Set<Goods> goodsSet = new HashSet<Goods>();

    @OneToMany(mappedBy="category",cascade={CascadeType.ALL})
    public Set<Goods> getGoodsSet() {
        return goodsSet;
    }
    public void setGoodsSet(Set<Goods> goodsSet) {
        this.goodsSet = goodsSet;
    }
    @Id
    @GeneratedValue
    @Column(name="id")
    public Integer getCategory_id() {
        return category_id;
    }
    public void setCategory_id(Integer categoryId) {
        category_id = categoryId;
    }

    @Column(name="category_name")
    public String getCategoryName() {
        return categoryName;
    }
    public void setCategoryName(String categoryName) {
        this.categoryName = categoryName;
    }



}

Goods實體

  package com.own.model;


import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@org.hibernate.annotations.Entity(dynamicInsert=true,dynamicUpdate=true)
@Table(name="goods")
public class Goods implements Serializable {
    private static final long serialVersionUID = 1L;
    private Integer id;
    private  String goodsName;
    private Double price;
    private String goodsDescription;
    private Category category;
    @ManyToOne
    @JoinColumn(name="category_id",referencedColumnName="id")
    public Category getCategory() {
        return category;
    }

    public void setCategory(Category category) {
        this.category = category;
    }

    public Goods(){}

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="goods_id")
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name="goods_name",length=40,nullable=false)
    public String getGoodsName() {
        return goodsName;
    }
    public void setGoodsName(String goodsName) {
        this.goodsName = goodsName;
    }

    @Column(name="goods_price")
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }

    @Column(name="goods_description")
    public String getGoodsDescription() {
        return goodsDescription;
    }
    public void setGoodsDescription(String goodsDescription) {
        this.goodsDescription = goodsDescription;
    }


    @Override
    public boolean equals(Object o) {

        if(o == null || o.getClass() != this.getClass()){
            return false;
        }

        if(o == this){
            return true;
        }

        Goods goods = (Goods) o;

        if(id == null ? goods.id == null : this.id.equals(goods.id)){
            return true;
        }


        return false;
    }

    /*@Override
    public int hashCode() {
        //return this.id.hashCode();
        return
    }*/

}

5.多對多關聯 
多對多關聯用manyToMany來映射，這裏用學生和選的課程，它們是多對多的關聯，多對對 
關聯通常需要一張中間表，這個表就兩字段，學生id和課程id（這裏中間表就兩個字段） 
在java中用兩set集合來表示 
student 映射文件 

  <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping >
        <class name="com.own.model.Student"  table="student"  dynamic-update="true"  dynamic-insert="true" >
           <id name="studentId"  column="id" >
              <generator class="native"></generator>
           </id>
            <property name="studentName"  column="student_name"   ></property>
            <property name="studentNum"  column="student_no" type="string"  ></property>
            <set name="cosrseSet"    table="student_course"  >
           <!--  引用當前實體主鍵的外鍵名稱   -->
          <key  column="student_id"   />
              <many-to-many column="course_id"  class="com.own.model.Course"   ></many-to-many>
            </set>
        </class>
</hibernate-mapping>

course映射文件

  <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping   >
        <class name="com.own.model.Course"  table="course"  dynamic-update="true"     dynamic-insert="true" >
           <id name="courseId"  column="id" >
              <generator class="native"></generator>
           </id>
            <property name="courseName"  column="course_name"   ></property>
            <property name="courseNum"   column="course_no"  ></property>

          <set name="studentSet"  inverse="true"  cascade="all"    table="student_course"    >
              <key  column="course_id"   />
              <many-to-many column="student_id"  class="com.own.model.Student"   ></many-to-many>
           </set>
        </class>
</hibernate-mapping>

jpa元數據 
Student實體

  package com.own.model;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
@Entity
@Table(name="student")
public class Student implements Serializable {

    private static final long serialVersionUID = 1L;
    private Integer studentId;
    private String studentName;
    private String studentNum;
    private Set<Course> cosrseSet = new HashSet<Course>();
    @ManyToMany
    @JoinTable(name="student_course",joinColumns={@JoinColumn(name="student_id")},
               inverseJoinColumns={@JoinColumn(name="course_id")})
    public Set<Course> getCosrseSet() {
        return cosrseSet;
    }
    public void setCosrseSet(Set<Course> cosrseSet) {
        this.cosrseSet = cosrseSet;
    }

    @Id
    @GeneratedValue
    @Column(name="id")
    public Integer getStudentId() {
        return studentId;
    }
    public void setStudentId(Integer studentId) {
        this.studentId = studentId;
    }

    @Column(name="student_name")
    public String getStudentName() {
        return studentName;
    }
    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    @Column(name="student_no")
    public String getStudentNum() {
        return studentNum;
    }
    public void setStudentNum(String studentNum) {
        this.studentNum = studentNum;
    }

}

Course實體

  package com.own.model;

import java.io.Serializable;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
@Entity
@Table(name="course")
public class Course implements Serializable {
    private static final long serialVersionUID = 1L;
    private Integer courseId;
    private String courseNum;
    private String courseName;
    private Set<Student> studentSet = new HashSet<Student>();

    @ManyToMany(mappedBy="cosrseSet")
    public Set<Student> getStudentSet() {
        return studentSet;
    }
    public void setStudentSet(Set<Student> studentSet) {
        this.studentSet = studentSet;
    }
    @Id
    @GeneratedValue
    @Column(name="id")
    public Integer getCourseId() {
        return courseId;
    }
    public void setCourseId(Integer courseId) {
        this.courseId = courseId;
    }

    @Column(name="course_no")
    public String getCourseNum() {
        return courseNum;
    }
    public void setCourseNum(String courseNum) {
        this.courseNum = courseNum;
    }

    @Column(name="course_name")
    public String getCourseName() {
        return courseName;
    }
    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

  /* @Override
   public boolean equals(Object o) {
     if(o == null || o.getClass() != Course.class){
         return false;
     }

     if(o == this){
         return true;
     }

     Course another = (Course)o;
     if(courseId == null ? another.courseId == null : courseId.equals(another.courseId)){
         return true;
     }

     return  false;

  }

  @Override
   public int hashCode() {
    return super.hashCode();
     // return 1;
  }*/


}

在多對對關聯的情況下，用的是set集合，實體要實現hashcode和equals，不然在更新關聯表的時候會更新不了，比如學生不在選擇這門課程，從set集合中remove掉這個課程，然後更新這個學生實體，代碼如下，在不實現hashcode和equals更新不會成功，只有實現了纔可以，hibernate返回了自己寫的集合，PersistenceSet而不是HashSet，這也是爲什麼我們在實體中寫set接口，不能寫HashSet ... = new HashSet,要用 Set ... = new HashSet 。

tc = session.beginTransaction();
   Student s1 = (Student) session.get(Student.class,9) ;
         Course c = new Course();
        s1.getCosrseSet().remove(c);
        session.update(s1);//更新學生的選課
tc.commit();

最後講解一下cascade和inverse這兩個屬性，剛用hibernate的時候也比較不理解，首先這兩個屬性沒有任何關係，cascade表示級聯，就是被關聯的一段，比如cascade='save-update',級聯保存和更新，在設置了cascade的端，保存這個對象，會一併保存關聯的一端，省去了我們寫保存關聯端的代碼，inverse表示有誰來維護關聯，在一段設置inverse=true，則有關聯對來維護關聯關係，比如上面的例子，在course端設置了inverse=true，則有student來維護中間表，只有當插入student的時候，才向中間表插入數據，如果都設置inverse=true則會插入重複數據，如果不設置，則會出錯，在jpa元數據註解中 用mappedBy來表示有那方來維護關聯關係