JPA双向一对多多一对一

Posted 1斑点

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JPA双向一对多多一对一相关的知识,希望对你有一定的参考价值。

 ?
双向一对多关系中,必须存在一个关系维护端,在 JPA 规范中,要求  many 的一方作为关系的维护端(owner side), one 的一方作为被维护端(inverse side)。
?可以在 one 方指定 @OneToMany 注释并设置 mappedBy 属性,以指定它是这一关联中的被维护端,many 为维护端
?在 many 方指定 @ManyToOne 注释,并使用 @JoinColumn 指定外键名称
技术分享图片
技术分享图片
    1. package com.morris.entity;  
    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.Id;  
    9. import javax.persistence.JoinColumn;  
    10. import javax.persistence.ManyToOne;  
    11. import javax.persistence.Table;  
    12.    
    13. @Entity  
    14. @Table(name="order_item")  
    15. public class OrderItem {  
    16.       
    17.      @Id  
    18.      @GeneratedValue  
    19.      @Column(name="order_item_id")  
    20.      private Integer orderItemId;  
    21.       
    22.      @Column(name="product_name",length=50,nullable=false)  
    23.      private String productName;  
    24.       
    25.      @Column(name="product_price",nullable=false)  
    26.      private Double productPrice;  
    27.       
    28.      /** 
    29.       * ManyToOne:多对一的配置 
    30.       * cascade(级联):all(所有),merge(更新),refresh(查询),persistence(保存),remove(删除) 
    31.       * fetch: eager:立即加载  one的一方默认是立即加载 
    32.       *            lazy:懒加载    many的一方默认是懒加载 
    33.       * optional:是否可选,外键是否允许为空 
    34.       * 
    35.       * JoinColumn:指定外键名 
    36.       * 
    37.       */  
    38.      @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},fetch=FetchType.EAGER,optional=false)  
    39.      @JoinColumn(name="order_id")  
    40.      private Order order;  
    41.    
    42.       
    43.      public OrderItem() {  
    44.          super();  
    45.          // TODO Auto-generated constructor stub  
    46.      }  
    47.    
    48.      @Override  
    49.      public String toString() {  
    50.          return "OrderItem [orderItemId=" + orderItemId + ", productName="  
    51.                    + productName + ", productPrice=" + productPrice + ", order="  
    52.                    + order + "]";  
    53.      }  
    54.    
    55.      public Integer getOrderItemId() {  
    56.          return orderItemId;  
    57.      }  
    58.    
    59.      public void setOrderItemId(Integer orderItemId) {  
    60.          this.orderItemId = orderItemId;  
    61.      }  
    62.    
    63.      public String getProductName() {  
    64.          return productName;  
    65.      }  
    66.    
    67.      public void setProductName(String productName) {  
    68.          this.productName = productName;  
    69.      }  
    70.    
    71.      public Double getProductPrice() {  
    72.          return productPrice;  
    73.      }  
    74.    
    75.      public void setProductPrice(Double productPrice) {  
    76.          this.productPrice = productPrice;  
    77.      }  
    78.    
    79.      public Order getOrder() {  
    80.          return order;  
    81.      }  
    82.    
    83.      public void setOrder(Order order) {  
    84.          this.order = order;  
    85.      }  
    86.    
    87.      public OrderItem(String productName,  
    88.               Double productPrice) {  
    89.          super();  
    90.          this.productName = productName;  
    91.          this.productPrice = productPrice;  
    92.      }  
    93. }  
    94.  ---------------------------------------------------------------------------------
    95.  双向一对多
    96. package com.morris.entity;  
    97.    
    98. import java.util.Set;  
    99.    
    100. import javax.persistence.CascadeType;  
    101. import javax.persistence.Column;  
    102. import javax.persistence.Entity;  
    103. import javax.persistence.FetchType;  
    104. import javax.persistence.Id;  
    105. import javax.persistence.OneToMany;  
    106. import javax.persistence.Table;  
    107.    
    108. @Entity  
    109. @Table(name="orders")  
    110. public class Order {  
    111.      
    112.     @Id  
    113.     @Column(name="order_id",length=32)  
    114.     private String orderId;  
    115.      
    116.     @Column(name="order_name",length=50)  
    117.     private String orderName;  
    118.      
    119.     /** 
    120.      * OneToMany:一对多的配置 
    121.      * mappedBy="order":指定由多的一方的order属性维护关联关系 
    122.      * 
    123.      */  
    124.     @OneToMany(cascade={CascadeType.REFRESH,CascadeType.MERGE,CascadeType.REMOVE,CascadeType.PERSIST},fetch=FetchType.LAZY,mappedBy="order")  
    125.     private Set<OrderItem> orderItems;  
    126.    
    127.     public Order(String orderId, String orderName, Set<OrderItem> orderItems) {  
    128.        super();  
    129.        this.orderId = orderId;  
    130.        this.orderName = orderName;  
    131.        this.orderItems = orderItems;  
    132.     }  
    133.    
    134.     public Set<OrderItem> getOrderItems() {  
    135.        return orderItems;  
    136.     }  
    137.    
    138.     public void setOrderItems(Set<OrderItem> orderItems) {  
    139.        this.orderItems = orderItems;  
    140.     }  
    141.    
    142.     public Order() {  
    143.        super();  
    144.        // TODO Auto-generated constructor stub  
    145.     }  
    146.    
    147.     public Order(String orderId, String orderName) {  
    148.        super();  
    149.        this.orderId = orderId;  
    150.        this.orderName = orderName;  
    151.     }  
    152.    
    153.     @Override  
    154.     public String toString() {  
    155.        return "Order [orderId=" + orderId + ", orderName=" + orderName + "]";  
    156.     }  
    157.    
    158.     public String getOrderId() {  
    159.        return orderId;  
    160.     }  
    161.    
    162.     public void setOrderId(String orderId) {  
    163.        this.orderId = orderId;  
    164.     }  
    165.    
    166.     public String getOrderName() {  
    167.        return orderName;  
    168.     }  
    169.    
    170.     public void setOrderName(String orderName) {  
    171.        this.orderName = orderName;  
    172.     }  
    173. }  


以上是关于JPA双向一对多多一对一的主要内容,如果未能解决你的问题,请参考以下文章

JPA中实现双向一对一的关联关系

spring data jpa关联查询(一对一对多多对多)

jpa休眠一对多双向[重复]

JPA 一对多双向堆栈溢出问题

Hibernate JPA双向一对多结果与约束冲突异常

一对多多列加入 Spring Data JPA