@OneToMany或@ManyToOne的用法-annotation关系映射篇(上)

例如我们用一个例子来开启JPA的一对多和多对一的学习。

  比如你去当当网上买书籍,当当网就给你一个订单。
  通过上面的业务活动描述你可以分析得出:一个订单可以包含一个或多个订单项.那么我们将将订单和订单项设计关系为(1:N)一对多的关系(排除0)。得出关系我们就使用JPA来实现这个关系(关于建立JPA和基本的配置我就不再说了,如果不明白请看JPA入门篇)。

首先建立订单实体类
Java代码 复制代码
  1. import java.util.HashSet;   
  2. import java.util.Set;   
  3.   
  4. import javax.persistence.CascadeType;   
  5. import javax.persistence.Column;   
  6. import javax.persistence.Entity;   
  7. import javax.persistence.Id;   
  8. import javax.persistence.OneToMany;   
  9. import javax.persistence.Table;   
  10.   
  11. @Entity  
  12. @Table(name="orders")   
  13. public class Order {   
  14.        
  15.     private String orderid;   
  16.     private Float amount = 0f;   
  17.     private Set<OrderItem> items = new HashSet<OrderItem>();   
  18.   
  19.     @Id  
  20.     @Column(length = 12)   
  21.     public String getOrderid() {   
  22.         return orderid;   
  23.     }   
  24.   
  25.     public void setOrderid(String orderid) {   
  26.         this.orderid = orderid;   
  27.     }   
  28.   
  29.     @Column(nullable = false)   
  30.     public Float getAmount() {   
  31.         return amount;   
  32.     }   
  33.   
  34.     public void setAmount(Float amount) {   
  35.         this.amount = amount;   
  36.     }   
  37.   
  38.     @OneToMany(cascade = { CascadeType.REFRESH, CascadeType.PERSIST,CascadeType.MERGE, CascadeType.REMOVE },mappedBy ="order"//这里配置关系,并且确定关系维护端和被维护端。mappBy表示关系被维护端,只有关系端有权去更新外键。这里还有注意OneToMany默认的加载方式是赖加载。当看到设置关系中最后一个单词是Many,那么该加载默认为懒加载   
  39.     public Set<OrderItem> getItems() {   
  40.         return items;   
  41.     }   
  42.   
  43.     public void setItems(Set<OrderItem> items) {   
  44.         this.items = items;   
  45.     }   
  46.        
  47.          /**   
  48.            *该方法用于向order中加order项   
  49.           /*   
  50.     public void addOrderItem(OrderItem orderItem){   
  51.         orderItem.setOrder(this);//用关系维护端来维护关系   
  52.         this.items.add(orderItem);   
  53.     }   
  54.   
  55. }  

订单项的实体类
Java代码 复制代码
  1. import javax.persistence.CascadeType;   
  2. import javax.persistence.Column;   
  3. import javax.persistence.Entity;   
  4. import javax.persistence.GeneratedValue;   
  5. import javax.persistence.Id;   
  6. import javax.persistence.JoinColumn;   
  7. import javax.persistence.ManyToOne;   
  8.   
  9. @Entity  
  10. public class OrderItem {   
  11.     private Integer id;   
  12.     private String productName;   
  13.     private Float sellPrice = 0f;   
  14.     private Order order;   
  15.   
  16.     @Id  
  17.     @GeneratedValue  
  18.     public Integer getId() {   
  19.         return id;   
  20.     }   
  21.   
  22.     public void setId(Integer id) {   
  23.         this.id = id;   
  24.     }   
  25.   
  26.     @Column(length = 40, nullable = false)   
  27.     public String getProductName() {   
  28.         return productName;   
  29.     }   
  30.   
  31.     public void setProductName(String productName) {   
  32.         this.productName = productName;   
  33.     }   
  34.   
  35.     @Column(nullable = false)   
  36.     public Float getSellPrice() {   
  37.         return sellPrice;   
  38.     }   
  39.   
  40.     public void setSellPrice(Float sellPrice) {   
  41.         this.sellPrice = sellPrice;   
  42.     }   
  43.   
  44.     @ManyToOne(cascade = {CascadeType.MERGE,CascadeType.REFRESH }, optional = true)   
  45.     @JoinColumn(name="order_id")//这里设置JoinColum设置了外键的名字,并且orderItem是关系维护端  
  46.     public Order getOrder() {   
  47.         return order;   
  48.     }   
  49.   
  50.     public void setOrder(Order order) {   
  51.         this.order = order;   
  52.     }   
  53.   
  54. }  

下面看看测试类
Java代码 复制代码
  1. import javax.persistence.EntityManager;   
  2. import javax.persistence.EntityManagerFactory;   
  3. import javax.persistence.Persistence;   
  4.   
  5. import org.junit.BeforeClass;   
  6. import org.junit.Test;   
  7.   
  8. import cn.itcast.bean.Order;   
  9. import cn.itcast.bean.OrderItem;   
  10.   
  11. public class OneToManyTest {   
  12.   
  13.     @BeforeClass  
  14.     public static void setUpBeforeClass() throws Exception {   
  15.     }   
  16.     @Test public void addOrder(){   
  17.          EntityManagerFactory factory = Persistence.createEntityManagerFactory("test");   
  18.          EntityManager em = factory.createEntityManager();   
  19.          em.getTransaction().begin(); // start transaction   
  20.             
  21.                    Order order = new Order();    
  22.          order.setAmount(34f);    
  23.          order.setOrderid("00001");   
  24.                       
  25.                    //order中包含的OrderItem项OrderItem1,OrderItem2   
  26.          OrderItem orderItem1 = new OrderItem();   
  27.          orderItem1.setProductName("书");   
  28.          orderItem1.setSellPrice(22f);   
  29.          order.addOrderItem(orderItem1); //add orderitem in order   
  30.             
  31.          OrderItem orderItem2 = new OrderItem();   
  32.          orderItem2.setProductName("篮球");   
  33.          orderItem2.setSellPrice(100f);   
  34.          order.addOrderItem(orderItem2);   
  35.             
  36.          em.persist(order); //persist order object   
  37.          em.getTransaction().commit(); //commit transaction   
  38.          em.close();   
  39.          factory.close();   
  40.     }   
展开阅读全文

没有更多推荐了,返回首页