订单和订单项就是一对多的关系。一个订单有多个订单项，一个订单项属于某个订单。
订单和订单项映射后的表结构如下：
订单表结构
订单项表结构
下面就以订单和订单项为例介绍多对多映射关系的实例开发
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);
* 删除订单项
public void removeorderitem(orderitem item) {
if (this.items.contains(item)) {
item.setorder(null);
this.items.remove(item);
orderitem订单项类
import javax.persistence.generatedvalue;
import javax.persistence.joincolumn;
import javax.persistence.manytoone;
* many端
* 在one-to-many双向关联中，多的一方为关系维护端，关系维护端负责外键记录的更新
* 关系被维护端是没有权力更新外键记录的
@table(name = "tb_orderitem")
public class orderitem implements java.io.serializable {
@generatedvalue
private integer id;
@column(length = 40, nullable = false)
private string productname;
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() {
public orderitem(string productname, float sellprice) {
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) {
public float getsellprice() {
return sellprice;
public void setsellprice(float 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.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对象（即：父对象删除时子对象跟着删除）
public void detele1(){
order order=em.getreference(order.class, "xxxx");
em.remove(order);
* 删除子对象时，父对象没影响
public void detele2(){
orderitem item=em.getreference(orderitem.class, (serializable)3);
em.remove(item);
//运行结果为：
//orderid:xxxx, amount:34.0
//productname:足球price:20.0
//productname:篮球price:25.0
//===============
public void find1(){
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("===============");
//运行结果为
//============
public void find2(){
list<orderitem> items=em.createquery("select o from orderitem o").getresultlist();
for(orderitem item:items){
order order=item.getorder();
system.out.println("============");
* 测试jpa环境是否搭建成功
public void test() {
persistence.createentitymanagerfactory("ljq");