单向1-N关联
@OneToMany支持的属性
cascade:(非必须属性)指定Hibernate对关联实体采用怎样的级联策略，该级联策略支持如下五个属性：
1.CascadeType.ALL：指定Hibernate将多有的持久化操作都级联到关联实体；
2.CascadeType.MERGE：指定Hibernate将merge操作级联到关联实体；
3.CascadeType.PERSIST：指定Hibernate将persist操作级联到关联实体；
4.CascadeType.REFRESH：指定Hibernate将refresh操作级联到关联实体；
5.CascadeType.REMOVE：指定Hibernate将remove操作级联到关联实体；
fetch:(非必须属性)指定抓取关联实体时的抓取策略，该属性支持如下两个属性值：
1.FetchType.EAGER：抓取实体时，立即抓取关联实体，这是默认值；
2.FetchType.LAZY：抓取实体时，延迟抓取关联实体，等到正真用到关联实体时采取抓取；
targetEntity:(非必须属性)该属性指定关联实体的类名，在默认情况下，Hibernate将通过反射来判断关联实体的类名；
mappedBy:(非必须属性)该属性合法的属性值为关联实体的属性名，该属性指定关联实体中哪个属性可引用到当前实体；
orphanRemoval:(非必须属性)该属性设置是否删除"孤儿"实体，如果某个实体所关联的父实体不存在，(即该实体对应记录的外键为null)，该实体就是所谓的"孤儿"实体；------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1>无连接表的单向1-N关联
对于无连接表的1-N单向关联而言，同样需要在N的一端增加外键列来维护关联关系，但由于程序此时只让1的一端来控制关联关系，因此直接在1的一端使用@JoinColumn修饰Set集合属性、映射外键列即可；
Person实体类
<span style="font-size:18px;">package com.anlw.entity;
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.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name="person_inf")
public class Person{
//标识属性
@Id
@Column(name="person_id12")
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private String name;
private int age;
//定义该Person实体所有关联的Address实体，没有指定cascade属性
@OneToMany(targetEntity=Address.class)
//映射外键列，此处映射的外键列将会添加到关联实体对应的数据表中
@JoinColumn(name="p_id1",referencedColumnName="person_id12")
private Set<Address> addresses = new HashSet<Address>();
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Set<Address> getAddresses() {
return addresses;
}
public void setAddresses(Set<Address> addresses) {
this.addresses = addresses;
}
}</span>Address实体
<span style="font-size:18px;">package com.anlw.entity;
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_inf")
public class Address {
//标识属性
@Id
@Column(name="address_id11d")
@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;
}
public String getAddressDetail() {
return addressDetail;
}
public void setAddressDetail(String addressDetail) {
this.addressDetail = addressDetail;
}
}</span>使用如下代码来保存一个Person对象和两个Address对象：
核心测试代码
<span style="font-size:18px;">package com.anlw.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import com.anlw.entity.Address;
import com.anlw.entity.Person;
public class Test {
public static void main(String[] args) {
Configuration conf = new Configuration().configure();
ServiceRegistry st = new StandardServiceRegistryBuilder().applySettings(conf.getProperties()).build();
SessionFactory sf = conf.buildSessionFactory(st);
Session sess = sf.openSession();
Transaction tx = sess.beginTransaction();
//创建一个Person对象
Person p = new Person();
//创建一个瞬态的Address对象
Address a = new Address("guangzhou");
//必须先持久化Address对象
sess.persist(a);
p.setName("kobe");
p.setAge(36);
//设置Person和Address之间的关联关系
p.getAddresses().add(a);
//持久化Person对象
sess.save(p);
//创建一个瞬态的Address对象
Address a2 = new Address("shanghai");
//必须先持久化Address对象
sess.persist(a2);
//修改持久化状态的Person对象
p.getAddresses().add(a2);
tx.commit();
sess.close();
sf.close();
}
}
</span>1，执行insert into person_inf...语句，向Person数据表插入一条记录；i
2，hibernate试图执行update address_inf...语句，将当前person_inf表记录关联的address_inf表记录的外键修改为该person_inf表记录的主键值；问题是：如果address_inf表中将要被修改的记录不存在呢？如果程序在@OneToMany注释中指定了cascade=CadscadeType.ALL，则Hibernate先执行insert into person_inf...语句插入一条记录，然后执行insert into address_inf...语句插入一条address_inf记录，再执行一条update address_inf... 语句来修改刚刚插入的address_inf记录；（指定了cascade=CadscadeType.ALL也可以执行成功）
正如上面程序看到的，由于配置<set.../>元素时没有指定cascade=all，因此程序对Person实体的持久化操作不会级联到关联的Address实体，程序必须显示的持久化两个Address实体；
从上面的执行过程可以看出，虽然上面的程序仅仅需要为Person实体增加一个关联的Addressss实体，但是hibernate会采用两条sql语句来完成，一条insert语句插入一条外键值为null的address_inf记录，一条update语句修改刚刚插入的address_inf记录，这肯定会造成性能不好；
造成这种现象的根本原因是从Person到Address的关联(外键person_id)没有被当作Address对象状态的一部分，(程序是通过把Address实体添加到Person实体的addresses集合属性中，而Address实体并不知道他所关联的Person实体)，因而Hibernate无法在执行insert into address_inf...语句时为该外键列指定值；
解决这个问题的思路是，程序必须在持久化Address实体之前，让Address实体能知道他所关联的Person实体，也就是应该通过address.setPerson(person)方法来建立关联关系--这就需要把这个关联关系添加到Address的映射中，这就变成了双向1-N关联，因此应该尽量少用单向1-N单向关联，而是改用双向1-N关联；
对于双向的1-N父子关联，使用1的一端控制关系的性能比使用N的一端控制关系的性能低，性能低的原因是当使用1的一端控制关联关系时，由于插入数据时无法同时插入外键列，因此会多出额外的一条update语句，而且外键列还无法增加非空约束-因为添加关联实体时，总会先插入一条外键列为null的记录；
万一程序必须采用单向1-N的关联模型，也应该采用有连接表的单向1-N关联；
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
2>又连接表的单向1-N关联
对于有连接表的1-N关联，同样需要使用@OneToMany修饰代表关联实体的集合属性，除此之外，程序还应使用@JoinTable显示指定连接表；
Person实体类
<span style="font-size:18px;">package com.anlw.entity;
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.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name="person_inf")
public class Person{
//标识属性
@Id
@Column(name="person_id12")
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private String name;
private int age;
//定义该Person实体所有关联的Address实体
@OneToMany(targetEntity=Address.class)
//映射连接表为p_a
@JoinTable(name="p_a",
//定义连接表中名为person_id的外键列，该外键列参照当前实体对应表的主键列
joinColumns=@JoinColumn(name="p",referencedColumnName="person_id12"),
//定义连接表中名为address_id的外键列
//该外键列参照当前实体的关联实体对应表的主键列
inverseJoinColumns=@JoinColumn(name="a",referencedColumnName="address_id11d",unique=true)
)
private Set<Address> addresses = new HashSet<Address>();
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Set<Address> getAddresses() {
return addresses;
}
public void setAddresses(Set<Address> addresses) {
this.addresses = addresses;
}
}</span>上面程序@JoinTable注解映射address_id外键列时，指定了unique=true，这意味着为连接表的address_id列增加了唯一约束，因此每个Address实体最多只能关联一个Person实体，但是一个Person实体可以关联多个Address实体；
当程序需要保存一个Person对象，两个Address对象，并建立该Person对象和这两个Address对象的关联关系时，程序依然需要5条sql语句，只是这5条sql语句都是insert语句--其中两条用于向连接表中插入记录，从而建立Person和Address之间的关联关系；
对于采用连接表的单向1-N关联而言，由于采用了连接表来维护1-N关联关系，两个实体对应的数据表都都无需增加外键列，因此不存在主从表关系，程序完全可以想先持久化哪个实体就先持久化哪个实体，无论先持久化哪个实体，程序都不会引发性能问题；
扫一扫
4401
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
