JPA映射关系

最新推荐文章于 2025-05-11 06:00:00 发布
原创 最新推荐文章于 2025-05-11 06:00:00 发布 · 508 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文 遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。【个人网站： www.andus.top 】
文章标签：

#jpa

本文深入探讨了实体间关系管理的多种模式，包括单向多对一、单向一对多、双向一对多、双向一对一及双向多对多的关系处理策略。详细解析了不同关系类型在保存、查询、删除及更新操作中的行为特点，以及如何优化关联关系以减少SQL语句的执行。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

单向多对一

场景

一个顾客N个订单，一个订单属于1个顾客。

// Order.class
@JoinColumn(name="buyer_id")// 映射外键列名
// 及时查询(默认)：fetch=FetchType.EAGER、懒加载：fetch=FetchType.LAZY
@ManyToOne // 映射单向多对一。
publice Buyer getBuyer(){
	return buyer;
}

测试

保存
	@Test
	public void persist() {
		Buyer buyer = new Buyer();
		// ...添加属性

		Order o1 = new Oreder();
		// ...添加属性
		Order o1 = new Oreder();
		// ...添加属性

		buyer.getOrders().add(o1);
		buyer.getOrders().add(o2);

		/**
		 insert into buyer ...
		 insert into order ..
		 insert into order ..
		 update order set buyer_id ..
		 update order set buyer_id ..
		 */
		entityManager.persist(buyer);
		entityManager.persist(o1);
		entityManager.persist(o2);

		/**
		 insert into buyer ...
		 insert into order ..
		 insert into order ..
		 update order set buyer_id ..
		 update order set buyer_id ..
		 */
		entityManager.persist(o1);
		entityManager.persist(o2);
		entityManager.persist(buyer);
	}
  • 小结
    （先1后N）单向多对一时，优先保存1的一端，后保存N的一端, 效率更高
查询
/**
select xxx from order left join buyer on ..
where order.id = ?
*/
@Test
public void find(){
	Order o1 = entityManager.find(Order.class, {主键值});
	System.out.println(o1.getXx());

	System.out.println(o1.getBuyer().getXxx());
}
  • 小结
  1. 默认使用及时查询，默认会使用左外连接查询出1的一端。
  2. 采用懒加载，会先查询出N端，再查询出1的一端。
删除
// 删除多的一端
@Test
public void removeN(){
	Order o1 = entityManager.find(Order.class, {主键});
	entityManager.remove(o1);
}
// 删除有映射关系的1的一端
@Test
public void remove1(){
	Buyer buyer = entityManager.find(Buyer.class, {主键});
	entityManager.remove(buyer);
}
  • 小结
  1. 删除N端时，能正常删除。
  2. 删除1的一端时，不能直接删除。因为有外键关联。
更新
public void update(){
	Order o1 = entityManager.find(Order.class, {主键});
	// 完成更新
	o1.getBuyer().setXxx(xx);
}
  • 小结
    更改持久化对象（entityManager查询出来的对象），会同步更新到数据库

结论

  • 保存时，单向多对一时，优先保存1的一端，后保存N的一端。
  • 查询N端时，默认会使用左外连接查询出1的一端,即默认使用的及时查询策略。
  • 不能直接删除1的一端，因为有外键关联。
  • 更改持久化对象，会同步更新到数据库。

单向一对多

// Buyer.class
Set<Order> orders = new HashSet();

@JoinColumn(name="buyer_id")// 映射外键列名
/** 及时查询(默认)：fetch=FetchType.EAGER、懒加载：fetch=FetchType.LAZY
级联删除属性：级联删除：cascad={CascadeType.REMOVE}
*/
@OneToMany // 映射单向一对多。
publice Set<Order> getOrders(){
	return orders;
}

测试

保存
@Test
public void persist(){
		Buyer buyer = new Buyer();
		// ...添加属性

		Order o1 = new Oreder();
		// ...添加属性
		Order o1 = new Oreder();
		// ...添加属性

		buyer.getOrders().add(o1);
		buyer.getOrders().add(o2);

		/**
		 insert into buyer ...
		 insert into order ..
		 insert into order ..
		 update order set buyer_id ..
		 update order set buyer_id ..
		 */
		entityManager.persist(buyer);
		entityManager.persist(o1);
		entityManager.persist(o2);

		/**
		 insert into buyer ...
		 insert into order ..
		 insert into order ..
		 update order set buyer_id ..
		 update order set buyer_id ..
		 */
		entityManager.persist(o1);
		entityManager.persist(o2);
		entityManager.persist(buyer);
	}
  • 小结
    先保存1端还是N端，都会执行update语句，因为关联关系是1的一端在维护。
查询
@Test
public void find(){
	Buyer buyer = entityManager.find(Buyer.class, {主键});

// 默认懒加载策略，两条select语句	System.out.println(buyer.getXx());
System.out.println(buyer.getOrders().size());

// 及时查询策略时，select .. from buyer left outer join oreder on ..
}
  • 小结
  1. 默认对关联的N端使用懒加载策略。
  2. 如果采用及时查询策略，会执行左外连接查询语句。
删除
@Test
public void remove(){
	Buyer buyer = entityManager.find(Buyer.class,{主键});
	
	// 能直接删除1的一端。先执行order表中对应值外键置空，再删除buyer中数据。
	entity.Manager.remove(buyer);
}
  • 小结
  1. 默认不执行级联删除，若删除1的一端，会先将关联的外键置空，在删除1的一端。
更新
  1. 可以修改@OneToMany的cascad属性为{CascadeType.REMOVE}，实现级联删除。
@Test
public void update(){
	Buyer buyer = entityManager.find(Buyer.class,{主键});

	buyer.getOrders().iterator().next().setOrderName("xx");
}

结论

  1. 单向1对N时，关联关系执行保存时，一定会多执行update语句，因为关联关系是1的一端在维护，N端在插入时不会插入外键列。
  2. 查询时，默认对关联的N端使用懒加载策略。如果采用及时查询策略，会执行左外连接查询语句。
  3. 删除时，默认不是级联删除，若删除1的一端，会先将关联的外键置空，在删除1的一端。可以修改@OneToMany的cascad属性为{CascadeType.REMOVE}，实现级联删除。

双向一对多

// Order.class
@JoinColumn(name="buyer_id")// 映射外键列名
// 及时查询(默认)：fetch=FetchType.EAGER、懒加载：fetch=FetchType.LAZY
@ManyToOne // 映射单向多对一。
publice Buyer getBuyer(){
	return buyer;
}

// Buyer.class
Set<Order> orders = new HashSet();

// @JoinColumn(name="buyer_id")// 映射外键列名
/** 及时查询(默认)：fetch=FetchType.EAGER、懒加载：fetch=FetchType.LAZY
级联删除属性：级联删除：cascad={CascadeType.REMOVE}
关联关系维护：mappedBy="buyer" 申明，由N端维护关联关系。此时不能定义@JoinColumn属性。
*/
@OneToMany(mappedBy="buyer") // 映射单向一对多。
publice Set<Order> getOrders(){
	return orders;
}

测试

保存
@Test
public void persist(){
	Buyer buyer = new Buyer();
	// ...添加属性

	Order o1 = new Oreder();
	// ...添加属性
	Order o1 = new Oreder();
	// ...添加属性

	// 建立关联关系
	buyer.getOrders().add(o1);
	buyer.getOrders().add(o2);

	o1.setBuyer(buyer);
	o2.setBuyer(buyer);

	/**
	// 先保存N的一端
	 insert into order .. # buyer_id为null
	 insert into order .. # buyer_id为null
	 insert into buyer ..
	 // 从order方维护一次关联关系
	 update order set order ..
	 update order set order ..
 	// 从buyer方维护一次关联关系
	 update order set order ..
	 update order set order ..
	 */
	entityManager.persist(o1);
	entityManager.persist(o2);
	entityManager.persist(buyer);

	/**
	// 先保存1的一端
	
	*/
	entityManager.persist(buyer);
	entityManager.persist(o1);
	entityManager.persist(o2);
	
	
	
}
  • 小结
  1. 双向1对N时，若先保存N端，默认会多出n条update语句。若先保存1的一端，会多出n条buyer维护的update
  2. 在进行双向 1对N关联关系时，建议使用N的一端进行关联关系的维护，1的一端不维护，这样会有效减少SQL语句。

结论

  • 在进行双向 1对N关联关系时，建议使用N的一端进行关联关系的维护，1的一端不维护，这样会有效减少SQL语句。可通过在1的一端@OneToManay的mappedBy="{N端中，1端的属性名}" 申明，由N端维护关联关系，此时@JoinColumn属性不能再1的一端使用。

双向一对一

一个经理只能管一个部门，一个部门只能被一个经理管。

// Manager.class
// 及时查询(默认)：fetch=FetchType.EAGER、懒加载：fetch=FetchType.LAZY
@OneToOne(mappedBy="mgr") // 映射双向一对一。使用对方的哪个属性
publice Department getDept(){
	return dept;
}

// Department.class
@JoinColumn(name="mgr_id", unique=true)
@OneToOne
public Manager getMgr(){
	return mgr;
}

测试

保存
@Test
public void persist(){
	Manager mgr = new Manager();
	// 设置属性..
	
	Department dept = new Department();
	// 设置属性..

	mgr.setDept(dept);
	dept.setMgr(mgr);


	// 先保存不维护关联关系的一方。	entityManager.persist(mgr);
	entityManager.persist(dept);
}
  • 小结
    建议先保存不维护关联关系的一方，否则会多出update语句。
查询
@Test
public void find(){
	// 获取维护关联关系的一方
	Department dept = entityManager.find(Department.class,{主键});
	System.out.println(dept.getXx());
	System.out.println(dept.getMgr().getXx());

	// 获取不维护关联关系的一方
	Manager mgr = entityManager.find(Manager.class,{主键});
	System.out.println(mgr.getXx());
	
	// 此时不清楚当前mgr有关联关系的dept是否存在。所以，无论怎样都会执行sql语句去查询。	System.out.println(mgr.getDept().getXx());
}
  • 小结
  1. 默认（及时查询），获取维护关联关系的一方，会通过左外连接获取关联对象。可通过@OneToOne的fetch属性修改策略。
  2. 默认（及时查询），获取不维护关联关系的一方，会通过左外连接获取关联对象。且@OneToOne的fetch属性修改为LAZY后，反而还会多发一条SQL。

结论

  1. 需要确定哪一方维护关联关系。
  2. 双向1对1，@JoinColumn需要添加unique=true
  3. 无外键的一方，需要设置mappedBy="{对方维护映射关系的属性}"
  4. 双向1对1时，建议先保存无外键的一端，否则会多出update语句。
  5. 双向1对1时，先查询不维护关联关系的一端时，建议不修改不维护关联关系一端的@OneToOne的fetch属性为LAZY。

双向多对多

一个商品属于多个类别，一个类别有多个商品。

// Item.class
public Set<Category> categories = new HashSet();

@JoinTable(name="item_category",joinColumns={@JoinColumn(name="item_id", referencedColunmnName="{当前类的主键名称}")}, inverseJoinColumns={@JoinColumn(name="category_id", referencedColunmnName="{关联类的主键名称}")})// 映射表
// 及时查询(默认)：fetch=FetchType.EAGER、懒加载：fetch=FetchType.LAZY
@ManyToMany // 映射双向多对多。
publice Set<Category> getCategories(){
	return categories;
}

// Category.class
public Set<Item> items = new HashSet();

// @ManyToMany(mappedBy="{维护关联关系类中的关联属性名}")
@ManyToMany(mappedBy="categories")
public Set<Item> getItems(){
	return items;
}

测试

保存
@Test
public void persist(){
	Item i1= new Item();
	Item i2= new Item();

	Category c1 = new Category();
	Category c2 = new Category();

	i1.getCategories().add(c1);
	i1.getCategories().add(c2);
	i2.getCategories().add(c1);
	i2.getCategories().add(c2);

	c1.getItems().add(i1);
	c1.getItems().add(i2);
	c2.getItems().add(i1);
	c2.getItems().add(i2);

	entityManager.persist(i1);
	entityManager.persist(i2);
	entityManager.persist(c1);
	entityManager.persist(c2);
}
查询
@Test
public void find(){
	// 获取维护关联关系的一方
	Item item = entityManager.find(Item.class, {主键});
	System.out.println(item.getXx());
	System.out.println(item.getCategories().size());

	// 获取非维护关联关系的一方
	Category c1 = entiryManager.find(Category.class, {主键});
	
	System.out.println(c1.getXx());
	System.out.println(c1.getItems().size());
}

结论

获取维护关联关系的一方，还是获取非维护关联关系的一方，都默认使用懒加载策略，且使用左外连接进行查询。

松林羊
关注
jpa中映射关系
weixin_45415977的博客
07-28 556
1.单向一对多 单向一对多用得比较少(性能差)，但是依然要求必须掌握，因为我们在使用双向一对多还会用到单向一对多的相应配置。 映射关系 @Entity public class Product { @Id @GeneratedValue private Long id; private String name; @Entity public class ProductDir ...
使用 JPA 进行对象关系映射-与数据库的轻松交互
一名热衷于技术的全栈开发者，专注于前端与后端的全面技术探索。在这里，我将分享我在技术领域的学习与成长，助力更多开发者的进步。
11-15 754
通过 JPA，Java 开发者能够快速地实现对象与关系数据库之间的映射。通过定义实体类及其注解，开发者可以避免繁琐的 SQL 操作，实现数据的持久化处理。此外，JPA 提供了灵活的查询机制及关系映射能力，使得数据库操作更具可读性和扩展性。在现代 Java 项目中，JPA 是构建稳定持久层的优选方案。
JPA关系映射
Mydwr的专栏
06-20 5457
JPA一对多双向 1-m:多的一方为关系维护端,关系维护端负责外键纪录的更新,关系被维护端没有权力更新外键纪录. 拥有mappedBy注解的实体类为关系被维护端，另外的实体类为关系维护端的。顾名思意，关系的维护端对关系（在多对多为中间关联表）的CRUD做操作。关系的被维护端没有该操作，不能维护关系。 @ManyToOne表示一个多对一的映射,该注解标注的属性通常是数据库表的外键 opt
Java关系映射入门：@OneToOne、@OneToMany、@ManyToOne、@ManyToMany
最新发布
程序媛学姐的博客
05-11 596
JPA提供的@OneToOne@OneToMany@ManyToOne和注解为开发者处理实体之间的关系提供了强大而方便的工具。通过合理使用这些注解，开发者可以将现实世界中的数据关系准确地映射到数据库中，同时保持Java代码的面向对象特性。在实际开发中，需要根据具体的业务需求选择合适的关系映射方式，以确保数据的一致性和完整性，提高开发效率和代码的可维护性。
jpa 映射关系
qq_41764878的博客
04-24 385
ex:【产品类Product--多方 ，产品分类ProductDir--一方】 单向一对多：给一方加上@OneToMany ex：【产品类Product--多方 ，产品分类ProductDir--一方】 双向多对一、一对多： 给多方加上@ManyToOne，给一方加上@OneToMany ex:【部门类Department--一方 ，员工类Employee--多方...
JPA的映射关系
weixin_45739442的博客
11-28 173
##JPA映射关系 ###单向一对一 onetoone；双向两边都写（用的很少），在实际中一般一对一直接写在一个表里面，所以了解这个就可以了。 ###单向一对多 onetomany；（几乎不用但是依然要求必须掌握，因为我们在使用双向一对多还会用到单向一对多的相应配置。），使用list或者set集合，并且会创建第三方中间表，对其进行一定优化（必须配置外键id，否则会多生成一张表，形成多对多的关系@J...
jpa映射关系详解[参照].pdf
10-19
jpa映射关系详解[参照].pdf
JPA映射关系详解javax JPA JPA映射关系 JPA映射
08-15
### JPA映射关系详解 Java Persistence API (JPA) 是一种用于管理关系型数据库中的数据的标准 Java 技术。JPA 提供了一种对象关系映射 (ORM) 方法来处理数据库，允许开发者以面向对象的方式操作数据库。本文将详细...
JPA映射关系,多种映射关系的图解
09-02
JPA映射关系,多种映射关系的图解，适合EJB初学者，对JPA映射关系的了解.
jpa的实体映射关系7种
02-23
在Java Persistence API (JPA) 中，实体映射关系是数据库关系模型与Java对象模型之间的桥梁，用于在ORM（对象关系映射）框架下管理数据。JPA 提供了多种映射关系，使得开发者能够方便地处理不同类型的关联。下面我们...
JPA学习（五） 五种 映射关系
殇莫忆的博客
11-21 993
一、JPA_映射单向多对一的关联关系 1、创建实体类 //订单 @Table(name="JPA_ORDER") @Entity public class Order { private Integer id; private String orderName; private Customer customer; @Id @GeneratedValue public ...
JPA 映射关系
primarykey123的博客
07-28 227
1.单向一对多配置 // 一次性保存一方,同时保存2个多方 @Before public void persist() throws Exception { // 一方 ProductDir dir = new ProductDir(); dir.setName("类型1"); // 多方 Product product = new Product(); product....
Jpa映射关系
qq_43853427的博客
09-21 198
1.单向一对多 单向一对多用得比较少(性能差), @OneToMany 必须配置外键id，否则会多生成一张表，形成多对多的关系 ，保存代码: import cn.itsource.jpa.manytoone1.Product; import cn.itsource.jpa.manytoone1.ProductDir; import cn.itsource.util.JpaUtils; impor...
jpa关联映射(一）
weixin_30415113的博客
07-11 131
开发中常用到数据表的关联(其实很难遇到。。),spring-data-jpa(其实是hibernate)提供了一整套十分方便的注解来供我们使用表关联功能。 OneToOne OneToMany ManyToOne ManyToMany 举例之前，先理解两个表的关系中，哪一个是主体，一对一以及多对多需要自己按照现实场景来区分，而一对多和多对一始终是以多的一方为主体的。注解在使用中“...
JPA中映射关系详细说明(一对多，多对一，一对一、多对多）、@JoinColumn、mappedBy说明
热门推荐
z1340954953
06-22 1万+
JPA中的映射关系 jpa中维护one to one ,one to many, many to one ,many to many 四种映射关系。       在每个关系中，双方中的一方在其表中拥有连接列。那么一方称为所有方(owning side) 或者关系的所有者。 不具有连接列的一方称之为非所有方(non-owning)或者反方       所有权对于映射很重要，因为用于定义映射到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值