JPA 單向一對多關聯關係

 

映射單向一對多的關聯關係

一、首先在一的一端加入多的一端的實體類集合

二、使用@OneToMany 來映射一對多的關聯關係
三、使用@JoinColumn 來映射外鍵列的名稱
四、可使用@OneToMany的fetch 屬性來修改默認的加載策略
五、能夠經過@OneToMany的cascade 屬性來修改默認的刪除策略
六、cascade={CascadeType.REMOVE} 會把主表和從表的數據都刪除

以下代碼：

/**
 *數據庫持久化類
 * @author z
 *
 */
@Table(name="JPA_CUSTOMERS")//主要是映射表名對應的數據庫表名JPA_CUSTOMER默認狀況下能夠不寫表名與持久化類名相同
@Entity //代表這是一個持久化類
public class Customer {
    
    private Integer id;
    private String lastName;
    private String email;
    private int  age ;
    
    private Date createdTime;
    private Date birth;
    
    /**
     * 單向一對多關係映射
     * 一、添加多的一方的集合屬性
     */
      private Set<Order> orders=new HashSet<>();
    
    /**
     * 定義各數據列必須加在get方法上
     * @return
     */
    //定義主鍵，生成主鍵的策略AUTO自動的根據數據的類型生成主鍵
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Id //定義數據列
//    @Column(name="ID")//定義數據庫的列名若是與字段名同樣能夠省略
    
    //使用table生成主鍵
//    @TableGenerator(name="ID_GENERATOR",
//            table="JPA_ID_GENERATORS",
//            pkColumnName="PK_NAME",
//            pkColumnValue="CUSTOMER_ID",
//            valueColumnName="PK_VALUE",
//            allocationSize=100
//            
//            
//            )
//    
//    @GeneratedValue(strategy=GenerationType.TABLE,generator="ID_GENERATOR")
//    @Id
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    
    @Column(name="LAST_NAME",length=50,nullable=false) //nullable false表示此字段不能爲空
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    @Temporal(TemporalType.TIMESTAMP)
    public Date getCreatedTime() {
        return createdTime;
    }
    public void setCreatedTime(Date createdTime) {
        this.createdTime = createdTime;
    }
    @Temporal(TemporalType.DATE)
    public Date getBirth() {
        return birth;
    }
    public void setBirth(Date birth) {
        this.birth = birth;
    }
    
    //映射單向一對多的關聯關係
    //使用@OneToMany 來映射一對多的關聯關係
    //使用@JoinColumn 來映射外鍵列的名稱
    //可使用@OneToMany的fetch 屬性來修改默認的加載策略
    //能夠經過@OneToMany的cascade 屬性來修改默認的刪除策略
    //cascade={CascadeType.REMOVE} 會把主表和從表的數據都刪除
    @JoinColumn(name="CUSTOMER_ID")
    @OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE})
   public Set<Order> getOrders() { 
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    
    //工具方法，不須要映射爲數據表的一列
    @Transient
    public String getInfo(){
        return "lastName:"+lastName+",email:"+email;
    }
    @Override
    public String toString() {
        return "Customer [id=" + id + ", lastName=" + lastName + ", email=" + email + ", age=" + age + ", createdTime="
                + createdTime + ", birth=" + birth + "]";
    }
    
}

二、單向多對一增刪查改測試範例及注意事項

public class JPATest {
    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;
    @Before
    public void init(){
        entityManagerFactory= Persistence.createEntityManagerFactory("jpa-1");
        entityManager=entityManagerFactory.createEntityManager();
        transaction=entityManager.getTransaction();
        transaction.begin();//開啓事務
        
    }
    @After
    public void destroy(){
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }
    
    //修改
    @Test
    public void testUpdate(){
        Customer customer=entityManager.find(Customer.class, 4);
        customer.getOrders().iterator().next().setOrderName("O-XXX-10");
        
    }
    
     //刪除
    //默認狀況下，若刪除1的一端，則會先把關聯的多的一段的外鍵置空,而後刪除一的一端
    ////能夠經過@OneToMany的cascade 屬性來修改默認的刪除策略
    @Test
    public void testOneToManyRemove(){
        Customer customer=entityManager.find(Customer.class, 7);
        entityManager.remove(customer);
        
    }
    
    //默認對關聯多的一方使用懶加載的加載策略(延遲加載)
    //可使用@OneToMany的fetch 屬性來修改默認的加載策略
    //查詢
    @Test
    public void testOneToManyFind(){
        Customer customer=entityManager.find(Customer.class,6);
        System.out.println(customer.getLastName());
        
        System.out.println(customer.getOrders().size());
        
    }
    
    //單向一對多保存時，必定會多出update語句
    //由於多的一端在插入時不會同時插入外鍵列
    //保存
    @Test
    public void testOneToManyPersist(){
        Customer customer=new Customer();
        customer.setAge(16);
        customer.setBirth(new Date());
        customer.setCreatedTime(new Date());
        customer.setEmail("CC@163.com");
        customer.setLastName("AA");
        
        Order order1=new Order();
        order1.setOrderName("o-CC-1");
        
        Order order2=new Order();
        order2.setOrderName("o-CC-2");
        
        //創建關聯關係
        customer.getOrders().add(order1);
        customer.getOrders().add(order2);
        //執行保存操做
        entityManager.persist(customer);
        entityManager.persist(order1);
        entityManager.persist(order2);    
     }   
    }

源碼地址：https://github.com/wuhongpu/JPA.git