基于外键1-N关联(无连接表)
一个Customer关联多个Card
Customer实体(1端):
package com.ydoing.hibernate4;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
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;
@Entity
@Table(name = "customer_inf")
public class Customer {
@Id
@Column(name = "customer_id")
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
private String name;
@OneToMany(targetEntity = Card.class, cascade = CascadeType.ALL)
@JoinColumn(name = "customer_id", referencedColumnName = "customer_id")
private Set<Card> cards = new HashSet<>();
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;
}
public Set<Card> getCards() {
return cards;
}
public void setCards(Set<Card> cards) {
this.cards = cards;
}
}
Card实体(N端):
package com.ydoing.hibernate4;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "card_inf")
public class Card {
@Id
@Column(name = "card_id")
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
private String name;
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;
}
}
测试:
package com.ydoing.hibernate4
import org.hibernate.Session
import org.hibernate.SessionFactory
import org.hibernate.Transaction
import org.hibernate.boot.registry.StandardServiceRegistryBuilder
import org.hibernate.cfg.Configuration
import org.hibernate.service.ServiceRegistry
import org.junit.BeforeClass
import org.junit.Test
public class Main {
private static Session session
@BeforeClass
public static void init() {
Configuration conf = new Configuration()
conf.configure()
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(conf.getProperties())
.build()
SessionFactory factory = conf.buildSessionFactory(serviceRegistry)
session = factory.openSession()
}
@Test
public void test() {
Transaction tx = session.getTransaction()
tx.begin()
Customer customer = new Customer()
customer.setName("Jack")
Card card1 = new Card()
card1.setName("ICBC")
Card card2 = new Card()
card2.setName("CCB")
customer.getCards().add(card1)
customer.getCards().add(card2)
session.save(customer)
tx.commit()
session.close()
}
}
Console输出:
Hibernate:
insert
into
customer_inf
(name)
values
(?)
Hibernate:
select
last_insert_id()
Hibernate:
insert
into
card_inf
(name)
values
(?)
Hibernate:
select
last_insert_id()
Hibernate:
insert
into
card_inf
(name)
values
(?)
Hibernate:
select
last_insert_id()
Hibernate:
update
card_inf
set
customer_id=?
where
card_id=?
Hibernate:
update
card_inf
set
customer_id=?
where
card_id=?
从输出不难看出Hibernate主要进行了5个操作。首先向customer_inf插入一条数据,向card_inf插入两条数据。然后两次更新card_inf表。
数据表:
customer_inf:
card_inf:
有连接表的单向1-N关联
只要改变前面Customer类就行了
package com.ydoing.hibernate4;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
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.JoinTable;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name = "customer_inf")
public class Customer {
@Id
@Column(name = "customer_id")
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
private String name;
@OneToMany(targetEntity = Card.class, cascade = CascadeType.ALL)
@JoinTable(name = "customer_card_inf", joinColumns = @JoinColumn(name = "customer_id", referencedColumnName = "customer_id"), inverseJoinColumns = @JoinColumn(name = "card_id", referencedColumnName = "card_id", unique = true))
private Set<Card> cards = new HashSet<>();
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;
}
public Set<Card> getCards() {
return cards;
}
public void setCards(Set<Card> cards) {
this.cards = cards;
}
}
Console输出:
Hibernate:
insert
into
customer_inf
(name)
values
(?)
Hibernate:
select
last_insert_id()
Hibernate:
insert
into
card_inf
(name)
values
(?)
Hibernate:
select
last_insert_id()
Hibernate:
insert
into
card_inf
(name)
values
(?)
Hibernate:
select
last_insert_id()
Hibernate:
insert
into
customer_card_inf
(customer_id, card_id)
values
(?, ?)
Hibernate:
insert
into
customer_card_inf
(customer_id, card_id)
values
(?, ?)
从输出不难看出,Hibernate创建了连接表customer_card_inf。
数据库表:
<script type="text/javascript">
$(function () {
$('pre.prettyprint code').each(function () {
var lines = $(this).text().split('\n').length;
var $numbering = $('<ul/>').addClass('pre-numbering').hide();
$(this).addClass('has-numbering').parent().append($numbering);
for (i = 1; i <= lines; i++) {
$numbering.append($('<li/>').text(i));
};
$numbering.fadeIn(1700);
});
});
</script>
版权声明:本文为博主原创文章,未经博主允许不得转载。
分享到:
相关推荐
“Hibernate基于外键的一对多单向关联”这个标题指的是在Java持久化框架Hibernate中,如何通过外键实现一个实体类(如订单)与另一个实体类(如商品)之间的一对多关系,并且这种关联是单向的,即从订单端可以访问到...
8. **单向与双向映射**:一对多关系可以是单向的,即只有“1”端知道“N”端;也可以是双向的,双方都有对对方的引用。双向映射需要注意维护关系的同步,防止数据不一致。 在实践中,我们可以使用Hibernate的API来...
本篇文章将详细讲解Hibernate的两种单向关联关系:单向1-N关联和单向N-1关联。 1. **单向1-N关联** 在这种关联关系中,一个实体(1端)可以与多个其他实体(N端)相关联。在Hibernate中,通常在1端的实体类中引入...
本教程将深入探讨Hibernate中的四种主要数据关联:一对一(11)、多对一(M1)、一对多(1N)和多对多(MN)的关系映射。 1. **一对一(11)关联**: 在现实世界中,有些实体间存在一对一的关系,例如一个人只有一...
`hibernate_many2many_1`和`hibernate_many2many_2`的示例可能会展示如何创建中间表来存储这种关系,通常需要定义两个`@ManyToMany`注解,分别在两个参与关联的实体上,并通过`@JoinTable`来指定关联的表结构。...
在本篇讨论中,我们将深入探讨Hibernate如何实现多对多单向关联。 一、多对多关联的配置 在Hibernate中,多对多关联通常通过`@ManyToMany`注解来定义。这个注解可以用在实体类的属性上,表示该属性与另一个实体类...
本文主要探讨的是Hibernate中的两种关联关系:多对一单向关联和多对一双向关联。通过理解这两种关联方式,我们可以更好地设计和实现复杂的数据库模型。 首先,我们来看**多对一单向关联**。这种关联意味着一个实体...
单向N-1关联 这种关联通常代表一种“一对多”的关系,例如,一个人可以有多个地址。在Hibernate中,我们可以通过在N的一端(通常是拥有集合的一方)使用`<many-to-one>`元素来实现这种关联。对于无连接表的N-1关联...
1. **单向N-1关联(无连接表)** 在这种关联中,一个Person对象拥有一个Address对象。在Person类中添加`private Address address`属性,并在`person.hbm.xml`中配置`<many-to-one>`元素,如`<many-to-one name=...
本篇文章将深入探讨Hibernate中一对多单向关联映射的概念、配置以及其实现方法。 一、概念理解 一对多关联意味着在数据库中,一个表(实体)的一条记录可以对应另一个表(实体)的多条记录。例如,一个学生可以有多...
8. **查询优化**:使用HQL(Hibernate Query Language)或Criteria API进行更高效的查询,避免N+1查询问题。 通过学习这个教程和相关源码,开发者将能够理解和掌握在Hibernate中如何配置和使用一对一单向外键关联,...
###### 2.1.1 多对一 (N-1) - **基于FK**:在这种情况下,只有一方包含了另一方的引用关联实体属性。例如,`Person`类包含了一个指向`Address`类的属性。 - **映射示例**: ```xml <many-to-one name="address" ...
- 解决著名的`n+1`问题,即多次查询相同数据的问题。 - 通过配置适当的缓存策略,可以减少数据库的直接访问次数。 #### 七、`inverse`与二级缓存的关系 在管理双向关联时,`inverse`属性和二级缓存的使用需要仔细...
在实际应用中,我们还需要注意一些最佳实践,比如合理选择加载策略(EAGER vs LAZY),避免N+1查询问题,以及正确处理级联操作(如级联保存、删除等)。通过理解并熟练运用这些技巧,可以更高效地使用Hibernate进行...
1. **外键约束**:在一对一关联中,通常由一方持有外键,可以是双向关联,也可以是单向关联。 2. **唯一性**:在数据库中,一对一关联的两个表的关联字段必须具有唯一性约束。 3. **性能考虑**:根据业务需求选择...
- **一对多,在一的一端维护关系的缺点**:可能导致性能问题,如N+1查询问题。 - **一对多单向数据加载**:演示如何加载一对多的数据。 #### 一对多关联映射双向(one-to-many) - **学生映射文件修改后的**:调整...
- 查询:HQL(Hibernate Query Language)是Hibernate的查询语言,可以避免N+1问题,通过一次性加载所有数据或使用`Criteria` API进行分页查询。 总的来说,Hibernate通过简化数据库操作,提高了开发效率。理解并...
本知识点将深入讲解Hibernate中的一对一(OneToOne)连接,特别是单向关联的实现。 在数据库设计中,一对一关联是指两个实体之间存在唯一对应的关系,例如一个人可能只有一个身份证,或者一个账户只有一个用户信息...
### Hibernate的N对N的关系映射详解 #### 一、概念理解 在关系型数据库设计中,实体之间的关联关系主要有三种类型:一对一(One-to-One)、一对多(One-to-Many)以及多对多(Many-to-Many)。而Hibernate作为一种...