Hibernate的單向關聯映射應用

一、簡述

一、單向N-1關聯
單向N-1關係，比如多個人對應一個地址，只需從人實體端可以找到對應的地址實體，無須關係某個地址的全部住戶。
單向 n-1 關聯只需從 n 的一端可以訪問 1 的一端。
二、單向1-1關聯
從持久化的代碼上看，單向1-1與單向N-1沒有絲毫區別。
三、N-N關係
持久化類裏需要使用集合屬性，此時集合裏的元素是關聯實體

二、簡單例子
1、數據庫表

person表：
CREATE TABLE `person` (
  `personId` int(50) NOT NULL AUTO_INCREMENT,
  `personName` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL,
  `personAge` int(50) DEFAULT NULL,
  `addressId` int(11) DEFAULT NULL,
  PRIMARY KEY (`personId`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

address表：
CREATE TABLE `address` (
  `addressId` int(50) NOT NULL AUTO_INCREMENT,
  `addressDetail` varchar(100) COLLATE utf8_unicode_ci DEFAULT NULL,
  PRIMARY KEY (`addressId`)
) ENGINE=InnoDB AUTO_INCREMENT=13 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

person_address表：
CREATE TABLE `person_address` (
  `addressId` int(50) NOT NULL AUTO_INCREMENT,
  `personId` int(50) DEFAULT NULL,
  PRIMARY KEY (`addressId`)
) ENGINE=InnoDB AUTO_INCREMENT=13 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

2、實體

package com;
import java.util.HashSet;
import java.util.Set;
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.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import org.hibernate.annotations.Cascade;
@Entity
@Table(name="person")
public class Person {
    @Id
    @Column(name="personId")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer personId;
    @Column(name="personName")
    private String personName;
    @Column(name="personAge")
    private Integer personAge;
    //----------------單向N-1關聯Begin-------------//

    //========無連接表(中間表)的N-1關聯===========//
    //  //定義該Person實體關聯的Address實體
    //  @ManyToOne(targetEntity=Address.class)
    //  //映射外鍵列，指定外鍵列的列名爲addressId
    //  @JoinColumn(name="addressId",nullable=false)
    //  @Cascade(CascadeType.ALL)



    //========有連接表(中間表)的N-1關係============//
    //定義該Person實體關聯的Address實體
    //  @ManyToOne(targetEntity=Address.class)
    //  //顯式使用@joinTable映射連接表
    //  @JoinTable(name="person_address",//指定連接表的表名爲person_address
    //  //指定連接表中personId外鍵列，參考當前 實體對應表的主鍵列
    //  joinColumns=@JoinColumn(name="personId",referencedColumnName="personId",unique=true),
    //  //指定連接表中addressId外鍵列，參照當前實體 關聯實體 對應表的主鍵列
    //  inverseJoinColumns=@JoinColumn(name="addressId",referencedColumnName="addressId")
    //  )
    //  @Cascade(CascadeType.ALL)
    //-----------------單向N-1關聯END----------------//

    //-----------------單向1-1關聯Begin------------------//
    //==================基於外鍵的單向1-1關聯===============//
    //定義該person實體關聯的Address實體
    //  @OneToOne(targetEntity=Address.class)
    //  //映射名爲addressId的外鍵列，參照關聯實體對應表addressId主鍵列
    //  @JoinColumn(name="addressId",
    //  //指定連接表中addressId外鍵列，參照當前實體關聯實體對應表的主鍵列  
    //  referencedColumnName="addressId",unique=true)
    //  @Cascade(CascadeType.ALL)

    //===================有連接表(中間表)的1-1關聯============//
    //  @OneToOne(targetEntity=Address.class)
    //  @JoinTable(name="person_address",//指定連接表的表名爲person_address
    //    //用於配置連接表中外鍵列信息，這些外鍵列參照當前實體對應表的主鍵列
    //  joinColumns=@JoinColumn(name="personId",referencedColumnName="personId",unique=true),
    //  //用於配置連接表中外鍵列信息，這些外鍵列參照當前實體關聯實體對應的主鍵列
    //  inverseJoinColumns=@JoinColumn(name="addressId",referencedColumnName="addressId",unique=true)
    //  )
    //  @Cascade(CascadeType.ALL)
    //=====================單向1-1關聯End==================//

    //=====================單向N-N關聯=====================//
    //定義該Person實體所有關聯的Address實體
    @ManyToMany(targetEntity=Address.class)
    //映射鏈接表爲person_address
    @JoinTable(name="person_address",
    //定義連接表中名爲person_id的外鍵列，該外鍵參照當前實體對應的主鍵列
    joinColumns=@JoinColumn(name="personId",referencedColumnName="personId"),
    //定義連接表中名爲address_id的外鍵列，該外鍵列參照當前實體關聯實體對應表的主鍵列，沒有指定unique=true
    inverseJoinColumns=@JoinColumn(name="addressId",referencedColumnName="addressId")
    )
    @Cascade(org.hibernate.annotations.CascadeType.ALL)
    //======================單向N-N關聯End====================//
    private Set<Address> addresses=new HashSet();
    /**
      *  
      * //  private Address address;
        //  public Address getAddress() {
        //      return address;
        //  }
        //  public void setAddress(Address address) {
        //      this.address = address;
        //  }
     * 
     * @return
     */
    public Integer getPersonId() {
        return personId;
    }
    public void setPersonId(Integer personId) {
        this.personId = personId;
    }
    @Column(name="personName")
    public String getPersonName() {
        return personName;
    }
    public void setPersonName(String personName) {
        this.personName = personName;
    }
    @Column(name="personAge")
    public Integer getPersonAge() {
        return personAge;
    }
    public void setPersonAge(Integer personAge) {
        this.personAge = personAge;
    }
    public Set<Address> getAddresses() {
        return addresses;
    }
    public void setAddresses(Set<Address> addresses) {
        this.addresses = addresses;
    }
}


package com;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="address")
public class Address {
    @Id 
    @Column(name="addressId")
    @GeneratedValue(strategy=GenerationType.IDENTITY) 
    private Integer addressId;
    private String addressDetail;
    public Address(){

    }
    public Address(String addressDetail){
        this.addressDetail=addressDetail;
    }
    public Integer getAddressId() {
        return addressId;
    }
    public void setAddressId(Integer addressId) {
        this.addressId = addressId;
    }
    @Column(name="addressDetail")
    public String getAddressDetail() {
        return addressDetail;
    }
    public void setAddressDetail(String addressDetail) {
        this.addressDetail = addressDetail;
    }

}

3、測試類

package com;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class TestPerson {
    public static void main(String[] args) {
        Configuration config=new Configuration().configure();
        SessionFactory sfy=config.buildSessionFactory();
        Session session=sfy.openSession();
        Transaction tx=session.beginTransaction();
        Person p=new Person();
        Address a=new Address("茂名市茂南區N_N有連接表");
        p.setPersonName("person_N_N有連接關聯");
        p.setPersonAge(25);
        // p.setAddress(a);
        //持久化person對象
        session.persist(p);
        Address a2=new Address("茂名市化州市N_N有連接關聯");
        //修改持久狀態的p2
        //p.setAddress(a2);
        Set<Address> addresses=new HashSet<Address>();
        addresses.add(a);
        addresses.add(a2);
        p.setAddresses(addresses);
        tx.commit();
        session.close();
        sfy.close();
    }
}