JPA（七）：映射关联关系------映射双向多对一的关联关系

映射双向多对一的关联关系

修改Customer.java

package com.dx.jpa.singlemanytoone;

import java.util.Date;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;

@Entity
@Table(name = "jpa_customer")
public class Customer {
    private Integer id;
    private String fullName;
    private Integer age;
    private Date birth;
    private Date createDate;
    private Set<Order> orders = new HashSet<>();

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name = "FULL_NAME", length = 64, nullable = false)
    public String getFullName() {
        return fullName;
    }

    public void setFullName(String fullName) {
        this.fullName = fullName;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Temporal(TemporalType.DATE)
    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    @Temporal(TemporalType.TIMESTAMP)
    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    // 映射一对多的关联关系
    // @JoinColumn 用来映射一对多的关联关系
    // @OneToMany 用来映射外键列
    @JoinColumn(name = "CUSTOMER_ID")
    @OneToMany(fetch=FetchType.EAGER,cascade=CascadeType.REMOVE)
    public Set<Order> getOrders() {
        return orders;
    }

    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }

    // 帮助方法，不希望保存到数据库，但是需要动态获取Customer对象的属性。
    @Transient
    public String getCustomerInfo() {
        return "username:" + fullName + ",age:" + age;
    }
}

修改Order.java

package com.dx.jpa.singlemanytoone;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = "jpa_order")
public class Order {
    private Integer id;
    private String name;
    private Customer Customer;

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @JoinColumn(name = "CUSTOMER_ID")
    @ManyToOne(fetch = FetchType.LAZY)
    public Customer getCustomer() {
        return Customer;
    }

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

修改persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
    xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
    <persistence-unit name="Jpa-helloword"
        transaction-type="RESOURCE_LOCAL">
        <!-- 配置使用什么 ORM 产品来作为 JPA 的实现 -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!-- 添加持久化类 -->
        <class>com.dx.jpa.singlemanytoone.Customer</class>
        <class>com.dx.jpa.singlemanytoone.Order</class>
        <properties>
            <!-- 数据库的相关配置 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://127.0.0.1:3306/jpa" />
            <property name="javax.persistence.jdbc.user" value="root" />
            <property name="javax.persistence.jdbc.password" value="root" />
            <!-- 指定方言 
            MySQL                org.hibernate.dialect.MySQLDialect
            MySQL with InnoDB    org.hibernate.dialect.MySQLInnoDBDialect
            MySQL with MyISAM    org.hibernate.dialect.MySQLMyISAMDialect
            MySQL5                org.hibernate.dialect.MySQL5Dialect
            MySQL5 with InnoDB    org.hibernate.dialect.MySQL5InnoDBDialect
            -->
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.format_sql" value="true" />
            <!-- 
            create：每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，哪怕两次没有任何改变也要这样执行，这就是导致数据库表数据丢失的一个重要原因。<br>
            create-drop ：每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除。<br>
            update：最常用的属性，第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），以后加载hibernate时根据 model类自动更新表结构，即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后，表结构是不会被马上建立起来的，是要等 应用第一次运行起来后才会。<br>
            validate ：每次加载hibernate时，验证创建数据库表结构，只会和数据库中的表进行比较，不会创建新表，但是会插入新值。 <br> 
            -->
            <property name="hibernate.hbm2ddl.auto" value="update" />            
        </properties>
    </persistence-unit>
</persistence>

特别注意：配置双向多对一的关联关系时，Customer.java配置：

    // 映射一对多的关联关系
    // @JoinColumn 用来映射一对多的关联关系
    // @OneToMany 用来映射外键列
    @JoinColumn(name = "CUSTOMER_ID")
    @OneToMany(fetch=FetchType.EAGER,cascade=CascadeType.REMOVE)
    public Set<Order> getOrders() {
        return orders;
    }

Order.java配置：

    @JoinColumn(name = "CUSTOMER_ID")
    @ManyToOne(fetch = FetchType.LAZY)
    public Customer getCustomer() {
        return Customer;
    }

表关联关系：

测试添加：

添加测试函数：

    @Test
    public void testPersist() {
        Customer customer = new Customer();
        customer.setFullName("AA");
        customer.setAge(26);
        customer.setBirth(new Date());
        customer.setCreateDate(new Date());

        Order order1 = new Order();
        order1.setName("O-AA-01");

        Order order2 = new Order();
        order2.setName("O-AA-02");

        customer.getOrders().add(order1);
        customer.getOrders().add(order2);

        order1.setCustomer(customer);
        order2.setCustomer(customer);

        entityManager.persist(customer);
        entityManager.persist(order1);
        entityManager.persist(order2);
    }

执行sql::

Hibernate: 
    select
        next_val as id_val 
    from
        hibernate_sequence for update
            
Hibernate: 
    update
        hibernate_sequence 
    set
        next_val= ? 
    where
        next_val=?
Hibernate: 
    select
        next_val as id_val 
    from
        hibernate_sequence for update
            
Hibernate: 
    update
        hibernate_sequence 
    set
        next_val= ? 
    where
        next_val=?
Hibernate: 
    select
        next_val as id_val 
    from
        hibernate_sequence for update
            
Hibernate: 
    update
        hibernate_sequence 
    set
        next_val= ? 
    where
        next_val=?
Hibernate: 
    insert 
    into
        jpa_customer
        (age, birth, createDate, FULL_NAME, id) 
    values
        (?, ?, ?, ?, ?)
Hibernate: 
    insert 
    into
        jpa_order
        (CUSTOMER_ID, name, id) 
    values
        (?, ?, ?)
Hibernate: 
    insert 
    into
        jpa_order
        (CUSTOMER_ID, name, id) 
    values
        (?, ?, ?)
Hibernate: 
    update
        jpa_order 
    set
        CUSTOMER_ID=? 
    where
        id=?
Hibernate: 
    update
        jpa_order 
    set
        CUSTOMER_ID=? 
    where
        id=?

测试查询：

测试查询函数：

    @Test
    public void testFind() {
        Customer customer = entityManager.find(Customer.class, 1);
        System.out.println(customer.getFullName());
        System.out.println(customer.getOrders().size());
    }

执行sql语句：

Hibernate: 
    select
        customer0_.id as id1_0_0_,
        customer0_.age as age2_0_0_,
        customer0_.birth as birth3_0_0_,
        customer0_.createDate as createDa4_0_0_,
        customer0_.FULL_NAME as FULL_NAM5_0_0_,
        orders1_.CUSTOMER_ID as CUSTOMER3_1_1_,
        orders1_.id as id1_1_1_,
        orders1_.id as id1_1_2_,
        orders1_.CUSTOMER_ID as CUSTOMER3_1_2_,
        orders1_.name as name2_1_2_ 
    from
        jpa_customer customer0_ 
    left outer join
        jpa_order orders1_ 
            on customer0_.id=orders1_.CUSTOMER_ID 
    where
        customer0_.id=?
BB
2

测试修改：

测试修改函数：

执行sql语句：

测试删除：

4）映射双向一对一的关联关系

5）映射双向多对多的关联关系