xml程式碼

<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0"> <persistence-unit name="mengya" transaction-type="RESOURCE_LOCAL"> <properties> <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/> <property name="hibernate.hbm2ddl.auto" value="update"/> <property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/> <property name="hibernate.connection.username" value="root"/> <property name="hibernate.connection.password" value="123"/> <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/mp?useUnicode=true&characterEncoding=UTF-8"/> </properties> </persistence-unit> </persistence>

在JPA中雙向一對多關係則多方為關係護端即負責外來鍵記錄的更新，一方為被維護端即沒有權力更新外來鍵記錄

src下在面的META-INF/persistence.xml配置如下：

訂單和訂單項兩個例項實體Bean如下：

訂單表：

package com.mengya.bean; import java.util.HashSet; import java.util.Set; import javax.persistence.CascadeType; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.Id; import javax.persistence.OneToMany; import javax.persistence.Table; @Entity @Table(name = "orders") public class Order { private String orderId; private Float amount = 0f;// 設定預設值 private Set<OrderItem> items = new HashSet<OrderItem>(); @Id @Column(length = 32) public String getOrderId() { return orderId; } public void setOrderId(String orderId) { this.orderId = orderId; } @Column(nullable = false) public Float getAmount() { return amount; } public void setAmount(Float amount) { this.amount = amount; } // cascade表示級聯操作 // CascadeType.MERGE級聯更新：若items屬性修改了那麼order物件儲存時同時修改items裡的物件。對應EntityManager的merge方法 // CascadeType.PERSIST級聯重新整理：獲取order物件裡也同時也重新獲取最新的items時的物件。對應EntityManager的refresh(object)方法有效。即會重新查詢資料庫裡的最新資料 // CascadeType.REFRESH級聯儲存：對order物件儲存時也對items裡的物件也會儲存。對應EntityManager的presist方法 // CascadeType.REMOVE級聯刪除：對order物件刪除也對items裡的物件也會刪除。對應EntityManager的remove方法 // FetchType.LAZY表示懶載入。對於xxxtoMany時即獲得多的一方fetch的預設值是FetchType.LAZY懶載入。對於xxxtoOne時即獲得一的一方fetch的預設值是FetchType.EAGER立即載入 // mappedBy表示關係統被維護端，它的值是關係維護端維護關係的屬性 @OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH, CascadeType.REMOVE }, fetch = FetchType.LAZY, mappedBy = "order") public Set<OrderItem> getItems() { return items; } public void setItems(Set<OrderItem> items) { this.items = items; } /** * 自己的加的一個方法，為了方便新增OrderItem * */ public void addOrderItem(OrderItem item) { item.setOrder(this); this.items.add(item); } }

訂單項表：

package com.mengya.bean; import javax.persistence.CascadeType; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.ManyToOne; @Entity public class OrderItem { private Integer id; private String productName; private Float sellPrice = 0f;// 設定預設值 private Order order; @Id @GeneratedValue(strategy = GenerationType.AUTO) public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } @Column(length = 40, nullable = false) public String getProductName() { return productName; } public void setProductName(String productName) { this.productName = productName; } @Column(nullable = false) public Float getSellPrice() { return sellPrice; } public void setSellPrice(Float sellPrice) { this.sellPrice = sellPrice; } // cascade表示級聯。CascadeType.REFRESH級聯重新整理 // optional表示該物件可有可無，它的值為true表示該外來鍵可以為null，它的值為false表示該外來鍵為not null @ManyToOne(cascade = CascadeType.REFRESH, fetch = FetchType.EAGER, optional = false) // JoinColumn表示外來鍵的列 @JoinColumn(name="orderId") public Order getOrder() { return order; } public void setOrder(Order order) { this.order = order; } }

 測試：

package com.mengya.junit.test; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.Persistence; import org.junit.Test; import com.mengya.bean.Order; import com.mengya.bean.OrderItem; public class JPA_OnetoManyTest { @Test public void save(){ EntityManagerFactory factory=Persistence.createEntityManagerFactory("mengya"); EntityManager em=factory.createEntityManager(); em.getTransaction().begin(); Order order=new Order(); order.setOrderId("200910120001"); order.setAmount(450f); OrderItem item1=new OrderItem(); item1.setProductName("籃球"); item1.setSellPrice(220f); OrderItem item2=new OrderItem(); item2.setProductName("排球"); item2.setSellPrice(230f); order.addOrderItem(item1); order.addOrderItem(item2); em.persist(order); em.getTransaction().commit(); em.close(); factory.close(); } }

1、hibernate是雙向的,通過one可以找到many,通過many可以找到one,
   要想找到對方，必須將對方作為當前物件屬性，在one這邊
   應當有一個Set屬性裝載多many物件，在many這邊應當有一個
   屬性裝載一個One物件。
   public class customer
   {
    private Set buies;
    private String customerName;
    public void setBuies(Set buies)
    {
     this.buies=buies;
    }
    public Set getBuies()
    {
     return this.buies;
    }
   }
  
public class Buy
   {
    private Integer buyID;
    private Customer customer;
    public void setCustomer(Customer customer)
    {
     this.customer=customer;
    }
    public Customer getCustomer()
    {
     return this.customer;
    }
   }
2、主控方:維護外來鍵列的值。
   1、inverse="false"代表是主控方，另一方便是被控方，
     反之inverse="true"代表是被控方，另一方便是主控方。
     要想維護外來鍵的值，必須將被控方作為主控方的屬性。
     一般主控方要many這邊,不在one那邊。
3、延遲載入:
   1、lazy="true"代表是延遲載入，載入時只加載當前物件的，
     不載入其關聯物件的值，只有取關聯物件的值時才執行sql
     載入對方。
   2、lazy="false"代表即時載入，載入時不但載入當前物件的，
     還載入其關聯的所有物件資訊。
4、級聯處理:主增從增、主刪從刪、從改從改，要做到該功能，必須將
   從作為主的一個屬性或主集合屬性中的一個元素。
   1、cascade="all" 代表級聯insert、update、delete操作
   2、cascade="save-update" 代表級聯insert、update操作
主鍵的生成方式:
1、必須手動給定主鍵值
   assigned
2、使用者及hibernate都不管由資料庫生，如identity
   native
1、html:select標籤
2、過濾器
1、filter
2、RequestProcessor