JPA 一對多延遲加載與關係維護

package cn.itcast.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.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name="orders")   //把表名改爲orders（默認表名是order），防止默認表名order與數據庫的關鍵字"order by"中的order衝突。不改的話測試不成功，出現異常，orderitem表創建成功，order表建不了。
public class Order {
    private String orderId;
    private Float amount = 0f;
    private Set<OrderItem> items = new HashSet<OrderItem>();

    @Id //要注意：目前JPA規範並無提供UUID這種生成策略，目前主鍵值只提供了整型的生成方式，因此@GeneratedValue這個註解就不能在這裏用上,不能對字符串進行id自增加。
    @Column(length = 12)
    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;
    }

    @OneToMany(cascade = { CascadeType.REFRESH, CascadeType.PERSIST,
            CascadeType.MERGE, CascadeType.REMOVE },fetch=FetchType.LAZY,mappedBy="order")
    //mappedBy="order"，中的order是關係維護端的order屬性，這個order屬性的類型是這個bean。
    public Set<OrderItem> getItems() {
        return items;
    }
    /*
    @OneToMany(fetch=FetchType.)的選項有，以下圖：
        FetchType.EAGER:表明當即加載；
        FetchType.LAZY:表明延遲加載。

    當咱們把fetch設置爲FetchType.LAZY的時候，何時初始化items裏面的數據呢？當咱們第一次訪問這個屬性，並對這個屬性進行操做的時候，這個集合的數據纔會從數據庫裏面load出來。但要注意：當咱們訪問這個延遲屬性的時候，咱們的前提要EntityManager這個對象沒有被關閉，若是被關閉了咱們再去訪問延遲屬性的話，就訪問不到，並拋出延遲加載意外。
    若是沒有設置fetch這屬性的話，會怎麼樣呢？是當即加載？仍是延遲加載呢？
    記住@OneToMany這個標籤最後的英文單詞,若是是要獲得Many的一方，我無論你前面是什麼，只要後面的單詞是Many，也就是說要獲得多的一方，大家就給我記住，默認的加載策略就是延遲加載(Many記錄可能上幾萬條，當即加載的話可能對效率影響大，因此延遲加載)。
    反過來，若是後面是One呢？由於它是加載一的一方，這對性能影響不是很大，因此它的默認加載策略是當即加載。

    mappedBy：咱們怎麼知道關係的維護端和被維護端呢？固然JPA規範規定多的一端應該是爲維護端（關係維護段增長一個字段爲外鍵，裏面保存的是一的一端的主鍵），一的一端爲關係被維護端，那麼咱們總要在程序裏給他們打上標誌吧？雖然規範是這麼規定，但總要申明一下吧？就是經過mappedBy屬性，只要哪一個類出現了mappedBy，那麼這個類就是關係的被維護端。裏面的值指定的是關係維護端。
    orderItem這邊由哪個屬性去維護關係呢？是OrderItem類的order屬性。
    mappedBy屬性對應Hibernate裏面的inverse屬性：<SET name="items" inverse="true"></SET>

    */

    public void setItems(Set<OrderItem> items) {
        this.items = items;
    }

    //用這個方法會方便不少
    public void addOrderItem(OrderItem orderItem){
        orderItem.setOrder(this);   //關係維護方orderItem加入關係被維護方（this）後，才能維護更新關係（orderItem表中的外鍵字段order_id），維護關係其實就是更新外鍵。只有爲關係維護端設置了關係被維護端，關係才能創建起來。
        this.items.add(orderItem);
    }
}

 

OrderItem.java

package cn.itcast.bean;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
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;   //默認值爲0。
    private Order order;

    @Id
    @GeneratedValue  //id自增加方式生成主鍵。
    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;
    }

    @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)
    @JoinColumn(name="order_id")   //設置外鍵的名稱。
    public Order getOrder() {   //OrderItem是關係維護端，負責關係更新，它是根據它的order屬性值維護關係的。當它保存的時候（主動保存或是被級聯保存），他會根據order屬性的值更新關係，當order爲null時，就不會更新關係了。級聯操做也是根據雙方對象中的映射屬性值進行的，當映射屬性沒值的時候就不會對對方進行級聯操做了。
        return order;
    }
    /*
    @ManyToOne的級聯保存（CascadeType.PERSIST）是不須要的，不可能說你保存某個訂單項OrderItem的時候，也保存訂單Order的。一般都是保存訂單Order的時候，保存訂單項OrderItem的。
    CascadeType.MERGE：若是咱們更新了訂單項orderItem產品的價錢，那麼整個訂單Order的總金額是會發生改變的,因此能夠定義這個級聯更新。
    CascadeType.REFRESH：若是咱們想獲得目前數據庫裏orderItem最新的數據的話，咱們也但願獲得訂單order的最新數據,咱們能夠定義這個級聯刷新，就是說把數據庫裏最新的數據從新獲得。
    CascadeType.REMOVE：這個屬性這裏確定不設。就比如如今有一個訂單，一個訂單裏面有3個購物項orderItem,買了A,B,C三個產品，我如今不要A這個產品了，咱們只是把A這條記錄刪掉，那麼若是這裏定義了級聯刪除的話，那麼你刪除A記錄的同時，也會把整個訂單也刪除掉，因此這裏不須要設級聯刪除。
    */
    //optional：說明order這個是不是可選的？是否能夠沒有的？false表示必須的，true表示是可選的。

    public void setOrder(Order order) {
        this.order = order;
    }
}

 

OneToManyTest.java

package junit.test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import org.junit.BeforeClass;
import org.junit.Test;

import cn.itcast.bean.Order;
import cn.itcast.bean.OrderItem;

public class OneToManyTest {

    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
    }

    @Test
    public void save() {
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("itcast");
        EntityManager em = factory.createEntityManager();
        em.getTransaction().begin();

        Order order = new Order();
        order.setAmount(34f);
        order.setOrderId("992");  //orderId是數據庫裏面的主鍵，同時也是實體的標識。這裏並無使用Id自增加的方式來生成主鍵值，而是本身設值，因此能夠隨便寫。若是想用UUID，能夠這樣寫UUID.randomUUID().toString();這個類JDK5提供了。
        OrderItem orderItem1 = new OrderItem();
        orderItem1.setProductName("排球");
        orderItem1.setSellPrice(90f);
        OrderItem orderItem2=new OrderItem();
        orderItem2.setProductName("籃球");
        orderItem2.setSellPrice(30f);
        order.addOrderItem(orderItem1);
        order.addOrderItem(orderItem2);

        em.persist(order);
        em.getTransaction().commit();
        em.close();
        factory.close();
    }

}

 

 

運行junit測試，發現保存訂單Order的時候，也保存了訂單項OrderItem.爲何呢？是由於訂單Order和訂單項OrderItem定義 了級聯保存（CascadeType.PERSIST）關係，這個級聯關係在咱們調用em.persist(order);的persist方法時就會起 做用。