package com.hibernate.jpa.bean1;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
@Entity
public class Auto {
/**
* one to many 一对多关联
*/
private Integer autoId;
private String autotype;
private String autonum;
private Garage garage;
@Id @GeneratedValue
public Integer getAutoId() {
return autoId;
}
public void setAutoId(Integer autoId) {
this.autoId = autoId;
}
public String getAutotype() {
return autotype;
}
public void setAutotype(String autotype) {
this.autotype = autotype;
}
public String getAutonum() {
return autonum;
}
public void setAutonum(String autonum) {
this.autonum = autonum;
}
@ManyToOne
@JoinColumn(name="garageid")
public Garage getGarage() {
return garage;
}
public void setGarage(Garage garage) {
this.garage = garage;
}
}
------车库
package com.hibernate.jpa.bean1;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
@Entity
public class Garage {
/**
* many to one 多对一
*/
private Integer gid;
private String garagenum;
private Set<Auto> autos = new HashSet<Auto>();
@Id @GeneratedValue
public Integer getGid() {
return gid;
}
public void setGid(Integer gid) {
this.gid = gid;
}
@Column(length=20)
public String getGaragenum() {
return garagenum;
}
public void setGaragenum(String garagenum) {
this.garagenum = garagenum;
}
@OneToMany(mappedBy="garage")
public Set<Auto> getAutos() {
return autos;
}
public void setAutos(Set<Auto> autos) {
this.autos = autos;
}
public void addGarageAuto(Auto auto) {
auto.setGarage(this);
this.autos.add(auto);
}
}
---------junit保存方法
@Test public void save() {
EntityManagerFactory factory = Persistence.createEntityManagerFactory("jpa-hibernate");
EntityManager em = factory.createEntityManager();
em.getTransaction().begin();
Garage garage = new Garage();
garage.setGaragenum("room1");
Auto auto1 = new Auto();
auto1.setAutonum("bj0000");
auto1.setAutotype("car");
Auto auto2 = new Auto();
auto2.setAutonum("bj1231");
auto2.setAutotype("bus");
garage.addGarageAuto(auto1);
garage.addGarageAuto(auto2);
em.persist(garage);
em.getTransaction().commit();
em.close();
factory.close();
}
运行以上save()方法之后,数据库中只对应的表,但是只有garage表中被存入了数据,而auto表中没有被存入数据,仅仅是生成了表而已。
观察发出的sql语句:
-----------------------------------------------------------------------
当把
@OneToMany(mappedBy="garage")
public Set<Auto> getAutos() {
return autos;
}
改为:
@OneToMany(cascade={CascadeType.PERSIST},mappedBy="garage")
public Set<Auto> getAutos() {
return autos;
}
即多添加了一行cascade={CascadeType.PERSIST} 申明级联级联保存
删除前面生成的数据库表garage 和 auto
再次运行save()方法
这是我们看到数据库中都有对应的记录
观察发出的sql语句:
Hibernate: insert into Garage (garagenum) values (?)
Hibernate: insert into Auto (autonum, autotype, garageid) values (?, ?, ?)
Hibernate: insert into Auto (autonum, autotype, garageid) values (?, ?, ?)
分享到:
相关推荐
本资料包"10_JPA详解_JPA中的一对多双向关联与级联操作.zip"聚焦于JPA中的一个重要概念——一对多双向关联及其级联操作。以下是对这一主题的详细阐述。 **一对多关联** 在关系数据库设计中,一对多关联是最常见的...
`fetch`定义加载策略,`cascade`定义级联操作,如保存、删除等是否影响关联的实体。 9. **@OneToOne, @OneToMany, @ManyToMany**:这三种注解分别用于定义一对一、一对多和多对多的关系映射,它们也包含fetch和...
- **级联操作(Cascading)**:通过设置@Cascade注解,可以在操作实体时自动处理关联的实体。 此外,JPA还可以与其他技术结合,如Spring Data JPA,它提供了一套基于注解的声明式查询方法,进一步简化了数据访问...
3. ** Cascade操作**:`@ManyToMany`支持级联操作,如`CascadeType.PERSIST`、`CascadeType.MERGE`等,这使得在保存或更新主侧实体时,关联的次侧实体也会相应处理。 4. **Fetch策略**:默认情况下,JPA使用懒加载...
- **级联操作(Cascade)**:一个操作(如删除)会影响到其他相关实体。 - **继承(Inheritance)**:支持类继承关系的映射,如单表继承、联合继承、表格派生。 - **查询语言(JPQL)**:类似SQL的查询语言,用于在对象层...
在本教程中,我们将深入探讨JPA中的多对多双向关联及其各项操作。 ### 1. 多对多关联基础 在关系型数据库中,多对多关联通常通过中间表来实现,而JPA提供了一种声明式的方式来处理这种关联。在双向关联中,两个...
### JPA关联映射详解 #### 一、引言 Java Persistence API (JPA) 是 Java 平台标准的一部分,用于处理对象关系映射 (ORM)。它允许开发者以面向对象的方式开发应用程序,并通过注解将实体类映射到数据库表。在 JPA ...
1. **级联操作**:通过`CascadeType`可以指定在操作一个实体时,是否同时对关联的实体进行相同的操作,如`CascadeType.ALL`会包含保存、更新、删除等所有操作。 2. **懒加载与急加载**:JPA提供了懒加载和急加载策略...
在实际开发中,我们还需要考虑懒加载(Lazy Loading)和急加载(Eager Loading)策略,以及级联操作(Cascade Type)等特性,以优化性能和提高代码的灵活性。`@LazyCollection(LazyCollectionOption.EXTRA)`或`fetch...
7. **级联操作**:通过`cascade`属性,可以在一个实体的操作中影响到关联的实体,例如`@ManyToMany(cascade = CascadeType.ALL)`可以确保删除一个学生时,关联的课程也会被删除。 理解并熟练掌握JPA中的多对多双向...
**JPA一对多和多对一关系详解** Java Persistence API(JPA)是Java平台上的一个标准,用于处理对象关系映射(ORM),使得开发者可以使用面向对象的方式来操作数据库。在JPA中,实体间的关系映射是核心概念之一,...
8. **级联操作(Cascading)**:通过@Cascade注解,可将一个实体的操作(如保存、删除)应用到与其关联的实体。 9. **实体监听器(Entity Listener)**:通过@EntityListener注解,可以定义在特定实体事件(如保存...
- `cascade`:可选参数,表示级联操作的类型,常见的有: - `ALL`:所有操作。 - `PERSIST`:持久化。 - `MERGE`:合并。 - `REMOVE`:删除。 - `REFRESH`:刷新。 - `DETACH`:分离。 ```java @ManyToOne...
### JPA注解详解 #### 一、概述 Java Persistence API (JPA) 是 Java 社区标准 JSR-317 的一部分,它提供了一种面向对象的方式来处理数据库操作,极大地方便了 Java 应用程序对关系数据库的操作。JPA 主要包括两个...
**JPA 双向一对多关系详解** 在Java Persistence API(JPA)中,数据建模是通过实体类和它们之间的关联来实现的。在实际的业务场景中,经常会出现两个实体之间存在一对多(One-to-Many)的关系,比如一个用户可以有...
### JPA注解详解 #### 一、概述 Java Persistence API (JPA) 是 Java EE 5.0 规范中的一个重要的组成部分,它提供了一种面向对象的方式来处理数据库操作,极大地方便了开发人员对数据库的操作。JPA 的主要优势在于...
- `cascade`:表示级联操作策略,可以指定为 `ALL`, `PERSIST`, `MERGE`, `REFRESH` 等。 **示例**: ```java @ManyToOne(fetch = FetchType.LAZY, optional = false) public Address getAddress() { return ...
- `cascade`:级联操作,可以是`ALL`(所有操作)、`PERSIST`(保存)、`MERGE`(合并)、`REFRESH`(刷新)和`REMOVE`(删除)。 ### 示例 假设我们有一个`User`实体类,包含`id`、`name`和`birthday`字段,并且...
- `cascade`:可选,指定级联操作策略。 - `optional`:可选,是否允许为空,默认为 `true`。 - **用法**:放在属性上。 ```java @Entity public class Post { @ManyToOne(fetch = FetchType.LAZY, cascade = ...
- **级联操作(Cascading)**: 设置`cascade`属性,使操作影响到关联的实体。 - **事件监听(Entity Listeners)**: 注册实体监听器以在特定生命周期事件(如预持久化、后加载等)执行自定义逻辑。 在电子商务项目...