1. Unidirectional with join table
参考例子
http://www.vaannila.com/hibernate/hibernate-example/hibernate-mapping-one-to-many-using-annotations-1.html
2. Unidirectional with foreign key
PERSON
PERSON_ID
PERSON_NAME
ADDRESS
ADDRESS_ID
ADDRESS_NAME
P_ID
P_ID 字段在ADDRESS表中，但其定义在PERSON entity中
@Entity
@Table(name = "PERSON")
public class Person {
private Integer id;
private String name;
private Set<Address> addressSet = new HashSet<Address>(0);
public Person() {
}
public Person(String name, Set<Address> addSet) {
this.name = name;
this.addressSet = addSet;
}
@Id
@GeneratedValue
@Column(name = "PERSON_ID")
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name = "PERSON_NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinColumn(name = "P_ID")
public Set<Address> getAddressSet() {
return addressSet;
}
public void setAddressSet(Set<Address> addressSet) {
this.addressSet = addressSet;
}
@Override
public String toString() {
return this.id + "\t" + this.name;
}
}
@Entity
@Table(name = "ADDRESS")
public class Address {
private Integer addressId;
private String name;
public Address()
{
}
public Address(String name)
{
this.name = name;
}
@Id
@GeneratedValue
@Column(name = "ADDRESS_ID")
public Integer getAddressId() {
return addressId;
}
public void setAddressId(Integer addressId) {
this.addressId = addressId;
}
@Column(name = "ADDRESS_NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return this.addressId + "\t" + this.name;
}
}
插入数据时，hibernate会生成如下sql
Hibernate: insert into PERSON (PERSON_ID, PERSON_NAME) values (null, ?)
Hibernate: insert into ADDRESS (ADDRESS_ID, ADDRESS_NAME) values (null, ?)
Hibernate: insert into ADDRESS (ADDRESS_ID, ADDRESS_NAME) values (null, ?)
Hibernate: update ADDRESS set P_ID=? where ADDRESS_ID=?
Hibernate: update ADDRESS set P_ID=? where ADDRESS_ID=?
hibernate doc不建议使用此中连接，参考
http://docs.jboss.org/ejb3/app-server/HibernateAnnotations/reference/en/html_single/index.html#d0e1517
3. bidirectional
表结构
PERSON
PERSON_ID
PERSON_NAME
ADDRESS
ADDRESS_ID
ADDRESS_NAME
P_ID
A. many to one 端是owner
@Entity
@Table(name = "PERSON")
public class Person {
private Integer id;
private String name;
private Set<Address> addressSet = new HashSet<Address>(0);
public Person() {
}
public Person(String name, Set<Address> addSet) {
this.name = name;
this.addressSet = addSet;
}
@Id
@GeneratedValue
@Column(name = "PERSON_ID")
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name = "PERSON_NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER, [color=red]mappedBy = "person"[/color])
public Set<Address> getAddressSet() {
return addressSet;
}
public void setAddressSet(Set<Address> addressSet) {
this.addressSet = addressSet;
}
@Override
public String toString() {
return this.id + "\t" + this.name;
}
}
@Entity
@Table(name = "ADDRESS")
public class Address {
private Integer addressId;
private String name;
private Person person;
public Address()
{
}
public Address(String name)
{
this.name = name;
}
@Id
@GeneratedValue
@Column(name = "ADDRESS_ID")
public Integer getAddressId() {
return addressId;
}
public void setAddressId(Integer addressId) {
this.addressId = addressId;
}
@Column(name = "ADDRESS_NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@ManyToOne(cascade = CascadeType.ALL)
@JoinColumn(name = "P_ID")
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
@Override
public String toString() {
return this.addressId + "\t" + this.name;
}
}
B. one to many 端是owner
注意address 中joincolumn 的insertable 和updatable 为false
@Entity
@Table(name = "PERSON")
public class Person {
private Integer id;
private String name;
private Set<Address> addressSet = new HashSet<Address>(0);
public Person() {
}
public Person(String name, Set<Address> addSet) {
this.name = name;
this.addressSet = addSet;
}
@Id
@GeneratedValue
@Column(name = "PERSON_ID")
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name = "PERSON_NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinColumn(name = "P_ID")
public Set<Address> getAddressSet() {
return addressSet;
}
public void setAddressSet(Set<Address> addressSet) {
this.addressSet = addressSet;
}
@Override
public String toString() {
return this.id + "\t" + this.name;
}
}
@Entity
@Table(name = "ADDRESS")
public class Address {
private Integer addressId;
private String name;
private Person person;
public Address()
{
}
public Address(String name)
{
this.name = name;
}
@Id
@GeneratedValue
@Column(name = "ADDRESS_ID")
public Integer getAddressId() {
return addressId;
}
public void setAddressId(Integer addressId) {
this.addressId = addressId;
}
@Column(name = "ADDRESS_NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@ManyToOne(cascade = CascadeType.ALL)
@JoinColumn(name = "person_fk", insertable=false, updatable=false)
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
@Override
public String toString() {
return this.addressId + "\t" + this.name;
}
}
测试
1. 插入Person及关联的Address, hibernate 生成的的sql 语句为
many to one 端为owner时
Hibernate: insert into PERSON (PERSON_ID, PERSON_NAME) values (null, ?)
Hibernate: insert into ADDRESS (ADDRESS_ID, ADDRESS_NAME, person_fk) values (null, ?, ?)
Hibernate: insert into ADDRESS (ADDRESS_ID, ADDRESS_NAME, person_fk) values (null, ?, ?)
one to many 端为owner时
Hibernate: insert into PERSON (PERSON_ID, PERSON_NAME) values (null, ?)
Hibernate: insert into ADDRESS (ADDRESS_ID, ADDRESS_NAME) values (null, ?)
Hibernate: insert into ADDRESS (ADDRESS_ID, ADDRESS_NAME) values (null, ?)
Hibernate: update ADDRESS set person_fk=? where ADDRESS_ID=?
Hibernate: update ADDRESS set person_fk=? where ADDRESS_ID=?
2. 删除Address时，
many to one 端为owner时
Hibernate: delete from ADDRESS where ADDRESS_ID=?
Hibernate: delete from ADDRESS where ADDRESS_ID=?
Hibernate: delete from PERSON where PERSON_ID=?
one to many 端为owner时
Hibernate: update ADDRESS set person_fk=null where person_fk=?
Hibernate: delete from ADDRESS where ADDRESS_ID=?
Hibernate: delete from ADDRESS where ADDRESS_ID=?
Hibernate: delete from PERSON where PERSON_ID=?
3. 删除Person同删除Address相同
显然，one to many 端为owner时，会生成更多sql， 故hibernate doc有如下说明：
引用
This solution is obviously not optimized from the number of needed statements
参考：
http://docs.jboss.org/ejb3/app-server/HibernateAnnotations/reference/en/html_single/index.html#d0e949
分享到：
相关推荐
标题"Hibernate one to many(many to one) 配置"涉及到的是关系型数据库在Java中的持久化框架Hibernate中的两种关联映射关系：一对一（One-to-One）和多对一（Many-to-One）。在数据库设计中，这种关系很常见，例如...
"Hibernate one-to-many / many-to-one关系映射"是两个基本的关系类型，用于表示实体间的关联。在这个主题中，我们将深入探讨这两种关系映射的原理、配置和实际应用。 一、一对一（one-to-one）与一对多（one-to-...
本话题主要探讨两种基本的关系映射类型：many-to-one（多对一）和one-to-many（一对多）。这两种关系映射是数据库中常见的关联类型，理解和掌握它们对于开发高质量的Java应用至关重要。 1. many-to-one关系 many-to...
本示例将详细讲解如何在Hibernate中实现多对多（many-to-many）的关系映射。 在数据库设计中，多对多关系是指两个实体之间存在多个关联，比如学生和课程的关系，一个学生可以选修多门课程，一门课程也可以被多个...
在Java的持久化框架Hibernate中，"Many-to-One"关系是一种常见的关联映射类型，它表示一个实体（类）可以与多个其他实体实例相关联。在这个主题中，我们将深入探讨Hibernate如何处理这种关系，以及如何在实际编程中...
在Java的持久化框架Hibernate中，One-to-Many映射是一种常见的关系映射方式，它表示一个实体（比如一个用户）可以与多个其他实体（比如用户的订单）进行关联。在这个场景下，"用户"是一方，称为"One"，"订单"是另...
在配置双向一对多关联时，我们通常在"多"一端（这里是`Student`）的集合属性上使用`<many-to-one>`标签，将`Classes`对象映射到数据库中的外键。同时，在"一"端（`Classes`）使用`<set>`标签，表示班级可以包含多个...
在Java持久化框架Hibernate中，`one_to_many`映射是一种常见的关系模型，它表示一个实体（类）可以与多个其他实体（类）关联。在这个关系中，一个实体（通常是"one"端）对应多个实体实例（"many"端）。在数据库中，...
在Hibernate中，一对一唯一外键关联映射可以通过 `<many-to-one>` 标签来配置。例如，以下是Person实体与IdCard实体的一对一唯一外键关联映射配置： ```xml <many-to-one name="idCard" column="card_id...
在Hibernate中，`one-to-many`关系是常见的实体间关系之一，表示一个实体可以与多个其他实体相关联。本文将深入探讨`Hibernate one-to-many`注解的使用和实现细节。 ### 一、`@OneToMany`注解概述 `@OneToMany`...
### Hibernate Many-to-One (多对一) 及 Cascade (级联) #### 一、Many-to-One（多对一） 在数据库设计中，实体之间的关系主要包括一对一、一对多、多对多等几种类型。而在ORM（对象关系映射）框架Hibernate中，...
标题中的“Hibernate - one to many - update”指向的是一个关于Hibernate框架中的一对多关联关系在更新操作时的专题。Hibernate是Java开发中常用的持久化框架，它简化了数据库操作，使得开发者可以更加关注业务逻辑...
本实例将详细讲解如何在Hibernate中实现Many-to-One关系映射，这是一种常见的数据库关联，表示一个实体可以与多个其他实体相关联。 在Many-to-One关系中，通常一个实体（如部门）可以有多个相关实体（如员工），而...
本文将深入探讨Hibernate中一对多（One-to-Many）关系的处理方式，特别是通过外键映射和inverse属性的应用场景。 #### 一对多关系概念 一对多关系在数据库设计中非常常见，它指的是一个实体可以与多个其他实体关联...
除了基本的`<many-to-one>`映射外，Hibernate还支持多种映射策略，如`@ManyToOne`、`@JoinColumn`等注解，这些注解可以在实体类中直接使用，使得代码更加简洁明了。例如： ```java @ManyToOne(fetch = FetchType....
本文主要关注Hibernate中的一个核心概念——一对一（One-to-One）、一对多（One-to-Many）和多对一（Many-to-One）关联映射，特别是关于“一到多”单向和双向关联映射的配置心得。 首先，让我们了解“一到多”关联...
本文将深入探讨“Hibernate关联映射中的Many-to-One关系”。 Many-to-One关联是现实世界中常见的关系类型，比如一个学生可以对应多个课程，而一个课程可能被多个学生选修。在数据库中，这通常表现为一对多（One-to-...
《深入理解Hibernate：第三解——Many-to-One关系映射实战》 在Java世界里，ORM(Object-Relational Mapping)框架的出现极大地简化了数据库与Java对象之间的交互，而Hibernate作为其中的佼佼者，更是备受开发者青睐...
为了使用 `publisher` 属性，我们需要在 `Book` 类的 Hibernate 映射文件中添加 `<many-to-one>` 映射。这将在 `BOOK` 表中添加一个名为 `PUBLISHER_ID` 的列，并存储关联出版商的 ID。 ```xml <!-- 其他属性的...