jpa一对多映射案例
订单和订单项就是一对多的关系。一个订单有多个订单项，一个订单项属于某个订单。
订单和订单项映射后的表结构如下：
订单表结构
订单项表结构
下面就以订单和订单项为例介绍多对多映射关系的实例开发
persistence.xml配置文件
<?
xml version
=
"
1.0
"
?>
<
persistence xmlns
=
"
http://java.sun.com/xml/ns/persistence
"
xmlns:xsi
=
"
http://www.w3.org/2001/XMLSchema-instance
"
xsi:schemaLocation
=
"
http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd
"
version
=
"
1.0
"
>
<!--
事务类型：本地事务(仅针对一个数据库)和全局事务(针对多个数据库)；RESOURCE_LOCAL: 本地事务
-->
<
persistence
-
unit name
=
"
ljq
"
transaction
-
type
=
"
RESOURCE_LOCAL
"
>
<
properties
>
<
property name
=
"
hibernate.dialect
"
value
=
"
org.hibernate.dialect.MySQL5Dialect
"
/>
<
property name
=
"
hibernate.connection.driver_class
"
value
=
"
org.gjt.mm.mysql.Driver
"
/>
<
property name
=
"
hibernate.connection.username
"
value
=
"
root
"
/>
<
property name
=
"
hibernate.connection.password
"
value
=
"
mysql
"
/>
<
property name
=
"
hibernate.connection.url
"
value
=
"
jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
"
/>
<
property name
=
"
hibernate.hbm2ddl.auto
"
value
=
"
update
"
/>
</
properties
>
</
persistence
-
unit
>
</
persistence
>
Order订单类
package
com.ljq.entity;
import
java.util.HashSet;
import
java.util.Set;
import
javax.persistence.CascadeType;
import
javax.persistence.Column;
import
javax.persistence.Entity;
import
javax.persistence.FetchType;
import
javax.persistence.Id;
import
javax.persistence.OneToMany;
import
javax.persistence.Table;
/**
* one端
*
* 碰到many为末端的加载就是延迟加载，若one为末端则为立即加载，除了one-to-one。
*
*
@author
jiqinlin
*
*/
@Entity
@Table(name
=
"
tb_order
"
)
@SuppressWarnings(
"
serial
"
)
public
class
Order
implements
java.io.Serializable {
//
String类型不能用uuid，需要人为指定
@Id
@Column(length
=
12
)
private
String orderid;
@Column(nullable
=
false
)
private
Float amount
=
0f;
//
@OneToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE,CascadeType.REMOVE})
//
mappedBy="order": 指明Order类为双向关系维护端，负责外键的更新
@OneToMany(cascade
=
CascadeType.ALL, fetch
=
FetchType.LAZY, mappedBy
=
"
order
"
)
private
Set
<
OrderItem
>
items
=
new
HashSet
<
OrderItem
>
();
public
Order() {
super
();
}
public
Float getAmount() {
return
amount;
}
public
void
setAmount(Float amount) {
this
.amount
=
amount;
}
public
String getOrderid() {
return
orderid;
}
public
void
setOrderid(String orderid) {
this
.orderid
=
orderid;
}
public
Set
<
OrderItem
>
getItems() {
return
items;
}
public
void
setItems(Set
<
OrderItem
>
items) {
this
.items
=
items;
}
////////////////////////////////////
/**
* 添加订单项
*
*
@param
student
*/
public
void
addOrderItem(OrderItem item) {
if
(
!
this
.items.contains(item)) {
this
.items.add(item);
item.setOrder(
this
);
}
}
/**
* 删除订单项
*
*
@param
student
*/
public
void
removeOrderItem(OrderItem item) {
if
(
this
.items.contains(item)) {
item.setOrder(
null
);
this
.items.remove(item);
}
}
}
OrderItem订单项类
package
com.ljq.entity;
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;
import
javax.persistence.Table;
/**
* many端
*
* 在one-to-many双向关联中，多的一方为关系维护端，关系维护端负责外键记录的更新
* 关系被维护端是没有权力更新外键记录的
*
*
@author
jiqinlin
*
*/
@Entity
@Table(name
=
"
tb_orderitem
"
)
@SuppressWarnings(
"
serial
"
)
public
class
OrderItem
implements
java.io.Serializable {
@Id
@GeneratedValue
private
Integer id;
@Column(length
=
40
, nullable
=
false
)
private
String productName;
@Column(nullable
=
false
)
private
Float sellPrice
=
0f;
//
optional=true：可选，表示此对象可以没有，可以为null；false表示必须存在
@ManyToOne(cascade
=
{ CascadeType.REFRESH, CascadeType.MERGE }, optional
=
true
)
@JoinColumn(name
=
"
order_id
"
)
private
Order order;
public
OrderItem() {
super
();
}
public
OrderItem(String productName, Float sellPrice) {
super
();
this
.productName
=
productName;
this
.sellPrice
=
sellPrice;
}
public
Integer getId() {
return
id;
}
public
void
setId(Integer id) {
this
.id
=
id;
}
public
String getProductName() {
return
productName;
}
public
void
setProductName(String productName) {
this
.productName
=
productName;
}
public
Float getSellPrice() {
return
sellPrice;
}
public
void
setSellPrice(Float sellPrice) {
this
.sellPrice
=
sellPrice;
}
public
Order getOrder() {
return
order;
}
public
void
setOrder(Order order) {
this
.order
=
order;
}
}
OrderTest测试类
package
com.ljq.test;
import
java.io.Serializable;
import
java.util.List;
import
java.util.Set;
import
java.util.UUID;
import
javax.persistence.EntityManager;
import
javax.persistence.EntityManagerFactory;
import
javax.persistence.Persistence;
import
org.junit.Test;
import
com.ljq.entity.Order;
import
com.ljq.entity.OrderItem;
import
com.sun.org.apache.xpath.internal.operations.Or;
public
class
OrderTest {
/**
* 添加订单Order时同时添加两个订单项OrderItem，因为订单Order为双向关系维护者，起着主导作用
*/
@Test
public
void
save() {
EntityManagerFactory factory
=
Persistence.createEntityManagerFactory(
"
ljq
"
);
EntityManager em
=
factory.createEntityManager();
em.getTransaction().begin();
Order order
=
new
Order();
order.setAmount(34f);
//
UUID.randomUUID().toString()
order.setOrderid(
"
xxxx
"
);
order.addOrderItem(
new
OrderItem(
"
足球
"
,20f));
order.addOrderItem(
new
OrderItem(
"
篮球
"
,25f));
em.persist(order);
em.getTransaction().commit();
em.close();
factory.close();
}
/**
* 删除Order对象时，会自动删除OrderItem对象（即：父对象删除时子对象跟着删除）
*/
@Test
public
void
detele1(){
EntityManagerFactory factory
=
Persistence.createEntityManagerFactory(
"
ljq
"
);
EntityManager em
=
factory.createEntityManager();
em.getTransaction().begin();
Order order
=
em.getReference(Order.
class
,
"
xxxx
"
);
em.remove(order);
em.getTransaction().commit();
em.close();
factory.close();
}
/**
* 删除子对象时，父对象没影响
*/
@Test
public
void
detele2(){
EntityManagerFactory factory
=
Persistence.createEntityManagerFactory(
"
ljq
"
);
EntityManager em
=
factory.createEntityManager();
em.getTransaction().begin();
OrderItem item
=
em.getReference(OrderItem.
class
, (Serializable)
3
);
em.remove(item);
em.getTransaction().commit();
em.close();
factory.close();
}
//
运行结果为：
//
orderid:xxxx, amount:34.0
//
productName:足球price:20.0
//
productName:篮球price:25.0
//
===============
@Test
public
void
find1(){
EntityManagerFactory factory
=
Persistence.createEntityManagerFactory(
"
ljq
"
);
EntityManager em
=
factory.createEntityManager();
em.getTransaction().begin();
List
<
Order
>
orders
=
em.createQuery(
"
select o from Order o
"
).getResultList();
for
(Order order:orders){
System.out.println(
"
orderid:
"
+
order.getOrderid()
+
"
,
"
+
"
amount:
"
+
order.getAmount());
Set
<
OrderItem
>
orderItems
=
order.getItems();
for
(OrderItem item:orderItems){
System.out.println(
"
productName:
"
+
item.getProductName()
+
"
price:
"
+
item.getSellPrice());
}
System.out.println(
"
===============
"
);
}
em.close();
factory.close();
}
//
运行结果为
//
productName:足球price:20.0
//
orderid:xxxx, amount:34.0
//
============
//
productName:篮球price:25.0
//
orderid:xxxx, amount:34.0
//
============
@Test
public
void
find2(){
EntityManagerFactory factory
=
Persistence.createEntityManagerFactory(
"
ljq
"
);
EntityManager em
=
factory.createEntityManager();
em.getTransaction().begin();
List
<
OrderItem
>
items
=
em.createQuery(
"
select o from OrderItem o
"
).getResultList();
for
(OrderItem item:items){
System.out.println(
"
productName:
"
+
item.getProductName()
+
"
price:
"
+
item.getSellPrice());
Order order
=
item.getOrder();
System.out.println(
"
orderid:
"
+
order.getOrderid()
+
"
,
"
+
"
amount:
"
+
order.getAmount());
System.out.println(
"
============
"
);
}
em.close();
factory.close();
}
/**
* 测试jpa环境是否搭建成功
*
*/
@Test
public
void
test() {
Persistence.createEntityManagerFactory(
"
ljq
"
);
}
}