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

}