JPA的一对多映射(双向)关联

实体Customer：用户。

　　实体Order：订单。

　　Customer和Order是一对多关系。那么在JPA中，如何表示一对多的双向关联呢？

　　JPA使用@OneToMany和@ManyToOne来标识一对多的双向关联。一的一端(Customer)使用@OneToMany,多端(Order)使用@ManyToOne。

　　在JPA规范中，一对多的双向关系由多端(Order)来维护。就是说多端(Order)为关系维护端，负责关系的增删改查。一端(Customer)则为关系被维护端，不能维护关系。

　　一端(Customer)@OneToMany注释的mappedBy="customer"属性表明Customer是关系被维护端。

　　多端(Order)使用@ManyToOne和@JoinColumn来注释属性CUSTOMER_ID,@ManyToOne表明Order是多端，@JoinColumn设置在Order表中的关联字段(外键)。

Customer实体类如下：

/**
 *数据库持久化类
 * @author z
 *
 */
@Table(name="JPA_CUSTOMERS")//主要是映射表名对应的数据库表名JPA_CUSTOMER默认情况下可以不写表名与持久化类名相同
@Entity //表明这是一个持久化类
public class Customer {

    private Integer id;
    private String lastName;
    private String email;
    private int  age ;

    private Date createdTime;
    private Date birth;

    /**
     * 单向一对多关系映射
     * 1、添加多的一方的集合属性
     */
      private Set<Order> orders=new HashSet<>();

    /**
     * 定义各数据列必须加在get方法上
     * @return
     */
    //定义主键，生成主键的策略AUTO自动的根据数据的类型生成主键
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Id //定义数据列
//    @Column(name="ID")//定义数据库的列名如果与字段名一样可以省略

    //使用table生成主键
//    @TableGenerator(name="ID_GENERATOR",
//            table="JPA_ID_GENERATORS",
//            pkColumnName="PK_NAME",
//            pkColumnValue="CUSTOMER_ID",
//            valueColumnName="PK_VALUE",
//            allocationSize=100
//
//
//            )
//
//    @GeneratedValue(strategy=GenerationType.TABLE,generator="ID_GENERATOR")
//    @Id
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name="LAST_NAME",length=,nullable=false) //nullable false表示此字段不能为空
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Temporal(TemporalType.TIMESTAMP)
    public Date getCreatedTime() {
        return createdTime;
    }
    public void setCreatedTime(Date createdTime) {
        this.createdTime = createdTime;
    }
    @Temporal(TemporalType.DATE)
    public Date getBirth() {
        return birth;
    }
    public void setBirth(Date birth) {
        this.birth = birth;
    }

    //映射单向一对多的关联关系
    //使用@OneToMany 来映射一对多的关联关系
    //使用@JoinColumn 来映射外键列的名称
    //可以使用@OneToMany的fetch 属性来修改默认的加载策略
    //可以通过@OneToMany的cascade 属性来修改默认的删除策略
    //cascade={CascadeType.REMOVE} 会把主表和从表的数据都删除
    //mappedBy表明放弃关联关系维护并且不能在使用
    //注意：若在一的一端@oneToMany 中使用mapperBy属性，则@oneToMany端就不能在使用@JoinColumn(name="CUSTOMER_ID")属性
//    @JoinColumn(name="CUSTOMER_ID")
    @OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE},mappedBy="customer")
   public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }

    //工具方法，不需要映射为数据表的一列
    @Transient
    public String getInfo(){
        return "lastName:"+lastName+",email:"+email;
    }
    @Override
    public String toString() {
        return "Customer [id=" + id + ", lastName=" + lastName + ", email=" + email + ", age=" + age + ", createdTime="
                + createdTime + ", birth=" + birth + "]";
    }

}

多的一端实体类Order如下：

/**
 * 单向多对一
 * 一个订单可以有多个用户
 * 一个用户可以有多个订单
 * @author z
 *
 */
@Table(name="JPA_ORDERS")
@Entity
public class Order {
    private Integer id;
    private String orderName;

    private Customer customer;
    @GeneratedValue//使用默认的主键生成方式
    @Id
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }
    @Column(name="ORDER_NAME")
    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }
    //映射单向n-1的关联关系
    //使用@ManyToOne 来映射多对一的关系
    //使用@JoinColumn 来映射外键
    //可以使用@ManyToOne的fetch属性来修改默认的关联属性的加载策略
    @JoinColumn(name="CUSTOMER_ID")//外键列的列名
    @ManyToOne(fetch=FetchType.LAZY)
    public Customer getCustomer() {
    return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    @Override
    public String toString() {
        return "Order [id=" + id + ", orderName=" + orderName + ", customer=" + customer+ "]";
    }

}

简单的测试类

public class JPATest {
    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;
    @Before
    public void init(){
        entityManagerFactory= Persistence.createEntityManagerFactory("jpa-1");
        entityManager=entityManagerFactory.createEntityManager();
        transaction=entityManager.getTransaction();
        transaction.begin();//开启事务

    }
    @After
    public void destroy(){
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

    //修改
    @Test
    public void testUpdate(){
        Customer customer=entityManager.find(Customer.class, );
        customer.getOrders().iterator().next().setOrderName("O-XXX-10");

    }

     //删除
    //默认情况下，若删除1的一端，则会先把关联的多的一段的外键置空,然后删除一的一端
    ////可以通过@OneToMany的cascade 属性来修改默认的删除策略
    @Test
    public void testOneToManyRemove(){
        Customer customer=entityManager.find(Customer.class, );
        entityManager.remove(customer);

    }

    //默认对关联多的一方使用懒加载的加载策略(延迟加载)
    //可以使用@OneToMany的fetch 属性来修改默认的加载策略
    //查询
    @Test
    public void testOneToManyFind(){
        Customer customer=entityManager.find(Customer.class,);
        System.out.println(customer.getLastName());

        System.out.println(customer.getOrders().size());

    }

    //双向一对多的关联关系在执行保存时
    //若先保存多的一端，在保存一的一端，默认情况下，会多出四条update语句
    //若先保存一的一端则会多出2(n)条update语句
    //在进行双向一对多的关联关系时，建议使用多的一方来维护关联关系，而1的一方不维护关联关系，这样会有效的减少sql语句
    //注意：若在一的一端@oneToMany 中使用mapperBy属性，则@oneToMany端就不能在使用@JoinColumn(name="CUSTOMER_ID")属性//保存
    @Test
    public void testOneToManyPersist(){
        Customer customer=new Customer();
        customer.setAge();
        customer.setBirth(new Date());
        customer.setCreatedTime(new Date());
        customer.setEmail("CC@163.com");
        customer.setLastName("AA");

        Order order1=new Order();
        order1.setOrderName("o-CC-1");

        Order order2=new Order();
        order2.setOrderName("o-CC-2");

        //建立关联关系
        customer.getOrders().add(order1);
        customer.getOrders().add(order2);
        //执行保存操作
        entityManager.persist(customer);
        entityManager.persist(order1);
        entityManager.persist(order2);    

    }
    }

源码地址：https://github.com/wuhongpu/JPA.git