`
林里风咏
  • 浏览: 12776 次
  • 性别: Icon_minigender_1
  • 来自: 湖南长沙
最近访客 更多访客>>
社区版块
存档分类
最新评论

JPA实现一对多

    博客分类:
  • JPA
阅读更多
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();
	}

}

0
0
分享到:
评论

相关推荐

    Hibernate annotation JPA 一对多,多对多

    同时,还需要在`Teacher`类中添加一个`List&lt;Student&gt;`字段,用`@OneToMany`注解来实现一对多关系,形成双向关联。 3. **多对多关系**: 学生和班级的关系可以是多对多,因为一个学生可以属于多个班级,反过来,一...

    JPA一对多和多对一关系

    **JPA一对多和多对一关系详解** Java Persistence API(JPA)是Java平台上的一个标准,用于处理对象关系映射(ORM),使得开发者可以使用面向对象的方式来操作数据库。在JPA中,实体间的关系映射是核心概念之一,...

    JPA一对一,一对多,多对多关系映射

    本篇将深入探讨JPA中的一对一(OneToOne)、一对多(OneToMany)以及多对多(ManyToMany)关系映射。 ### 1. JPA 一对一(OneToOne)关系映射 **概念**:一对一关系意味着两个实体之间存在唯一的关联,一个实体...

    11_传智播客JPA详解_JPA中的一对多延迟加载与关系维护

    本教程“11_传智播客JPA详解_JPA中的一对多延迟加载与关系维护”聚焦于JPA在处理一对多关系时的延迟加载机制以及如何有效地维护这些关系。 一、JPA一对多关系 在数据库中,一对多关系意味着一个实体可以与多个其他...

    11_JPA详解_JPA中的一对多延迟加载与关系维护.zip

    要在一对多关系中实现延迟加载,我们需要在`@OneToMany`注解上添加`fetch = FetchType.LAZY`。这告诉JPA应该在需要时才去加载关联的实体集合,而不是在加载父实体时一并加载。然而,需要注意的是,由于Java的反射...

    JPA_2_一对多双向关联关系

    在这个场景中,我们将深入探讨如何在JPA 2中实现一对多双向关联关系。 首先,我们需要定义两个实体,一个是"一"的一端,另一个是"多"的一端。假设我们有`Department`(部门)和`Employee`(员工)两个实体。在`...

    jpa的一对多和多对多代码

    本篇文章将深入探讨JPA中的一对多和多对多关系的实现,通过具体的代码示例来帮助理解。 ### 1. 一对多关系 在数据库中,一对多关系意味着一个父实体可以关联多个子实体,而每个子实体只能属于一个父实体。在JPA中...

    JPA多对多Demo

    本示例中的“JPA多对多Demo”是一个具体的实践案例,展示了如何在JPA中实现多对多关联关系,以及对应的增删改查方法。 多对多关联是现实世界中常见的一种关系类型,例如教师和学生之间的关系,一个教师可以教多个...

    JPA中的一对多双向关联与级联操作

    在Java Persistence API (JPA) 中,一对多关联是一种常见的关系映射,它表示一个实体可以与多个其他实体相关联。这种关联在数据库层面通常通过外键实现,而在JPA中,我们通过注解来配置这种关系。这篇博客将深入探讨...

    13_jpa多对多双向关联实体定义与注解

    4. **注解细节**:`@JoinColumn`用于单向一对一或一对多关系,而在多对多关系中,通常使用`@JoinTable`来指定中间表的信息,包括表名、连接列等。 5. **操作关联**:在JPA中,可以通过添加或移除对象到集合属性来...

    jpa实现数据库操作

    - **一对多(OneToMany)**: 一个实体对应多个实体实例。 - **多对一(ManyToOne)**: 多个实体对应一个实体实例。 - **多对多(ManyToMany)**: 多个实体对应多个实体实例,通常需要一个关联表来维护关系。 6. ...

    JPA中实现双向多对多的关联关系示例代码

    本文将深入探讨在JPA中如何实现双向多对多的关联关系,并提供相关的示例代码。 首先,我们需要了解多对多关联关系的基本概念。在关系型数据库中,两个实体之间可能存在多对多的关系,意味着每个实例可以从一个实体...

    JPA中的多对多双向关联实体定义与注解设置

    下面,我们通过一个具体的例子来展示如何实现双向多对多关联。假设我们有`Student`和`Course`两个实体: ```java @Entity @Table(name = "student") public class Student { @Id private Long id; // 其他属性....

    JPA详解视频教程 第10讲 JPA中的一对多双向关联与级联操作.avi

    JPA用于整合现有的ORM技术,可以简化现有Java EE和Java SE应用对象持久化的开发工作,实现ORM的统一。JPA详解视频教程 第10讲 JPA中的一对多双向关联与级联操作.avi

    10_JPA详解_JPA中的一对多双向关联与级联操作.zip

    本资料包"10_JPA详解_JPA中的一对多双向关联与级联操作.zip"聚焦于JPA中的一个重要概念——一对多双向关联及其级联操作。以下是对这一主题的详细阐述。 **一对多关联** 在关系数据库设计中,一对多关联是最常见的...

    jpa例子jpajpa

    8. **多态性(Polymorphism)**: JPA支持继承和多态性,使得你可以定义一个基类,然后多个子类继承它并有自己的数据库表。 在"apache-openjpa-1.2.0-source"这个压缩包中,包含了Apache OpenJPA项目的源代码。Open...

    JPA规范实现与总结

    1. **可移植性**:由于JPA是基于标准API构建的,因此可以在不同的JPA实现之间轻松迁移,无需修改业务代码。 2. **简化开发**:通过使用注解,JPA简化了数据库交互代码的编写,开发者可以专注于业务逻辑而非数据访问...

    jpa--9.单向多对一

    在Java代码中,我们可以通过以下方式实现单向多对一的映射: 1. **实体定义**: - 在"多"端实体(Employee)中,我们需要添加一个对"一"端实体(Department)的引用。这通常是一个`@ManyToOne`注解的字段。 - ...

    使用springboot + JPA / MyBatis 实现多数据源动态切换

    **四、使用JPA实现动态切换** 1. **Repository接口**:创建带有特定数据源注解的Repository接口,例如`@RepositoryDataSource("secondary")`。 2. **Service层**:在Service层中注入Repository接口,Spring会根据...

Global site tag (gtag.js) - Google Analytics