映射单向一对多的关联关系
新建项目项目请参考《JPA（二）：HellWord工程》，基于上一章讲解的《JPA（五）：映射关联关系------映射单向多对一的关联关系》中的例子进行修改（需要清空数据中的表，因为本例子还是使用customer，order表来测试，但是关联关系发生了变化）：
Customer.java
package com.dx.jpa.singlemanytoone;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
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()
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;
}
}
View Code
注意：这里在Customer.java中添加了一对多的注解@OneToMany：
// 映射一对多的关联关系
// @JoinColumn 用来映射一对多的关联关系
// @OneToMany 用来映射外键列
@JoinColumn(name = "CUSTOMER_ID")
@OneToMany()
public Set<Order> getOrders() {
return orders;
}
Order.java
package com.dx.jpa.singlemanytoone;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "jpa_order")
public class Order {
private Integer id;
private String name;
@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;
}
}
View Code
初始化JPA项目时，创建表语句如下：
Hibernate:
create table hibernate_sequence (
next_val bigint
) engine=InnoDB
Hibernate:
insert into hibernate_sequence values ( 1 )
Hibernate:
insert into hibernate_sequence values ( 1 )
Hibernate:
create table jpa_customer (
id integer not null,
age integer,
birth date,
createDate datetime,
FULL_NAME varchar(64) not null,
primary key (id)
) engine=InnoDB
Hibernate:
create table jpa_order (
id integer not null,
name varchar(255),
CUSTOMER_ID integer,
primary key (id)
) engine=InnoDB
Hibernate:
alter table jpa_order
add constraint FK7glkngwj74nr8h2amofkp1fjd
foreign key (CUSTOMER_ID)
references jpa_customer (id)
View Code
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>
View Code
此时在order表中创建了外键关联关系：
添加测试
添加测试函数：
@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);
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
(name, id)
values
(?, ?)
Hibernate:
insert
into
jpa_order
(name, id)
values
(?, ?)
Hibernate:
update
jpa_order
set
CUSTOMER_ID=?
where
id=?
Hibernate:
update
jpa_order
set
CUSTOMER_ID=?
where
id=?
View Code
此时并不是因为customer,order保存顺序导致的（即使调换添加先后顺序也会多处update语句），因为多的一端在插入时不会插入外键列，因此一定会多处update语句。
查询测试
添加测试函数：
@Test
public void testFind() {
Customer customer = entityManager.find(Customer.class, 1);
System.out.println(customer.getFullName());
System.out.println(customer.getOrders().size());
}
View Code
执行打印结果：
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_
from
jpa_customer customer0_
where
customer0_.id=?
AA
Hibernate:
select
orders0_.CUSTOMER_ID as CUSTOMER3_1_0_,
orders0_.id as id1_1_0_,
orders0_.id as id1_1_1_,
orders0_.name as name2_1_1_
from
jpa_order orders0_
where
orders0_.CUSTOMER_ID=?
2
从打印结果上可以看出默认采用懒加载的方式，修改Customer.java中的@OneToMany()中的fetch属性为：@OneToMany(fetch=FetchType.EAGER)，此时才会出现非懒加载：
此时，再次执行插叙测试函数，执行打印结果如下：
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_.name as name2_1_2_
from
jpa_customer customer0_
left outer join
jpa_order orders1_
on customer0_.id=orders1_.CUSTOMER_ID
where
customer0_.id=?
AA
2
修改测试
修改测试函数：
@Test
public void testUpdate() {
Customer customer = entityManager.find(Customer.class, 1);
customer.getOrders().iterator().next().setName("O-XX-01");
}
此时执行打印结果为：
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_.name as name2_1_2_
from
jpa_customer customer0_
left outer join
jpa_order orders1_
on customer0_.id=orders1_.CUSTOMER_ID
where
customer0_.id=?
Hibernate:
update
jpa_order
set
name=?
where
注意：这时@OneToMany(fetch=FetchType.EAGER)
删除测试
删除测试函数：
@Test
public void testRemove() {
Customer customer = entityManager.find(Customer.class, 4);
entityManager.remove(customer);
}
此时customer表内容记录如下：
order表记录如下：
此时执行删除，可以删除成功，删除后customer.id=4的记录被删除了，而order表中id=5,6记录的customer_id值被置为null。
删除后结果为：
customer表记录：
order表记录：
从执行打印语句可以看出：
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_.name as name2_1_2_
from
jpa_customer customer0_
left outer join
jpa_order orders1_
on customer0_.id=orders1_.CUSTOMER_ID
where
customer0_.id=?
Hibernate:
update
jpa_order
set
CUSTOMER_ID=null
where
CUSTOMER_ID=?
Hibernate:
delete
from
jpa_customer
where
id=?
实际上，我们可以通过配置@OneToMany的级联删除属性，可以通过删除customer来实现级联删除的。
修改Customer.java中的@OneToMany注解信息：
这里修改配置后Customer的getOrders()方法的注解为：
// 映射一对多的关联关系
// @JoinColumn 用来映射一对多的关联关系
// @OneToMany 用来映射外键列
@JoinColumn(name = "CUSTOMER_ID")
@OneToMany(fetch=FetchType.EAGER,cascade=CascadeType.REMOVE)
public Set<Order> getOrders() {
return orders;
}
此时，测试通过删除customer.id=1的记录，测试结果可以成功级联删除，执行打印结果为：
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_.name as name2_1_2_
from
jpa_customer customer0_
left outer join
jpa_order orders1_
on customer0_.id=orders1_.CUSTOMER_ID
where
customer0_.id=?
Hibernate:
update
jpa_order
set
CUSTOMER_ID=null
where
CUSTOMER_ID=?
Hibernate:
delete
from
jpa_order
where
id=?
Hibernate:
delete
from
jpa_order
where
id=?
Hibernate:
delete
from
jpa_customer
where
id=?
基础才是编程人员应该深入研究的问题，比如:
1）List/Set/Map内部组成原理|区别
2）mysql索引存储结构&如何调优/b-tree特点、计算复杂度及影响复杂度的因素。。。
3）JVM运行组成与原理及调优
4）Java类加载器运行原理
5）Java中GC过程原理|使用的回收算法原理
6）Redis中hash一致性实现及与hash其他区别
7）Java多线程、线程池开发、管理Lock与Synchroined区别
8）Spring IOC/AOP 原理；加载过程的。。。
【+加关注】。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
