欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

JPA 一对多实例配置

程序员文章站 2022-03-03 09:41:11
...

http://zmx.iteye.com/blog/487063

 

Xml代码  JPA 一对多实例配置
            
    
    博客分类: Java jpa 
  1. <persistence xmlns="http://java.sun.com/xml/ns/persistence"  
  2.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"  
  4.    version="1.0">  
  5.    <persistence-unit name="mengya" transaction-type="RESOURCE_LOCAL">  
  6.       <properties>  
  7.          <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>  
  8.          <property name="hibernate.hbm2ddl.auto" value="update"/>  
  9.          <property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/>  
  10.          <property name="hibernate.connection.username" value="root"/>  
  11.          <property name="hibernate.connection.password" value="123"/>  
  12.          <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/mp?useUnicode=true&amp;characterEncoding=UTF-8"/>  
  13.       </properties>  
  14.    </persistence-unit>  
  15. </persistence>  

 在JPA中双向一对多关系则多方为关系护端即负责外键记录的更新,一方为被维护端即没有权力更新外键记录

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

 

 

订单和订单项两个实例实体Bean如下:

订单表:

Java代码  JPA 一对多实例配置
            
    
    博客分类: Java jpa 
  1. package com.mengya.bean;  
  2.   
  3. import java.util.HashSet;  
  4. import java.util.Set;  
  5.   
  6. import javax.persistence.CascadeType;  
  7. import javax.persistence.Column;  
  8. import javax.persistence.Entity;  
  9. import javax.persistence.FetchType;  
  10. import javax.persistence.Id;  
  11. import javax.persistence.OneToMany;  
  12. import javax.persistence.Table;  
  13.   
  14. @Entity  
  15. @Table(name = "orders")  
  16. public class Order {  
  17.     private String orderId;  
  18.   
  19.     private Float amount = 0f;// 设置默认值  
  20.   
  21.     private Set<OrderItem> items = new HashSet<OrderItem>();  
  22.   
  23.     @Id  
  24.     @Column(length = 32)  
  25.     public String getOrderId() {  
  26.         return orderId;  
  27.     }  
  28.   
  29.     public void setOrderId(String orderId) {  
  30.         this.orderId = orderId;  
  31.     }  
  32.   
  33.     @Column(nullable = false)  
  34.     public Float getAmount() {  
  35.         return amount;  
  36.     }  
  37.   
  38.     public void setAmount(Float amount) {  
  39.         this.amount = amount;  
  40.     }  
  41.   
  42.     // cascade表示级联操作  
  43.     // CascadeType.MERGE级联更新:若items属性修改了那么order对象保存时同时修改items里的对象。对应EntityManager的merge方法  
  44.     // CascadeType.PERSIST级联刷新:获取order对象里也同时也重新获取最新的items时的对象。对应EntityManager的refresh(object)方法有效。即会重新查询数据库里的最新数据  
  45.     // CascadeType.REFRESH级联保存:对order对象保存时也对items里的对象也会保存。对应EntityManager的presist方法  
  46.     // CascadeType.REMOVE级联删除:对order对象删除也对items里的对象也会删除。对应EntityManager的remove方法  
  47.     // FetchType.LAZY表示懒加载。对于xxxtoMany时即获得多的一方fetch的默认值是FetchType.LAZY懒加载。对于xxxtoOne时即获得一的一方fetch的默认值是FetchType.EAGER立即加载  
  48.     // mappedBy表示关系统被维护端,它的值是关系维护端维护关系的属性  
  49.     @OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH,  
  50.             CascadeType.REMOVE }, fetch = FetchType.LAZY, mappedBy = "order")  
  51.     public Set<OrderItem> getItems() {  
  52.         return items;  
  53.     }  
  54.   
  55.     public void setItems(Set<OrderItem> items) {  
  56.         this.items = items;  
  57.     }  
  58.   
  59.     /** 
  60.      * 自己的加的一个方法,为了方便添加OrderItem 
  61.      *  
  62.      */  
  63.     public void addOrderItem(OrderItem item) {  
  64.         item.setOrder(this);  
  65.         this.items.add(item);  
  66.     }  
  67.   
  68. }  

 订单项表:

Java代码  JPA 一对多实例配置
            
    
    博客分类: Java jpa 
  1. package com.mengya.bean;  
  2.   
  3. import javax.persistence.CascadeType;  
  4. import javax.persistence.Column;  
  5. import javax.persistence.Entity;  
  6. import javax.persistence.FetchType;  
  7. import javax.persistence.GeneratedValue;  
  8. import javax.persistence.GenerationType;  
  9. import javax.persistence.Id;  
  10. import javax.persistence.JoinColumn;  
  11. import javax.persistence.ManyToOne;  
  12.   
  13. @Entity  
  14. public class OrderItem {  
  15.     private Integer id;  
  16.   
  17.     private String productName;  
  18.   
  19.     private Float sellPrice = 0f;// 设置默认值  
  20.   
  21.     private Order order;  
  22.   
  23.     @Id  
  24.     @GeneratedValue(strategy = GenerationType.AUTO)  
  25.     public Integer getId() {  
  26.         return id;  
  27.     }  
  28.   
  29.     public void setId(Integer id) {  
  30.         this.id = id;  
  31.     }  
  32.   
  33.     @Column(length = 40, nullable = false)  
  34.     public String getProductName() {  
  35.         return productName;  
  36.     }  
  37.   
  38.     public void setProductName(String productName) {  
  39.         this.productName = productName;  
  40.     }  
  41.   
  42.     @Column(nullable = false)  
  43.     public Float getSellPrice() {  
  44.         return sellPrice;  
  45.     }  
  46.   
  47.     public void setSellPrice(Float sellPrice) {  
  48.         this.sellPrice = sellPrice;  
  49.     }  
  50.   
  51.     // cascade表示级联。CascadeType.REFRESH级联刷新  
  52.     // optional表示该对象可有可无,它的值为true表示该外键可以为null,它的值为false表示该外键为not null  
  53.     @ManyToOne(cascade = CascadeType.REFRESH, fetch = FetchType.EAGER, optional = false)  
  54.     // JoinColumn表示外键的列  
  55.     @JoinColumn(name="orderId")  
  56.     public Order getOrder() {  
  57.         return order;  
  58.     }  
  59.   
  60.     public void setOrder(Order order) {  
  61.         this.order = order;  
  62.     }  
  63.   
  64. }  

 

测试:

Java代码  JPA 一对多实例配置
            
    
    博客分类: Java jpa 
  1. package com.mengya.junit.test;  
  2.   
  3. import javax.persistence.EntityManager;  
  4. import javax.persistence.EntityManagerFactory;  
  5. import javax.persistence.Persistence;  
  6.   
  7. import org.junit.Test;  
  8.   
  9. import com.mengya.bean.Order;  
  10. import com.mengya.bean.OrderItem;  
  11.   
  12.   
  13. public class JPA_OnetoManyTest {  
  14.     @Test public void save(){  
  15.         EntityManagerFactory factory=Persistence.createEntityManagerFactory("mengya");  
  16.         EntityManager em=factory.createEntityManager();  
  17.         em.getTransaction().begin();  
  18.           
  19.         Order order=new Order();  
  20.         order.setOrderId("200910120001");  
  21.         order.setAmount(450f);  
  22.           
  23.         OrderItem item1=new OrderItem();  
  24.         item1.setProductName("篮球");  
  25.         item1.setSellPrice(220f);  
  26.         OrderItem item2=new OrderItem();  
  27.         item2.setProductName("排球");  
  28.         item2.setSellPrice(230f);  
  29.         order.addOrderItem(item1);  
  30.         order.addOrderItem(item2);  
  31.           
  32.         em.persist(order);  
  33.         em.getTransaction().commit();  
  34.         em.close();  
  35.         factory.close();  
  36.     }  
  37. }  
相关标签: jpa