例如我们用一个例子来开启JPA的一对多和多对一的学习。
转自：
首先建立订单实体类
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name="orders")
public class Order {
private String orderid;
private Float amount = 0f;
private Set<OrderItem> items = new HashSet<OrderItem>();
@Id
@Column(length = 12)
public String getOrderid() {
return orderid;
}
public void setOrderid(String orderid) {
this.orderid = orderid;
}
@Column(nullable = false)
public Float getAmount() {
return amount;
}
public void setAmount(Float amount) {
this.amount = amount;
}
@OneToMany(cascade = { CascadeType.REFRESH, CascadeType.PERSIST,CascadeType.MERGE, CascadeType.REMOVE },mappedBy ="order") //这里配置关系，并且确定关系维护端和被维护端。mappBy表示关系被维护端，只有关系端有权去更新外键。这里还有注意OneToMany默认的加载方式是赖加载。当看到设置关系中最后一个单词是Many，那么该加载默认为懒加载
public Set<OrderItem> getItems() {
return items;
}
public void setItems(Set<OrderItem> items) {
this.items = items;
}
/**
*该方法用于向order中加order项
/*
public void addOrderItem(OrderItem orderItem){
orderItem.setOrder(this);//用关系维护端来维护关系
this.items.add(orderItem);
}
}
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
@Entity
public class OrderItem {
private Integer id;
private String productName;
private Float sellPrice = 0f;
private Order order;
@Id
@GeneratedValue
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(length = 40, nullable = false)
public String getProductName() {
return productName;
}
public void setProductName(String productName) {
this.productName = productName;
}
@Column(nullable = false)
public Float getSellPrice() {
return sellPrice;
}
public void setSellPrice(Float sellPrice) {
this.sellPrice = sellPrice;
}
@ManyToOne(cascade = {CascadeType.MERGE,CascadeType.REFRESH }, optional = true)
@JoinColumn(name="order_id")//这里设置JoinColum设置了外键的名字，并且orderItem是关系维护端
public Order getOrder() {
return order;
}
public void setOrder(Order order) {
this.order = order;
}
}
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import org.junit.BeforeClass;
import org.junit.Test;
import cn.itcast.bean.Order;
import cn.itcast.bean.OrderItem;
public class OneToManyTest {
@BeforeClass
public static void setUpBeforeClass() throws Exception {
}
@Test public void addOrder(){
EntityManagerFactory factory = Persistence.createEntityManagerFactory("test");
EntityManager em = factory.createEntityManager();
em.getTransaction().begin(); // start transaction
Order order = new Order();
order.setAmount(34f);
order.setOrderid("00001");
//order中包含的OrderItem项OrderItem1，OrderItem2
OrderItem orderItem1 = new OrderItem();
orderItem1.setProductName("书");
orderItem1.setSellPrice(22f);
order.addOrderItem(orderItem1); //add orderitem in order
OrderItem orderItem2 = new OrderItem();
orderItem2.setProductName("篮球");
orderItem2.setSellPrice(100f);
order.addOrderItem(orderItem2);
em.persist(order); //persist order object
em.getTransaction().commit(); //commit transaction
em.close();
factory.close();
}
}
双向一对多关系，一是关系维护端（owner side），多是关系被维护端（inverse side）。在关系被维护端需要通过@JoinColumn建立外键列指向关系维护端的主键列。
publicclass
Order
implements
Serializable {
private
Set<OrderItem> orderItems
=
new
HashSet<OrderItem>();
。。。。
@
OneToMany
(mappedBy=
"order"
,cascade = CascadeType.
ALL
, fetch = FetchType.
LAZY
)
@
OrderBy
(value =
"id ASC"
)
public
Set<OrderItem> getOrderItems() {
return
orderItems
;
}
}
publicclass
OrderItem
implements
Serializable {
private
Order
order
;
。。。。
@
ManyToOne
(cascade=CascadeType.
REFRESH
,optional=
false
)
@
JoinColumn
(name =
"order_id"
)
public
Order getOrder() {
return
order
;
}
}
@OrderBy(value = "id ASC")
指明加载
OrderItem
时按
id
的升序排序
@OneToMany
的属性
：
1>targetEntity
定义关系类的类型，默认是该成员属性对应的类类型，所以通常不需要提供定义。
2>mappedBy
定义类之间的双向关系。如果类之间是单向关系，不需要提供定义，如果类和类之间形成双向关系，我们就需要使用这个属性进行定义，否则可能引起数据一致性的问题。
该属性的值是“多”方class里的“一”方的变量名
3>cascade
该属性定义类和类之间的级联关系。定义的级联关系将被容器视为对当前类对象及其关联类对象采取相同的操作，而且这种关系是递归调用的。举个例子：
Order
和
OrderItem
有级联关系，那么删除
Order
时将同时删除它所对应的
OrderItem
对象。而如果
OrderItem
还和其他的对象之间有级联关系，那么这样的操作会一直递归执行下去。
cascade
的值只能从
CascadeType.PERSIST
（级联新建）、
CascadeType.REMOVE
（级联删除）、
CascadeType.REFRESH
（级联刷新）、
CascadeType.MERGE
（级联更新）中选择一个或多个。还有一个选择是使用
CascadeType.ALL
，表示选择全部四项。
4>fatch
可选择项包括：
FetchType.EAGER
和
FetchType.LAZY
。前者表示关系类
(
本例是
OrderItem
类
)
在主类
(
本例是
Order
类
)
加载的时候同时加载，后者表示关系类在被访问时才加载。默认值是
FetchType.LAZY
。
@JoinColumn(name = "order_id")
注释指定OrderItem映射表的order_id列作为外键与Order 映射表的主键列关联。
@ManyToOne
：指明OrderItem和Order之间为多对一关系。
@ManyToOne
注释有四个属性：targetEntity、cascade、fetch 和optional，前三个属性的具体含义和@OneToMany的同名属性相同，但@ManyToOne的fetch 属性默认值是FetchType.EAGER。
optional
属性是定义该关联类是否必须存在，值为false 时，关联类双方都必须存在，如果关系被维护端不存在，查询的结果为null。值为true 时, 关系被维护端可以不存在，查询的结果仍然会返回关系维护端，在关系维护端中指向关系被维护端的属性为null。optional属性的默认值是true。optional 属性实际上指定关联类与被关联类的join 查询关系，如optional=false 时join 查询关系为inner join, optional=true 时join 查询关系为left join。下面代码片断解释如下:
有一点需要强调：当业务方法需要把一个实体
Bean
作为参数返回给客户端时，除了实体
Bean
本身需要实现
Serializable
接口之外
，如果关联类(OrderItem)是延迟加载，还需在返回实体Bean之前通过访问关联类的方式加载关联类（见下例）。否则在客户端访问关联类时将会抛出加载例外。
public
Order getOrderByID(Integer orderid) {
Order order =
em
.find(Order.
class
, orderid);
//!!!!!
因为是延迟加载，通过执行
size()
这种方式获取订单下的所有订单项
order.getOrderItems().size();
return
order;
}
另外不管是否延迟加载，通过join fetch 关联语句都可显式加载关联类
，如下例：
public
List getAllOrder() {
Query query =
em
.createQuery(
"select DISTINCT o from Order o inner
join fetch o.orderItems order by o.orderid"
);
List result = query.getResultList();
return
result;
}
转自：
http://blog.csdn.net/gebitan505/article/details/22619175
http://blog.csdn.net/lxl_family/article/details/26523757
扫一扫
4628
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
