`

JPA一对多和多对一关系

阅读更多

     1-m:多的一方为关系维护端,关系维护端负责外键纪录的更新,关系被维护端没有权力更新外键纪录.

 

维护端注解

 

@OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH,
			CascadeType.MERGE, CascadeType.REMOVE },
                       fetch = FetchType.EAGER,
                       mappedBy = "order")

被维护端注解

 

@ManyToOne(cascade = { CascadeType.MERGE, CascadeType.REFRESH }, optional = false)
@JoinColumn(name = "order_id")

 

 

 

对于一对多和多对一关系的现实中的例子是,网上购物时的订单和订单项。一个订单有多个订单项。多个订单项属于一个订单。

 

订单实体类:

package com.taoistwar.jpa.entity.onetomany;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name = "order_info")
public class OrderInfo {
	private Integer id;
	private String name;

	private Set<OrderItem> items = new HashSet<OrderItem>();

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH,
			CascadeType.MERGE, CascadeType.REMOVE }, fetch = FetchType.EAGER, 
                       mappedBy = "order")
	public Set<OrderItem> getItems() {
		return items;
	}

	public void setItems(Set<OrderItem> items) {
		this.items = items;
	}

	public void addOrderItem(OrderItem orderItem) {
		orderItem.setOrder(this);
		this.items.add(orderItem);
	}

}

 重点在于:

       @OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH,
			CascadeType.MERGE, CascadeType.REMOVE }, fetch = FetchType.EAGER,
                       mappedBy = "order")
	public Set<OrderItem> getItems() {
		return items;
	}

 订单项实体类:

package com.taoistwar.jpa.entity.onetomany;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = "order_item")
public class OrderItem {
	private Integer Id;
	private String name;

	private OrderInfo order;

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	public Integer getId() {
		return Id;
	}

	public void setId(Integer id) {
		Id = id;
	}

	@Column(length = 20, nullable = true)
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@ManyToOne(cascade = { CascadeType.MERGE, CascadeType.REFRESH }, optional = false)
	@JoinColumn(name = "order_id")
	public OrderInfo getOrder() {
		return order;
	}

	public void setOrder(OrderInfo order) {
		this.order = order;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((Id == null) ? 0 : Id.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		OrderItem other = (OrderItem) obj;
		if (Id == null) {
			if (other.Id != null)
				return false;
		} else if (!Id.equals(other.Id))
			return false;
		return true;
	}

}

 重点在于:

       @ManyToOne(cascade = { CascadeType.MERGE, CascadeType.REFRESH }, optional = false)
	@JoinColumn(name = "order_id")
	public OrderInfo getOrder() {
		return order;
	}

 测试类:

package com.taoistwar.jpa.entity.onetomany;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import org.junit.Test;


public class OneToMany {
	@Test
	public void save() {
		EntityManagerFactory emf = Persistence
				.createEntityManagerFactory("JPAPU");
		EntityManager em = emf.createEntityManager();
		em.getTransaction().begin();
		OrderInfo o = new OrderInfo();
		o.setName("订单一");
		OrderItem oi1 = new OrderItem();
		oi1.setName("产品一");
		o.addOrderItem(oi1);
		OrderItem oi2 = new OrderItem();
		oi2.setName("产品一");
		o.addOrderItem(oi2);
		OrderItem oi3 = new OrderItem();
		oi3.setName("产品一");
		o.addOrderItem(oi3);
		OrderItem oi4 = new OrderItem();
		oi4.setName("产品一");
		o.addOrderItem(oi4);
		em.persist(o);
		// UUID.randomUUID().toString();
		em.getTransaction().commit();
		emf.close();
	}
}
 

 

 

 

  • JPA.zip (5.7 MB)
  • 下载次数: 543
分享到:
评论

相关推荐

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

    **概念**:一对多关系表示一个实体可以与多个其他实体相关联,比如一个用户可以有多个订单。在数据库中,这通常通过在多方实体的表中添加外键实现。 **配置方式**: - 在一方实体上使用`@OneToMany`注解,表示一个...

    Hibernate annotation JPA 一对多,多对多

    在现实世界中,一个老师可以教多个学生,或者一个班级可以包含多个学生,这就是典型的一对多关系。在Hibernate中,我们使用`@OneToMany`注解来表示这种关系。例如,在`Teacher`类中,我们可以定义一个`List...

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

    一、JPA一对多关系 在数据库中,一对多关系意味着一个实体可以与多个其他实体关联。例如,一个学生可以属于多个班级(多对一),而一个班级可以包含多个学生(一对多)。在JPA中,我们通过在实体类上使用`@...

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

    总结来说,JPA的一对多关系和延迟加载是两个非常重要的概念,它们帮助我们在Java应用程序中更高效、更灵活地处理数据库操作。了解和熟练运用这两个特性,能够提升代码的质量,同时优化数据库交互,提高系统的整体...

    JPA_2_一对多双向关联关系

    **JPA 2 一对多双向关联关系** Java Persistence API(JPA)是Java平台上的一个标准,用于处理对象关系映射(ORM),使得开发者可以使用面向对象的方式操作数据库。在JPA中,一对多关联关系是常见的实体间关系类型...

    JPA多对多Demo

    对于多对多关系,我们需要在双方实体类中分别添加一个`@ManyToMany`注解的集合属性,表示另一方实体的集合。例如: ```java @Entity @Table(name = "teacher") public class Teacher { @Id @GeneratedValue...

    jpa的一对多和多对多代码

    在数据库中,一对多关系意味着一个父实体可以关联多个子实体,而每个子实体只能属于一个父实体。在JPA中,我们可以使用`@OneToMany`注解来定义这种关系。 ```java @Entity public class ParentEntity { @Id @...

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

    例如,一个学生可以选修多门课程,一门课程也可以被多名学生选修,这就是典型的多对多关系。在这个主题中,我们将深入探讨如何在JPA中定义和配置双向多对多关联实体,并通过注解进行设置。 首先,我们需要了解JPA中...

    14_传智播客JPA详解_JPA中的多对多双向关联的各项关系操作

    例如,学生和课程之间的关系就是一个典型的多对多关系:一个学生可以选修多门课程,一门课程也可以被多个学生选修。在JPA中,这种关系通过`@ManyToMany`注解来表示。 **双向关联**意味着在两个实体类中都有对彼此的...

    JPA常用关系实现例子

    2. **一对多关系(OneToMany)**: 一个实体可以与多个其他实体相关联,这在现实世界中很常见。使用@OneToMany注解来定义这种关系,通常还需要使用@JoinColumn或@JoinTable来指定如何存储关联。例如,一个部门实体...

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

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

    JPA和Hibernate的关系

    ### JPA与Hibernate的关系 ...而Hibernate作为JPA的一种强大实现,不仅完全兼容JPA,还提供了更多的高级功能和灵活性。对于希望利用标准化API进行数据库操作的开发者而言,JPA和Hibernate都是非常有价值的工具。

    jpa的实体映射关系7种

    双向一对多关系中,一方实体可以拥有多个另一方实体,而另一方实体也知晓这个关系。双方都需要使用`@OneToMany`和`@ManyToOne`注解来定义关系,且`mappedBy`应设置在`@OneToMany`的一侧。 5. **双向多对一**: 相...

    JPA映射关系详解javax JPA JPA映射关系 JPA映射

    一对多关系表示一个实体可以与多个实体关联。在 JPA 中,使用 `@OneToMany` 注解来定义这种关系,并通过 `@JoinColumn` 指定关联字段。 **示例代码:** ```java @OneToMany @JoinColumn(name = "CUST_ID") private...

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

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

    JPA一对多双向配置实例

    **JPA一对多双向配置实例详解** 在Java Persistence API (JPA)中,"一对多"关系是数据库中常见的关联类型,它表示一个实体(如用户)可以与多个其他实体(如订单)相关联。本实例将深入探讨如何在JPA中配置一对多的...

    JPA一对多映射关系解析

    为了方便广大开发朋友的需要特整理一下有关jpa映射关系,希望可以帮助到一些朋友。

    jpa--9.单向多对一

    单向多对一"表明我们将讨论如何在JPA中设置和管理这种关系。描述中的重复文字可能是由于输入错误,我们主要关注"单向多对一"这一主题。 首先,我们来理解一下"多对一"关系的基本概念。在数据库设计中,如果一个表的...

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

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

Global site tag (gtag.js) - Google Analytics