JPA双向一对多和多对一

　　JPA中一对多和多对一双向关系中，多的一方为关系维护端 。有mappedBy的一方为关系被维护端。

　　关系维护端负责外键纪录的更新 ，关系被维护端是没有权力更新外键纪录的。只能通过关系维护端设置与关系被维护端的关系。

一对多：

@OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH,
            CascadeType.MERGE, CascadeType.REMOVE, CascadeType.ALL }, fetch = FetchType.EAGER, mappedBy = "order")

cascade：设置级联操作，对JPQL语句进行的操作没有任何影响

CascadeType.PERSIST对应实体管理器的persist()方法

CascadeType.REFRESH对应实体管理器的refresh()方法

CascadeType.MERGE对应实体管理器的merge()方法

CascadeType.REMOVE对应实体管理器的remove()方法

CascadeType.ALL对应实体管理器的以上方法：persist()、refresh()、merge()、remove()方法

fetch：设置是否延迟加载，FetchType.LZAY为延迟加载， FetchType.EAGER时立即加载。如果加载的是多的一方的话，默认的是延迟加载，否则是加载。

多对一：

@ManyToOne(cascade = { CascadeType.MERGE, CascadeType.REFRESH }, optional = false)
@JoinColumn(name = "order_id")

optional：代表外键字段是否可以为空。true可以为空，false不可以为空。

@JoinColumn(name = "order_id")：设置关联外键字段的名称。

 

例：

１.两个实体的一对多和多对一

使用现实生活中的订单和订单项的关系，代码为：

package com.taoistwar.jpa.entity.onetomany;

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

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name = "order_info")
public class OrderInfo {
	private Integer id;
	private String name;

	private Set<OrderItem> items = new HashSet<OrderItem>();

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	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;
	}

	@OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH,
			CascadeType.MERGE, CascadeType.REMOVE }, fetch = FetchType.EAGER, mappedBy = "order")
	//fetch是否延迟加载，mappedBy有它的一方为关系被维护端。
	public Set<OrderItem> getItems() {
		return items;
	}

	public void setItems(Set<OrderItem> items) {
		this.items = items;
	}

	public void addOrderItem(OrderItem orderItem) {
		orderItem.setOrder(this);
		this.items.add(orderItem);
	}

}

 

package com.taoistwar.jpa.entity.onetomany;

import javax.persistence.CascadeType;
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
@Table(name = "order_item")
public class OrderItem {
	private Integer Id;
	private String name;

	private OrderInfo order;

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	public Integer getId() {
		return Id;
	}

	public void setId(Integer id) {
		Id = id;
	}

	@Column(length = 20, nullable = true)
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@ManyToOne(cascade = { CascadeType.MERGE, CascadeType.REFRESH }, optional = false)
	@JoinColumn(name = "order_id")
	// optional是否可以为空
	public OrderInfo getOrder() {
		return order;
	}

	public void setOrder(OrderInfo order) {
		this.order = order;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((Id == null) ? 0 : Id.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		OrderItem other = (OrderItem) obj;
		if (Id == null) {
			if (other.Id != null)
				return false;
		} else if (!Id.equals(other.Id))
			return false;
		return true;
	}

}

 2.单个实体的一对多和多对一

使用软件开发中的模块为例子，代码如下：

package com.taoistwar.ejb.sys.entity;

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

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;

/**
 * @author TaoistWar 模块实体类　（一对多）
 * 　JPA中一对多和多对一双向关系中，多的一方为关系维护端。
 *	关系维护端负责外键纪录的更新，关系被维护端是没有权力更新外键纪录的。
 */
@Entity
@Table(name = "s_moudle")
public class Moudle implements Serializable {
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Integer id;
	// 模块名(一般中文)
	@Column(name = "modName")
	private String modName;
	// 模块值(英文)
	@Column(name = "modValue")
	private String modValue;
	// 模块排序编码
	@Column(name = "orderCode")
	private Integer orderCode;
	// 模块是否禁用
	@Column(name = "forbidden")
	private boolean forbidden;
	// 模块链接路径
	@Column(name = "modUrl")
	private String modUrl;
	// 父级模块
	@ManyToOne(cascade = { CascadeType.REFRESH, CascadeType.REMOVE }, optional=true)
	@JoinColumn(name="parent_id")
	// optional关联字段是否可以为空
	private Moudle parent;
	// 子级模块
	@OneToMany(cascade = { CascadeType.REFRESH, CascadeType.REMOVE }, fetch=FetchType.LAZY, mappedBy="parent")
	private Set<Moudle> children;

	public Integer getId() {
		return id;
	}

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

	public String getModName() {
		return modName;
	}

	public void setModName(String modName) {
		this.modName = modName;
	}

	public String getModValue() {
		return modValue;
	}

	public void setModValue(String modValue) {
		this.modValue = modValue;
	}

	public Integer getOrderCode() {
		return orderCode;
	}

	public void setOrderCode(Integer orderCode) {
		this.orderCode = orderCode;
	}

	public boolean isForbidden() {
		return forbidden;
	}

	public void setForbidden(boolean forbidden) {
		this.forbidden = forbidden;
	}

	public String getModUrl() {
		return modUrl;
	}

	public void setModUrl(String modUrl) {
		this.modUrl = modUrl;
	}

	public Moudle getParent() {
		return parent;
	}

	public void setParent(Moudle parent) {
		this.parent = parent;
	}

	public Set<Moudle> getChildren() {
		return children;
	}

	public void setChildren(Set<Moudle> children) {
		this.children = children;
	}

}