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