Hibernate的关联映射(3)-单向1-N关联

太过爱你忘了你带给我的痛 2022-07-21 00:10 141阅读 0赞

单向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实体类

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

上面代码首先使用@OneToMany修饰了Set集合属性，接下来使用@JoinColumn映射了外键列，此处的外键列并不是增加到当前实体对应的数据表中，而是增加到关联实体Address对应的数据表中；

Address实体

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

对于Person实体类而言，程序使用了@OneToMany时并没有指定cascade属性，这意味着对主表实体的持久化操作不会级联到从表实体；

使用如下代码来保存一个Person对象和两个Address对象：

核心测试代码

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

上面程序中sess.save(p)持久化了一个Person对象，且Person对象关联了一个Address对象，此时Hibernate需要完成哪些事情呢：

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实体类

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

上面程序@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关联关系，两个实体对应的数据表都都无需增加外键列，因此不存在主从表关系，程序完全可以想先持久化哪个实体就先持久化哪个实体，无论先持久化哪个实体，程序都不会引发性能问题；