JPA实现一对多,以定单和定单项为例
1.Order.java 定单类
package com.cyberwise.jpa.one2many;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.Version;
@Entity
@Table(name = "orders")
public class Order implements Serializable {
@Version
private Long version;
@Id
private String orderId;
private Float amount = 0f;
@OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH,
CascadeType.REMOVE, CascadeType.MERGE }, fetch = FetchType.LAZY, mappedBy = "order")//这里配了mappedBy,也就是属于双向关联了,既可以从这张表找到另外一张表,也可以从别外的表找到这张表
private List<OrderItem> items = new ArrayList<OrderItem>();
public Order(){
}
@Column(name="版本号")
public Long getVersion() {
return version;
}
public void setVersion(Long version) {
this.version = version;
}
@Column(name="定单号",length = 12)
public String getOrderId() {
return orderId;
}
public void setOrderId(String orderId) {
this.orderId = orderId;
}
@Column(name="总数",nullable = false)
public Float getAmount() {
return amount;
}
public void setAmount(Float amount) {
this.amount = amount;
}
public List<OrderItem> getItems() {
return items;
}
public void setItems(List<OrderItem> items) {
this.items = items;
}
public void addOrderItem(OrderItem orderItem){
orderItem.setOrder(this);
this.items.add(orderItem);
}
}
2.OrderItem.java 定单项类
package com.cyberwise.jpa.one2many;
import java.io.Serializable;
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;
import javax.persistence.Version;
@Entity
@Table(name="orderitems")
public class OrderItem implements Serializable{
@Version
private Long version;
@Id
@GeneratedValue
private Integer id;
private String productName;
private Float sellPrice =0f;//默认为0
@ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)
@JoinColumn(name="order_id")//设置外键的名称
private Order order;
public OrderItem(){
}
@Column(name="版本号")
public Long getVersion() {
return version;
}
public void setVersion(Long version) {
this.version = version;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name="产品名称",length=40,nullable=false)
public String getProductName() {
return productName;
}
public void setProductName(String productName) {
this.productName = productName;
}
@Column(name="产品价格",nullable=false)
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;
}
}
3.One2ManyTest.java 测试类
package com.cyberwise.jpa.one2many;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import org.jboss.seam.annotations.In;
public class One2ManyTest {
@In
EntityManagerFactory factory;
@In
EntityManager manager;
public void save(){
factory = Persistence.createEntityManagerFactory("test");
manager = factory.createEntityManager();
manager.getTransaction().begin();
Order order = new Order();
order.setAmount(200f);
order.setOrderId("9002");
OrderItem orderItem = new OrderItem();
orderItem.setProductName("跳绳");
orderItem.setSellPrice(15f);
OrderItem orderItem2 = new OrderItem();
orderItem2.setProductName("橄榄球");
orderItem2.setSellPrice(200f);
order.addOrderItem(orderItem);
order.addOrderItem(orderItem2);
manager.persist(order);
manager.getTransaction().commit();
manager.close();
factory.close();
}
/**查看产品*/
public void query(){
factory = Persistence.createEntityManagerFactory("test");
manager = factory.createEntityManager();
String sql = "select o from OrderItem o where o.order='9002'";
List<OrderItem> productList = manager.createQuery(sql).getResultList();
System.out.println("产品名称:");
for(OrderItem o : productList){
System.out.println(o.getProductName());
}
manager.close();
factory.close();
}
/**这是修改定单表*/
public void update(){
factory = Persistence.createEntityManagerFactory("test");
manager = factory.createEntityManager();
manager.getTransaction().begin();
String ql ="update Order o set o.amount =:amount where o.orderId=:orderId";
Query query = manager.createQuery(ql);
query.setParameter("amount",100f );
query.setParameter("orderId", "9002");
query.executeUpdate();
manager.getTransaction().commit();
manager.close();
factory.close();
}
/**修改定单项*/
public void updateItem(){
factory = Persistence.createEntityManagerFactory("test");
manager = factory.createEntityManager();
manager.getTransaction().begin();
String sql = "update OrderItem o set o.order.orderId =:orderId where o.id=:id";
Query query = manager.createQuery(sql);
query.setParameter("orderId", "9001");
query.setParameter("id", 3);
query.executeUpdate();
manager.getTransaction().commit();
manager.close();
factory.close();
}
/**增加定单项*/
public void addProduct(){
factory = Persistence.createEntityManagerFactory("test");
manager = factory.createEntityManager();
manager.getTransaction().begin();
//增加定单号为9002的定单
String id = "9002";
Order order1 = manager.find(Order.class,id);
OrderItem orderItem = new OrderItem();
orderItem.setOrder(order1);
orderItem.setProductName("橄榄球");
orderItem.setSellPrice(115f);
manager.persist(orderItem);
manager.getTransaction().commit();
manager.close();
factory.close();
}
public static void main(String[] args) {
One2ManyTest test = new One2ManyTest();
// test.save();
test.query();
// test.update();
// test.updateItem();
// test.addProduct();
}
}
分享到:
相关推荐
同时,还需要在`Teacher`类中添加一个`List<Student>`字段,用`@OneToMany`注解来实现一对多关系,形成双向关联。 3. **多对多关系**: 学生和班级的关系可以是多对多,因为一个学生可以属于多个班级,反过来,一...
**JPA一对多和多对一关系详解** Java Persistence API(JPA)是Java平台上的一个标准,用于处理对象关系映射(ORM),使得开发者可以使用面向对象的方式来操作数据库。在JPA中,实体间的关系映射是核心概念之一,...
本篇将深入探讨JPA中的一对一(OneToOne)、一对多(OneToMany)以及多对多(ManyToMany)关系映射。 ### 1. JPA 一对一(OneToOne)关系映射 **概念**:一对一关系意味着两个实体之间存在唯一的关联,一个实体...
本教程“11_传智播客JPA详解_JPA中的一对多延迟加载与关系维护”聚焦于JPA在处理一对多关系时的延迟加载机制以及如何有效地维护这些关系。 一、JPA一对多关系 在数据库中,一对多关系意味着一个实体可以与多个其他...
要在一对多关系中实现延迟加载,我们需要在`@OneToMany`注解上添加`fetch = FetchType.LAZY`。这告诉JPA应该在需要时才去加载关联的实体集合,而不是在加载父实体时一并加载。然而,需要注意的是,由于Java的反射...
在这个场景中,我们将深入探讨如何在JPA 2中实现一对多双向关联关系。 首先,我们需要定义两个实体,一个是"一"的一端,另一个是"多"的一端。假设我们有`Department`(部门)和`Employee`(员工)两个实体。在`...
本篇文章将深入探讨JPA中的一对多和多对多关系的实现,通过具体的代码示例来帮助理解。 ### 1. 一对多关系 在数据库中,一对多关系意味着一个父实体可以关联多个子实体,而每个子实体只能属于一个父实体。在JPA中...
本示例中的“JPA多对多Demo”是一个具体的实践案例,展示了如何在JPA中实现多对多关联关系,以及对应的增删改查方法。 多对多关联是现实世界中常见的一种关系类型,例如教师和学生之间的关系,一个教师可以教多个...
在Java Persistence API (JPA) 中,一对多关联是一种常见的关系映射,它表示一个实体可以与多个其他实体相关联。这种关联在数据库层面通常通过外键实现,而在JPA中,我们通过注解来配置这种关系。这篇博客将深入探讨...
4. **注解细节**:`@JoinColumn`用于单向一对一或一对多关系,而在多对多关系中,通常使用`@JoinTable`来指定中间表的信息,包括表名、连接列等。 5. **操作关联**:在JPA中,可以通过添加或移除对象到集合属性来...
- **一对多(OneToMany)**: 一个实体对应多个实体实例。 - **多对一(ManyToOne)**: 多个实体对应一个实体实例。 - **多对多(ManyToMany)**: 多个实体对应多个实体实例,通常需要一个关联表来维护关系。 6. ...
本文将深入探讨在JPA中如何实现双向多对多的关联关系,并提供相关的示例代码。 首先,我们需要了解多对多关联关系的基本概念。在关系型数据库中,两个实体之间可能存在多对多的关系,意味着每个实例可以从一个实体...
下面,我们通过一个具体的例子来展示如何实现双向多对多关联。假设我们有`Student`和`Course`两个实体: ```java @Entity @Table(name = "student") public class Student { @Id private Long id; // 其他属性....
JPA用于整合现有的ORM技术,可以简化现有Java EE和Java SE应用对象持久化的开发工作,实现ORM的统一。JPA详解视频教程 第10讲 JPA中的一对多双向关联与级联操作.avi
本资料包"10_JPA详解_JPA中的一对多双向关联与级联操作.zip"聚焦于JPA中的一个重要概念——一对多双向关联及其级联操作。以下是对这一主题的详细阐述。 **一对多关联** 在关系数据库设计中,一对多关联是最常见的...
8. **多态性(Polymorphism)**: JPA支持继承和多态性,使得你可以定义一个基类,然后多个子类继承它并有自己的数据库表。 在"apache-openjpa-1.2.0-source"这个压缩包中,包含了Apache OpenJPA项目的源代码。Open...
在Java代码中,我们可以通过以下方式实现单向多对一的映射: 1. **实体定义**: - 在"多"端实体(Employee)中,我们需要添加一个对"一"端实体(Department)的引用。这通常是一个`@ManyToOne`注解的字段。 - ...
**四、使用JPA实现动态切换** 1. **Repository接口**:创建带有特定数据源注解的Repository接口,例如`@RepositoryDataSource("secondary")`。 2. **Service层**:在Service层中注入Repository接口,Spring会根据...