JPA学习（五）五种映射关系

Myth丶恋晨 2022-05-14 11:45 64阅读 0赞

## 一、JPA\_映射单向多对一的关联关系 ##

1、创建实体类

//订单
    @Table(name="JPA_ORDER")
    @Entity
    public class Order {
    	
    	private Integer id;	
    	private String orderName;	
    	private Customer customer;
    
    	@Id
    	@GeneratedValue
    	public Integer getId() {
    		return id;
    	}
    
    	public void setId(Integer id) {
    		this.id = id;
    	}
    
    	@Column(name="ORDER_NAME")
    	public String getOrderName() {
    		return orderName;
    	}
    
    	public void setOrderName(String orderName) {
    		this.orderName = orderName;
    	}
    
    	//映射多对一的关联关系
    	//使用 @ManyToOne 来映射多对一的关联关系
    	//使用 @JoinColumn 来映射外键  name：外键键名
    	@JoinColumn(name="CUSTOMER_ID")
    	@ManyToOne
    	public Customer getCustomer() {
    		return customer;
    	}
    
    	public void setCustomer(Customer customer) {
    		this.customer = customer;
    	}
    }

测试类：

//数据表生成
    	@Test
    	public void testManyToOne(){
    		
    	}

###  保存**数据  ：**  ###

**保存多对一时，建议先保存1的一端，然后保存 n 的一端，这样不会多出额外的 UPDATE 语句**

@Test
    	public void testManyToOnePersist(){
    		Customer customer = new Customer();
    		customer.setAge(15);
    		customer.setBirth(new Date());
    		customer.setCreatTime(new Date());
    		customer.setEmail("ee@flx.com");
    		customer.setLastName("EE");
    		
    		Order order1 = new Order();
    		order1.setOrderName("O-EE-1");
    		
    		Order order2 = new Order();
    		order2.setOrderName("O-EE-2");
    		
    		//设置关联关系
    		order1.setCustomer(customer);
    		order2.setCustomer(customer);
    		
    		//执行保存操作
    		entityManager.persist(customer);
    		entityManager.persist(order1);
    		entityManager.persist(order2);
    		
    	}

![70][]

输出的SQL语句 ： 是3 条insert 语句

![70 1][]

### 如果把执行保存操作中调换顺序 ###

@Test
    	public void testManyToOnePersist(){
    		Customer customer = new Customer();
    		customer.setAge(15);
    		customer.setBirth(new Date());
    		customer.setCreatTime(new Date());
    		customer.setEmail("gg@flx.com");
    		customer.setLastName("GG");
    		
    		Order order1 = new Order();
    		order1.setOrderName("g-GG-1");
    		
    		Order order2 = new Order();
    		order2.setOrderName("g-GG-2");
    		
    		//设置关联关系
    		order1.setCustomer(customer);
    		order2.setCustomer(customer);
    
            //执行保存操作
    		
            entityManager.persist(order1);
            entityManager.persist(order2);
    		
            entityManager.persist(customer);

那么执行结果： 【可以保存成功，SQL的变化】 三条insert 和两条update

![70 2][]

![70 3][]

![70 4][]

![70 5][]

这个时候外键是null 的 【下图 中 CUSTOMER\_ID外键列的值 实际上为null 】

![70 6][]

只有在保存外这个customer 之后，才知道外键列时谁，这个时候customer 才会有id； 【如下图】

![70 7][]

然后jpa去维护关联关系，又额外有两个update。**所以总结：**

![70 8][]

### 获取数据： ###

**①、默认情况下，使用左外连接的方式来获取 n 的一端的对象和其关联的 1 的一端的对象**

@Test
    	public void testManyToOneFind(){
    		Order order = entityManager.find(Order.class, 1);
    		System.out.println(order.getOrderName());
    		
    		System.out.println(order.getCustomer().getLastName());
    	}

执行的结果： 【一条select 语句】

![70 9][]

**②、可使用 @ManyToOne 中的 fetch 属性来修改默认的关联属性的加载策略   【懒加载】**

![70 10][]

还是同样的测试 ，运行结果：  先生成Order 的信息 , 再打印Customer --查询customer 的语句 【两条SQL语句】

![70 11][]

![70 12][]

### 删除数据： ###

**①、删除**

@Test
    	public void testManyToOneRemove(){
    		Order order = entityManager.find(Order.class, 1);
    		entityManager.remove(order);
    	}

运行结果： 一个select 一个 delete

![70 13][]

![70 14][]

**②、不能直接删除1 的一端，因为有外键关联**

@Test
    	public void testManyToOneRemove(){
    	
    		Customer customer = entityManager.find(Customer.class, 7);
    		entityManager.remove(customer);
    		
    	}

![70 15][]

### 修改数据： ###

@Test
    	public void testManyToOneUpdate(){
    		Order order = entityManager.find(Order.class, 2);
    		order.getCustomer().setLastName("FFF");
    		
    	}

![70 16][]

## 二、JPA\_映射单向一对多的关联关系 ##

### 生成数据表： ###

@Test
    	public void testOneToMany(){
    		
    	}

### 保存数据： ###

**单向 1-n 关联关系执行保存时，一定会多出UPDATE语句，因为n 的一端在插入时不会同时插入外键列**

@Test
    	public void testOneToManyPersist(){
    		Customer customer = new Customer();
    		customer.setAge(18);
    		customer.setBirth(new Date());
    		customer.setCreatTime(new Date());
    		customer.setEmail("zz@flx.com");
    		customer.setLastName("ZZ");
    		
    		Order order1 = new Order();
    		order1.setOrderName("O-ZZ-1");
    		
    		Order order2 = new Order();
    		order2.setOrderName("O-ZZ-2");
    		
    		//建立关联关系
    		customer.getOrders().add(order1);
    		customer.getOrders().add(order2);
    		
    		//执行保存操作
    		
    		entityManager.persist(customer);
    		entityManager.persist(order1);
    		entityManager.persist(order2);	
    	}

结果是在控制台输出3条 insert 语句 和两条 update语句

![70 17][] ![70 18][]

![70 19][]

### 查询数据： ###

**①、默认对关联的多的一方使用懒加载的加载策略**

@Test
    	public void testOneToManyFind(){
    		Customer customer = entityManager.find(Customer.class, 9);
    		System.out.println(customer.getLastName());
    		System.out.println(customer.getOrders().size());
    	}

![70 20][]

**②、可以使用 @OneToMany 的fetch 属性来修改默认的加载策略**

![70 21][]

测试：

**运行结果变成了主外连接**

![70 22][]

### 删除数据： ###

**①、默认情况下，若删除 1 的一端，则想把关联 n 的一端的外键置空，然后进行删除**

@Test
    	public void testOneToManyRemove(){
    		Customer customer = entityManager.find(Customer.class, 9);
    		entityManager.remove(customer);
    	}

运行结果  ： 查询，然后把外键制空 ， 最后删除

![70 23][]  ![70 24][] ![70 25][]

![70 26][]   ![70 27][]

**②、可以通过修改 @OneToMany 的 cascade 属性来修改默认的删除策略**

![70 28][]

//默认情况下，若删除 1 的一端，则想把关联 n 的一端的外键置空，然后进行删除
    	//可以通过修改 @OneToMany 的 cascade 属性来修改默认的删除策略
    	@Test
    	public void testOneToManyRemove(){
    		Customer customer = entityManager.find(Customer.class, 8);
    		entityManager.remove(customer);
    	}

### ![70 29][] ![70 30][] ###

###  更新数据： ###

@Test
    	public void testOneToManyUpdate(){
    		Customer customer = entityManager.find(Customer.class, 11);	
    		customer.getOrders().iterator().next().setOrderName("O-xxx-11");
    	}

![70 31][]  ![70 32][]

## 三、JPA\_映射双向一对多的关联关系  和双向多对一是一样的 ##

### 1、实体类：   Order  的实体类 加上  private Customer customer;，Customer 的实体类不变 ###

@Table(name="JPA_ORDERS")  //订单
    @Entity
    public class Order {
    	private Integer id;
    	private String orderName;
    	private Customer customer;
    
    	@Id
    	@GeneratedValue
    	public Integer getId() {
    		return id;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    
    	@Column(name="ORDER_NAME")
    	public String getOrderName() {
    		return orderName;
    	}
    	public void setOrderName(String orderName) {
    		this.orderName = orderName;
    	}
    
    	@JoinColumn(name="CUSTOMER_ID")
    	@ManyToOne(fetch=FetchType.LAZY)
    	public Customer getCustomer() {
    		return customer;
    	}
    	public void setCustomer(Customer customer) {
    		this.customer = customer;
    	}
    }

###  保存数据： ###

**①、结论：若是双向1 - n 的关联关系，执行保存时：**

**若是先保存 n 的一端 ， 再保存 1 的一端，默认情况下会多出 4 (n) 条 UPDATE 语句。**

**若是先保存 1 的一端，再保存 n 的一端，默认情况下会多出 2(n)  条 UPDATE 语句**

@Test
    	public void testOneToManyDouble(){
    		Customer customer = new Customer();
    		customer.setAge(18);
    		customer.setBirth(new Date());
    		customer.setCreatTime(new Date());
    		customer.setEmail("yy@flx.com");
    		customer.setLastName("yy");
    		
    		Order order1 = new Order();
    		order1.setOrderName("O-YY-1");
    		
    		Order order2 = new Order();
    		order2.setOrderName("O-YY-2");
    		
    		//建立关联关系
    		customer.getOrders().add(order1);
    		customer.getOrders().add(order2);
    		
    		order1.setCustomer(customer);
    		order2.setCustomer(customer);
    		
    		//执行保存操作
    		entityManager.persist(order1);
    		entityManager.persist(order2);	
    
            entityManager.persist(customer);
    	}

会有四条update 语句输出

![70 33][]

**②、控制台多出2条 UPDATE 语句 **

**在进行双向 1-n 关联关系时，建议使用 n 的一方来维护关联关系，而1 的一方不维护关联关系，这样会有效的减少SQL语句。**

@Test
    	public void testOneToManyDouble2(){
    		Customer customer = new Customer();
    		customer.setAge(18);
    		customer.setBirth(new Date());
    		customer.setCreatTime(new Date());
    		customer.setEmail("ss@flx.com");
    		customer.setLastName("ss");
    		
    		Order order1 = new Order();
    		order1.setOrderName("O-SS-1");
    		
    		Order order2 = new Order();
    		order2.setOrderName("O-SS-2");
    		
    		//建立关联关系
    		customer.getOrders().add(order1);
    		customer.getOrders().add(order2);
    		
    		order1.setCustomer(customer);
    		order2.setCustomer(customer);
    		
    		//执行保存操作  =====》 更改顺序
    		entityManager.persist(order1);
    		entityManager.persist(order2);	
    		
    		entityManager.persist(customer);
    	}

结果大家自己去实现之后的控制台看吧 ，数据已经成功的保存在数据库里了。

**③、注意：若在 1 的一端的 @OneToMany  中使用  mappedBy 属性，则 @OneToMany 端就不能再使用 @JoinColumn 属性了。**

![70 34][]

![70 35][]

## 四、JPA\_映射双向一对一的关联关系 ##

## 五、JPA\_映射双向多对多的关联关系 ##

[70]: /images/20220514/9b53595367864ffa9bf7c952c0a0a26f.png
[70 1]: /images/20220514/aa11db4686d94681a8c00171fc9abe76.png
[70 2]: /images/20220514/4757f321a40f46efab279a72c543507a.png
[70 3]: /images/20220514/347fc1fcc40249dea46fc9ff78d67ded.png
[70 4]: /images/20220514/a1024ee8919346939284414380d51595.png
[70 5]: /images/20220514/ac3700b65c9d4720aa6743c5bac0a50f.png
[70 6]: /images/20220514/3c330873f9d145a9bf86b7a77349ab60.png
[70 7]: /images/20220514/d59f4f4a23a440fdb0b6747fe59c6029.png
[70 8]: /images/20220514/32a0bf4614a4456ab6ed21e97dccab17.png
[70 9]: /images/20220514/df8cdb4771c646ceb21d514b8d70e450.png
[70 10]: /images/20220514/749b072677c046c1a2630c6e7b20a1eb.png
[70 11]: /images/20220514/11b5b2e0ee5340a5b9212e5f4073f863.png
[70 12]: /images/20220514/48fd52c7712841709d317708bcf4a814.png
[70 13]: /images/20220514/f50b613232c4428091bbe2bb1435178c.png
[70 14]: /images/20220514/5a220b34660c461f9b97c8c88ad77dac.png
[70 15]: /images/20220514/e4bcc286e3e041d4949b028f73150e47.png
[70 16]: /images/20220514/cef9bbae235744c09fdc05fc37de1874.png
[70 17]: https://img-blog.csdn.net/20180917151043241?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4Mjg5NDA1/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 18]: /images/20220514/281e209b22a54b5d9181d9ecbd25a861.png
[70 19]: /images/20220514/6f908cc5a6624ecf8a3f82025bce0531.png
[70 20]: /images/20220514/ca1d071a520f4a05a2dfbd2cebe24ae1.png
[70 21]: /images/20220514/6ecf9a2512be4b58a760e969d3c91ffc.png
[70 22]: /images/20220514/97145f60d1754a78accb1976a986ad99.png
[70 23]: https://img-blog.csdn.net/20180917154333977?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4Mjg5NDA1/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 24]: https://img-blog.csdn.net/2018091715435265?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4Mjg5NDA1/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 25]: /images/20220514/936236a68afe47c1870189a6af6c41b7.png
[70 26]: https://img-blog.csdn.net/20180917154437608?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4Mjg5NDA1/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 27]: /images/20220514/a9d09a553b564a9091a931ff9e5d857e.png
[70 28]: /images/20220514/83742fe9b4714bb6a234e35c61f3f390.png
[70 29]: https://img-blog.csdn.net/2018091715491310?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4Mjg5NDA1/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 30]: /images/20220514/4b2aebafb5b149cb9fdb35cc754938ef.png
[70 31]: https://img-blog.csdn.net/20180917155436950?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4Mjg5NDA1/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 32]: /images/20220514/16f7e042bc8a4df3a8187748f41bb176.png
[70 33]: /images/20220514/2171eb20421d4757bf2dced59b9d45ec.png
[70 34]: /images/20220514/c09683e32c904ead9df29bfd0733b1a6.png
[70 35]: /images/20220514/b7523c8169ef4a1f805a16d852a4c92f.png