Hibernate的单向关联映射应用

一、单向N-1关联
单向N-1关系，比如多个人对应一个地址，只需从人实体端可以找到对应的地址实体，无须关系某个地址的全部住户。
单向 n-1 关联只需从 n 的一端可以访问 1 的一端。
二、单向1-1关联
从持久化的代码上看，单向1-1与单向N-1没有丝毫区别。
三、N-N关系
持久化类里需要使用集合属性，此时集合里的元素是关联实体

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

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;
}

}

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();
}
}