双向一对多（多对一）@OneToMany或@ManyToOne的用法

来源：互联网发布：录音频的软件编辑：程序博客网时间：2024/05/19 09:37

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

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

首先建立订单实体类

import java.util.HashSet;   import java.util.Set;     import javax.persistence.CascadeType;   import javax.persistence.Column;   import javax.persistence.Entity;   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 = 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 },mappedBy ="order") //这里配置关系，并且确定关系维护端和被维护端。mappBy表示关系被维护端，只有关系端有权去更新外键。这里还有注意OneToMany默认的加载方式是赖加载。当看到设置关系中最后一个单词是Many，那么该加载默认为懒加载       public Set<OrderItem> getItems() {           return items;       }         public void setItems(Set<OrderItem> items) {           this.items = items;       }                   /**              *该方法用于向order中加order项             /*       public void addOrderItem(OrderItem orderItem){           orderItem.setOrder(this);//用关系维护端来维护关系           this.items.add(orderItem);       }     }

订单项的实体类

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;       private Order order;         @Id      @GeneratedValue      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 = true)       @JoinColumn(name="order_id")//这里设置JoinColum设置了外键的名字，并且orderItem是关系维护端      public Order getOrder() {           return order;       }         public void setOrder(Order order) {           this.order = order;       }     }

下面看看测试类

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 addOrder(){            EntityManagerFactory factory = Persistence.createEntityManagerFactory("test");            EntityManager em = factory.createEntityManager();            em.getTransaction().begin(); // start transaction                                  Order order = new Order();             order.setAmount(34f);             order.setOrderid("00001");                                            //order中包含的OrderItem项OrderItem1，OrderItem2            OrderItem orderItem1 = new OrderItem();            orderItem1.setProductName("书");            orderItem1.setSellPrice(22f);            order.addOrderItem(orderItem1); //add orderitem in order                        OrderItem orderItem2 = new OrderItem();            orderItem2.setProductName("篮球");            orderItem2.setSellPrice(100f);            order.addOrderItem(orderItem2);                        em.persist(order); //persist order object            em.getTransaction().commit(); //commit transaction            em.close();            factory.close();       }   }

双向一对多关系，一是关系维护端（owner side），多是关系被维护端（inverse side）。在关系被维护端需要通过@JoinColumn建立外键列指向关系维护端的主键列。

publicclass Order implements Serializable {

privateSet<OrderItem> orderItems = new HashSet<OrderItem>();

。。。。

@OneToMany(mappedBy="order",cascade = CascadeType.ALL, fetch = FetchType.LAZY)

@OrderBy(value = "id ASC")

public Set<OrderItem> getOrderItems() {

returnorderItems;

}

publicclass OrderItem implements Serializable {

private Order order;

。。。。

@ManyToOne(cascade=CascadeType.REFRESH,optional=false)

@JoinColumn(name = "order_id")

public Order getOrder() {

returnorder;

}

@OrderBy(value = "id ASC") 指明加载OrderItem 时按id 的升序排序

@OneToMany的属性：

1>targetEntity

定义关系类的类型，默认是该成员属性对应的类类型，所以通常不需要提供定义。

2>mappedBy

定义类之间的双向关系。如果类之间是单向关系，不需要提供定义，如果类和类之间形成双向关系，我们就需要使用这个属性进行定义，否则可能引起数据一致性的问题。

该属性的值是“多”方class里的“一”方的变量名

3>cascade

该属性定义类和类之间的级联关系。定义的级联关系将被容器视为对当前类对象及其关联类对象采取相同的操作，而且这种关系是递归调用的。举个例子：Order 和OrderItem有级联关系，那么删除Order时将同时删除它所对应的OrderItem对象。而如果OrderItem还和其他的对象之间有级联关系，那么这样的操作会一直递归执行下去。

cascade的值只能从CascadeType.PERSIST（级联新建）、CascadeType.REMOVE（级联删除）、CascadeType.REFRESH（级联刷新）、CascadeType.MERGE（级联更新）中选择一个或多个。还有一个选择是使用CascadeType.ALL，表示选择全部四项。

4>fatch

可选择项包括：FetchType.EAGER和FetchType.LAZY。前者表示关系类(本例是OrderItem 类)在主类(本例是Order类)加载的时候同时加载，后者表示关系类在被访问时才加载。默认值是FetchType.LAZY。

@JoinColumn(name = "order_id")注释指定OrderItem映射表的order_id列作为外键与Order 映射表的主键列关联。

@ManyToOne：指明OrderItem和Order之间为多对一关系。

@ManyToOne注释有四个属性：targetEntity、cascade、fetch 和optional，前三个属性的具体含义和@OneToMany的同名属性相同，但@ManyToOne的fetch 属性默认值是FetchType.EAGER。

optional属性是定义该关联类是否必须存在，值为false 时，关联类双方都必须存在，如果关系被维护端不存在，查询的结果为null。值为true 时, 关系被维护端可以不存在，查询的结果仍然会返回关系维护端，在关系维护端中指向关系被维护端的属性为null。optional属性的默认值是true。optional 属性实际上指定关联类与被关联类的join 查询关系，如optional=false 时join 查询关系为inner join, optional=true 时join 查询关系为left join。下面代码片断解释如下:

有一点需要强调：当业务方法需要把一个实体Bean作为参数返回给客户端时，除了实体Bean本身需要实现Serializable 接口之外，如果关联类(OrderItem)是延迟加载，还需在返回实体Bean之前通过访问关联类的方式加载关联类（见下例）。否则在客户端访问关联类时将会抛出加载例外。

public Order getOrderByID(Integer orderid) {

Order order = em.find(Order.class, orderid);

//!!!!!因为是延迟加载，通过执行size()这种方式获取订单下的所有订单项

order.getOrderItems().size();

return order;

}

另外不管是否延迟加载，通过join fetch 关联语句都可显式加载关联类，如下例：

public List getAllOrder() {

Query query = em.createQuery("select DISTINCT o from Order o inner

join fetch o.orderItems order by o.orderid");

List result = query.getResultList();