JPA单向一对多关联关系@OneToMany

妖狐艹你老母 2022-05-20 07:59 188阅读 0赞

package com.jpa.helloworld;
    
    import java.util.Date;
    import java.util.HashSet;
    import java.util.Set;
    
    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.OneToMany;
    import javax.persistence.Table;
    import javax.persistence.TableGenerator;
    import javax.persistence.Temporal;
    import javax.persistence.TemporalType;
    import javax.persistence.Transient;
    
    import org.hibernate.annotations.Type;
    import org.joda.time.DateTime;
    import org.joda.time.LocalDate;
    
    @Table(name = "JPA_CUSTOMER")
    @Entity
    public class Customer {
    
    	private Integer id;
    
    	private String name;
    
    	private String email;
    
    	private int age;
    
    	private Date birth;
    
    	private Set<Order> orders = new HashSet<>();
    
    	private DateTime createDate;
    
    	private LocalDate lastUpdateDate;
    
    	private String tran;
    
    	@TableGenerator(name = "ID_GENDERATOR", pkColumnName = "PK_NAME", pkColumnValue = "CUSTOMER_ID", valueColumnName = "PK_VALUE", allocationSize = 5)
    	@GeneratedValue(strategy = GenerationType.TABLE, generator = "ID_GENDERATOR")
    	@Id
    	@Column(name = "C_ID")
    	public Integer getId() {
    		return id;
    	}
    
    	public void setId(Integer id) {
    		this.id = id;
    	}
    
    	@JoinColumn(name = "CUSTOMER_ID") @OneToMany(cascade={CascadeType.REMOVE})
    	public Set<Order> getOrders() {
    		return orders;
    	}
    
    	public void setOrders(Set<Order> orders) {
    		this.orders = orders;
    	}
    
    	@Column(name = "LAST_NAME", unique = true, length = 20, nullable = false)
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	@Column(name = "EMAIL", length = 50)
    	public String getEmail() {
    		return email;
    	}
    
    	public void setEmail(String email) {
    		this.email = email;
    	}
    
    	@Column(name = "AGE", length = 3)
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	@Transient
    	public String getTran() {
    		return tran;
    	}
    
    	public void setTran(String tran) {
    		this.tran = tran;
    	}
    
    	@Column(name = "BIRTH")
    	@Temporal(TemporalType.DATE)
    	public Date getBirth() {
    		return birth;
    	}
    
    	public void setBirth(Date birth) {
    		this.birth = birth;
    	}
    
    	@Column(name = "CREATEDATE")
    	@Type(type = "org.jadira.usertype.dateandtime.joda.PersistentDateTime")
    	public DateTime getCreateDate() {
    		return createDate;
    	}
    
    	public void setCreateDate(DateTime createDate) {
    		this.createDate = createDate;
    	}
    
    	@Column(name = "LASTUPDATEDATE")
    	@Type(type = "org.jadira.usertype.dateandtime.joda.PersistentLocalDate")
    	public LocalDate getLastUpdateDate() {
    		return lastUpdateDate;
    	}
    
    	public void setLastUpdateDate(LocalDate lastUpdateDate) {
    		this.lastUpdateDate = lastUpdateDate;
    	}
    }

`主要关注的是代码中有颜色的地方`

`接下来说一下关于单项一对多的插入和删除操作`

`插入`

`不管先插入多大一端还是一的一端，最终打印的sql语句数量是一样的，因为是由一的一端维护关联关系，所以在插入多的一端时它并不会保存外键值，只有在持久化之后再另外发送update语句更新多的一端的外键值`

@Test
    	public void testOnToMany() {
    		
    		Order o1 = new Order();
    		Order o2 = new Order();
    		o1.setoName("O-BB");
    		o2.setoName("O-CC");
    		
    		Customer customer = new Customer();
    		customer.setName("C-BB");
    		customer.setAge(23);
    		customer.setBirth(new Date());
    		customer.setEmail("aa@163.com");
    		customer.setCreateDate(DateTime.now());
    		customer.setLastUpdateDate(LocalDate.now());
    		customer.getOrders().add(o1);
    		customer.getOrders().add(o2);
    		
    		em.persist(customer);
    		em.persist(o1);
    		em.persist(o2);
    		
    	}

删除

多的一端可以随意删除，主要说一下一的一端

在单向多对一的时候一的一端是不可以删除的

而单项一对多的不同，可以删除一的一端，那么多的一端会被怎么操作呢？根据发出的sql语句可以看出，在默认情况下，删除一的一端，多的一端的外键会被置为null。那么接下来就说一下怎么设置对多的一端的操作。

在@OneToMany注解中有一个cascade属性，它的值是一个CascadeType类的数组

@JoinColumn(name = "CUSTOMER_ID")
    @OneToMany(cascade={CascadeType.REMOVE})
    public Set<Order> getOrders() {
    	return orders;
    }

`ALL`

级联所有实体状态转换

`PERSIST`   
级联实体持久化操作。

`MERGE`   
级联实体合并操作。

`REMOVE`   
级联实体删除操作。

`REFRESH`   
级联实体刷新操作。