Hibernate级联删除相关实体(ManyToOne OneToMany)
Hibernate是一个开源的Java持久化框架，它提供了对象关系映射（ORM）的解决方案，可以将Java对象映射到关系型数据库中的表结构。在Hibernate中，级联删除是指当删除一个实体时，自动删除与之相关联的其他实体。
在Hibernate中，级联删除可以通过设置关联关系的级联属性来实现。常见的关联关系有ManyToOne和OneToMany。
- ManyToOne关联关系：
- 概念：ManyToOne关联关系表示多个实体对象关联到一个实体对象。
- 优势：ManyToOne关联关系可以简化数据模型，提高查询效率。
- 应用场景：适用于多个实体对象关联到同一个实体对象的情况，例如，一个订单可以关联到一个客户。
- 推荐的腾讯云相关产品：腾讯云数据库MySQL，详情请参考腾讯云数据库MySQL。
- OneToMany关联关系：
- 概念：OneToMany关联关系表示一个实体对象关联到多个实体对象。
- 优势：OneToMany关联关系可以方便地管理多个实体对象之间的关系。
- 应用场景：适用于一个实体对象关联到多个实体对象的情况，例如，一个部门可以关联到多个员工。
- 推荐的腾讯云相关产品：腾讯云对象存储（COS），详情请参考腾讯云对象存储（COS）。
在Hibernate中，级联删除可以通过设置级联属性来实现。常见的级联属性有：
- CascadeType.ALL：表示所有操作都会级联执行，包括删除。
- CascadeType.PERSIST：表示只有持久化操作会级联执行，不包括删除。
- CascadeType.MERGE：表示只有合并操作会级联执行，不包括删除。
- CascadeType.REMOVE：表示只有删除操作会级联执行。
- CascadeType.REFRESH：表示只有刷新操作会级联执行。
- CascadeType.DETACH：表示只有分离操作会级联执行。
例如，如果一个实体A关联到多个实体B，且设置了级联删除属性为CascadeType.ALL，那么当删除实体A时，与之关联的所有实体B也会被自动删除。
总结：Hibernate级联删除相关实体是通过设置关联关系的级联属性来实现的，可以简化数据模型，方便管理实体对象之间的关系。在具体应用中，可以根据实际需求选择合适的级联属性。腾讯云提供了腾讯云数据库MySQL和腾讯云对象存储（COS）等产品，可以满足不同级联删除需求的场景。
相关·内容
我有两个实体，Menu和MenuItem，如下面的源代码所示。我试图从数据库中获取带有所有子实体的菜单，但Hibernate也在将MenuItem的子实体插入到Menu实体的nodes列表中。
Menu.java
[...]
@OneToMany(fetch = FetchType.EAGER, mappedBy = "menu", cascade = CascadeType.ALL, orphanRemoval = true)
@OrderBy("order ASC")
private List<MenuItem> nod
浏览 4提问于2020-05-26得票数 3
回答已采纳
Spring存储库保存()方法如果ID为null，则执行插入操作，否则它将执行Update操作。我有以下实体豆子-
Student {
@Id integer studentId;
....
@OneToMany Set<Project> projects;
@OneToMany Set<Subject> subjects;
}
Project {
@Id integer projectId;
....
@ManyToOne Student student;
}
Subject {
@Id integer subjectId;
....
@Man
浏览 1提问于2018-12-04得票数 2
回答已采纳
1回答
我有一个这样的实体关系：
在ParentObj类中：
@OneToMany(mappedBy = "parentObj", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
private List<ChildObj> list;
在ChildObj类中：
@JoinColumn(name="PARENT_OBJ")
@ManyToOne
private ParentObj parentObj;
当父对象持久化或删除时，子对象也会被持久化/删除。但当我尝
浏览 5提问于2016-06-08得票数 1
回答已采纳
1回答
我对manyToMany、oneToMany等实体之间的关系有些困惑。
我所困惑的是，如果我从数据库中删除或删除一条记录，我们又怎能说删除关系实体。
例如：
manyToMany
类别实体：
manyToMany:
posts:
targetEntity: PostEntity
mappedBy: taxonomies
设想一：
如果删除或删除这些类别之一，请立即删除post_taxonomy_relations表中的所有关系。我们能用什么来做这个？级联还是孤儿移除？
员额实体：
manyToMany:
taxonomies:
targetE
浏览 3提问于2015-09-15得票数 1
回答已采纳
我有以下实体
class A {
@OneToMany(cascade = ALL)
List<B> b;
@OneToMany(cascade = ALL)
List<C> c;
}
class B {
@ManyToOne
A a
}
class C {
@ManyToOne
A a;
@ManyToOne
B b;
}
现在，当我在事务中执行以下代码时
A a = repository.findOne(id);
B b = new B();
C c = new C();
c.set
浏览 1提问于2018-03-15得票数 1
回答已采纳
2回答
每当我试图删除/删除实体“候选人”时，我都会收到这个错误：
An exception occurred while executing 'DELETE FROM candidate WHERE id = ?' with params {"1":3}: SQLSTATE[23000]: Integrity constraint violation: 1451 Cannot delete or update a parent row: a foreign key constraint fails (`ima`.`result`, CONSTRAINT `result
浏览 2提问于2013-12-23得票数 1
回答已采纳
2回答
客户实体(父实体)
@Entity
public class Customer {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String name;
@OneToMany(mappedBy="customer", cascade=CascadeType.ALL)
private List<Facility> facilities;
//Setter and Getter for name and facilities
public void a
浏览 0提问于2010-08-05得票数 2
回答已采纳
1回答
当对订单(父级)执行删除时，hibernate试图级联删除这些子级。它不只是先删除子键，而是尝试删除外键，然后删除父键，然后删除子键。
是否有一种方法可以更改我的配置，允许先删除子级，然后删除父级？绕过取消外键的步骤？
表和相关列
阶
id，int，null
OrderResult
id，int，null order_id - FK，int，null
实体规范
阶
@OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
@JoinColumn(name = "CLOrderID")
public List<O
浏览 1提问于2012-05-15得票数 1
这可能看起来是一个非常简单的问题，但我已经纠结了一段时间了。我有两个实体Client和User，其中Client是User的父对象。这些实体的注释如下：
Client:
@OneToMany(mappedBy = "client", fetch = FetchType.LAZY)
@Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE})
private List<User> users = new ArrayList<User>();
User:
@ManyToOne
浏览 0提问于2010-09-24得票数 0
回答已采纳
1回答
在我的教义实体中，我有以下关系：
FavoriteRecipe
/**
* @ManyToOne(targetEntity="User", inversedBy="favoriteRecipes")
*/
private $user;
/**
* @ManyToOne(targetEntity="Recipe", inversedBy="favoriteRecipes")
*/
private $recipe;
配方
/**
* @OneToMany(targetEntity="FavoriteRecipe&#
浏览 3提问于2011-09-06得票数 8
回答已采纳
1回答
对于实体中的delete约束，我有一些问题。
我有一个实体商品和一个实体车辆，在商品中有一个多到一个的关系，所以一个商品只能在一辆车里，而一辆车可以有很多商品。所以我有：
class Merchandise{
/**
* @ORM\ManyToOne(targetEntity="Vehicle",inversedBy="merchandise")
* @ORM\JoinColumn(name="vehicle", referencedColumnName="id")
*/
private $v
浏览 3提问于2013-06-07得票数 2
我试图使用merge从父实体(而不是从DB删除引用)中删除一个子实体，我所做的是从父实体获取@OneToMany字段的集合，然后从集合中删除，最后使用merge，当我使用相同的方法但添加而不是删除时，实体如下：
@Entity
@Table(name="bills")
public class Bill {
@OneToMany(fetch=FetchType.EAGER,cascade=CascadeType.ALL,mappedBy="bill")
private Set<BillDetail> billDetails = ne
浏览 0提问于2015-02-12得票数 0
回答已采纳
3回答
我有两个这样的实体：
public class Client {
...
@OneToMany(mappedBy = "client", cascade = { CascadeType.DETACH, CascadeType.MERGE, CascadeType.REFRESH, CascadeType.REMOVE },orphanRemoval = true, fetch=FetchType.EAGER)
@Fetch(value = FetchMode.SUBSELECT)
@Cascade({ org.hibernate.annotations.CascadeTyp
浏览 4提问于2017-09-22得票数 5
回答已采纳
这就是问题所在。当我试图从数据库中删除Catalog对象时，Hibernate也会删除所有具有关联类型和类型Ids的Catalog对象。例如，如果我使用Type.id=1和Genre.id=1删除目录，Hibernate将删除具有此类if的所有目录。有什么办法解决吗？我只需要删除一个Catalog对象，而不需要使用id=1删除类型和类型对象。
@Entity
@Table(name = "catalog", catalog = "media_store_db")
public class Catalog implements Serializable {
浏览 1提问于2014-03-09得票数 0
回答已采纳
我的实体。ValidationStep与documentDetail是一对一的关系，而documentDetail与oneToMany的关系是documentValidations
ValidationStep
@Entity
public class ValidationStep {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@ManyToOne
@JoinColumn(name= "automation_information_aId", referencedColu
浏览 1提问于2019-10-21得票数 0
2回答
我正在尝试使用Symfony和Doctrine构建一个非常基本的CMS。我有实体模仿我网站的结构，如下所示：
实体:页面
/**
* @ORM\Entity(repositoryClass="App\Repository\ContentTree\PageRepository")
*/
class Page extends SortableBase
{
/**
* @ORM\Id()
* @ORM\GeneratedValue()
* @ORM\Column(type="integer")
* @ORM\Orde
浏览 3提问于2020-03-07得票数 1
回答已采纳
3回答
我有两个实体Order和Item，它们的关系是1:N，Order是父表，item是子表。当我删除订单时，我希望相应的项目也被删除。但这并没有发生，而是将子表中的OrderId设置为"null“。这是在Item表的数据库中创建孤立行。
这是我的配置:我使用Spring，Hibernate作为JPAVendor和mysql数据库
@Entity
@Table(name="T_ORDER")
public class Order {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private L
浏览 11提问于2012-12-14得票数 0
回答已采纳
这是我的数据模型(简化)，
public class AddressBook {
private List<Group> groups = new ArrayList<Group>();
private List<People> peoples = new ArrayList<People>();
@OneToMany(mappedBy = "addressbook", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@OnDelete(act
浏览 0提问于2009-06-04得票数 4
回答已采纳
我有两个名为Customer和Activity的实体类。
Customer有customerId，customerName，activities这里，activities持有的Activity集合对应于由@OneToMany(mappedBy = "customer")关系映射的每个Customer。
Customer类的定义如下(为了清晰起见，我删除了其他字段和一些getter和setter )：
@javax.persistence.Entity
@Table(name = "CUSTOMER")
public class Customer extends
浏览 3提问于2013-02-01得票数 2
回答已采纳
2回答
我们正在使用带有Hibernate 5.x的Spring数据存储库
我们有一个层次很深的实体图。映射如下：
@Entity
public class FooBar {
@OneToMany(mappedBy = "fooBar", cascade = CascadeType.ALL, orphanRemoval = true)
private Set<Foo> chassis = new HashSet<>(0);
...
}
@Entity
public class Foo {
@ManyToOne(fetch =
浏览 1提问于2018-09-12得票数 4
回答已采纳
1回答
我对Hibernate还不熟悉。我读到过，当使用cascade.ALL持久化时，更改是从拥有方传播的。我有下面的例子，我正在保存非拥有实体，并且拥有实体也被保存。 类帐户{ @OneToMany(mappedBy="account" , cascade=CascadeType.ALL)
List<Transaction> list= new ArrayList<Transaction>(); } 类事务{ @ManyToOne
@JoinColumn(name="account_id")
Account account; } Accou
浏览 15提问于2019-02-23得票数 0
回答已采纳
我有两个实体如下：
网站
帖子
在网站实体中，我给出了OneToMany关系，在posts实体中，我给出了ManytoOne关系。
网站实体：-
/**
* @var Collection<Post>
*
* @ORM\OneToMany(targetEntity="App\Domain\Entity\Post\Post", mappedBy="website", cascade={"all"})
*/
private Collection $posts;
职位实体：-
/**
* @ORM\ManyToO
浏览 2提问于2021-07-27得票数 0
回答已采纳
我有两个实体：
@Entity
@Table(name="\"Group\"")
public class Group implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="id")
private long id;
@NotNull
@ManyToOne(cascade=CascadeType.REMOVE, fetch=FetchType.EAGER)
浏览 3提问于2017-06-09得票数 2
回答已采纳
我在Hibernate实体中有这个映射。
A.java
@OneToMany(mappedBy = "a", cascade = CascadeType.ALL)
Set<B> bs;
B.java
@ManyToOne(cascade = CascadeType.ALL)
@JoinColumn(name = "A_ID")
A a;
我需要对A进行编辑。
因此，在将实体加载到带有Spring @Transactional注释的方法中之后
A a = entityManager.find(A.class, a.getId);
// set some
浏览 0提问于2018-06-26得票数 0
回答已采纳
我有以下两个实体：
1-交易
@OneToMany(cascade=CascadeType.ALL,mappedBy = "deal", fetch = FetchType.EAGER)
@Fetch( FetchMode.SELECT)
private List<DealCheckList> dealCheckList;
2- DealCheckList
@JoinColumn(name = "DEAL_ID", referencedColumnName = "DEAL_ID", insertable = false, updata
浏览 7提问于2012-09-25得票数 2
1回答
我有两门课：
父级
孩子
在数据库中，子表中有一个列ParentId ->典型的一个(父) ->多(子)关系
现在我创建了两个实体
public class Parent
{
@OneToMany(mappedBy="Parent", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
public Set<Child> getChildern()
{
...
}
}
public class Child
{
@ManyToOne(fe
浏览 5提问于2014-02-02得票数 2
回答已采纳
我有3个实体，Party将oneToMany映射为Invitation，后者映射为带有Guest的manyToOne。“联合行动纲领”的定义如下：
党级
@OneToMany(mappedBy="party", targetEntity=com.acme.party.model.Invitation.class)
@org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.LOCK})
@
浏览 4提问于2015-07-16得票数 2
回答已采纳
2回答
我有个问题
在使用Hibernate的Java Web项目中，我有一个具有@OneToMany关系的实体
当我部署站点时，@OneToMany关系可以正常工作
保存后，所有内容都正确地保存在数据库中，但此新记录的@OneToMany返回null
如果我再次进行部署，则@OneToMany可以工作
我的儿科课程
@Entity
@Table(name = "pedido")
@NamedQueries({
@NamedQuery(name = "pedido.findAll", query = "SELECT p FROM Pedido p"
浏览 23提问于2021-05-28得票数 0
2回答
对于下面的批处理插入方法，我得到这个异常“传递到持久的独立实体”。你能看看这个方法并给我一些提示吗？
非常感谢。
如果需要，我将在这里提供实体，目前我将提供关键字实体：
public class Keyword implements Serializable {
private static final long serialVersionUID = -1429681347817644570L;
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="key_id
浏览 8提问于2015-07-12得票数 2
回答已采纳
1回答
我对Hibernate有意见。
简言之：
如何在关系具有属性且需要级联保存、删除和更新的情况下配置Hibernate的ManyToMany关联？
大范围：
想象一下下面的DataBase：
Super Mini
M______N
|
attribute
这里有三张桌子：
"Mini", "Super" and "Super_Mini".
现在假设Super_Mini有关系的一个属性(很明显还有键
浏览 1提问于2011-12-16得票数 2
回答已采纳
我有以下hibernate实体：
@Entity
@Table(name = "model_view")
public class ModelView {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "modelView_id")
private Integer id;
@ManyToOne
@NotNull
@JoinColumn(name = "page_id", nullable = false
浏览 0提问于2013-06-12得票数 19
回答已采纳
网上有很多关于这个例外的问题和答案，但没有一个能解决我的问题。我有两个非常简单的实体-一个是类别，另一个是项目。类别与项目有一对多的关系。我对insert语句没有任何问题。但当我尝试删除类别时，hibernate抛出"org.hibernate.exception.ConstraintViolationException:无法执行语句“exception”，因为外键约束("com.microsoft.sqlserver.jdbc.SQLServerException：，delete语句与引用约束"FK_CATEGORY“冲突，冲突发生在数据库"shop”、表&#
浏览 0提问于2019-11-23得票数 0
回答已采纳
我正在尝试理解选项在Doctrine in Symfony2中。
我希望能够删除一个子实体(而不是触发外键约束错误)。
我有三个实体：
Report
/**
* @ORM\OneToMany(targetEntity="Response", mappedBy="report")
*/
protected $responses;
/**
* @ORM\OneToMany(targetEntity="Response", mappedBy="report")
*/
protected $sms;
响应
/**
* @ORM\Man
浏览 5提问于2012-11-14得票数 16
回答已采纳
我在实体Foo上的缓存使用情况如下所示
@Entity
class Foo {
@ManyToOne(fetch = LAZY)
@Cache(usage = org.hibernate.annotations.CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
private Boo boo;
@OneToMany
@Cache(usage = org.hibernate.annotations.CacheConcurrencyStrategy.READ_WRITE)
private List<
浏览 1提问于2011-06-23得票数 4
在实体hibernate.In中使用了@Cascade(CascadeType.DELETE) @ManyToOne注释，我在实体class.But中找到了另一个注释@ManyToOne(cascade=CascadeType.DELETE，fetch = FetchType.LAZY)。这两种annotations.If有什么区别吗?有什么区别，请解释一下。
浏览 5提问于2016-01-05得票数 0
回答已采纳
我有以下实体模型。 @Entity
@Table(name="product")
public class ProductEntity {
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "uuid2")
private UUID id;
...
@OneToMany(mappedBy = "productEntity&#
浏览 19提问于2019-03-10得票数 1
1回答
我有两个EJB 3实体Beans：
@Entity
public class Organisation
{
@Id
@Column(length = 64)
private String guid;
private String name;
@ManyToOne(fetch = FetchType.LAZY, cascade = CascadeType.REMOVE)
@JoinColumn(name = "home_unit_fk", nullable = true)
private Unit homeUnit;
浏览 1提问于2009-04-30得票数 1
回答已采纳
假设我们有两个实体(Profile和Address)。配置文件可以有多个地址。在这种情况下，我们有：
Profile:
...
fields:
...
oneToMany:
addresses:
targetEntity: Address
mappedBy: profile
orphanRemoval: true
Address:
...
fields:
...
manyToOne:
p
浏览 8提问于2015-04-18得票数 8
回答已采纳
一个实体项目可以有多个人员、多个查皮特、每个项目一个highConcept。而且用户可以有很多项目。然后，当我想要删除一个项目时，我会收到以下错误消息：
在执行“从id =？的项目中删除”时发生了异常。与params 2：
SQLSTATE23000:完整性约束违反:1451年不能删除或更新父行:外键约束失败(writtle.personnages，constraint FK_286738A6C18272 foreign (projet_id) REFERENCES projets (id))
这是我的实体：
人事实体
/**
* @ORM\ManyToMany(target
浏览 3提问于2019-12-06得票数 0
回答已采纳
1回答
正在删除父项和所有子项
、、、、
从数据库中删除父实体时出现问题。代码如下所示：
public class Parent implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.TABLE)
private Long id;
@Cascade(org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinColumn(name=
浏览 1提问于2010-06-30得票数 3
回答已采纳
1回答
在hibernate/JPA中的双向关系中，哪个实体(或两者都有？)您是否指定了fetch模式和级联类型？举个例子：
@Entity
@Table(name="EMPLOYER")
public Employer implements Serializable
{
@OneToMany(mappedBy="employer")
private Set<Employee> employees;
}
@Entity
@Table(name="EMPLOYEE")
public Employee implements
浏览 3提问于2014-05-07得票数 0
2回答
我正在处理hibernate JPA注释中的onetomany关系，下面是我的表和实体类的详细信息.
Service (entity class: ServiceRegistration.java)
=======
serviceid
servicename
channel meta table (entity class: Channels.java)
========
channelid
channelname
service_channel (entity class: ServiceChannels.java)
===============
seq_id
servi
浏览 9提问于2011-10-10得票数 0
更新Crypto时不需要更新值，但删除Crypto时需要删除所有子值：
class Crypto {
...
@OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
@JoinColumn(name="cryptoId", updatable=false)
private Set<Values> values;
...
}
class Values {
...
@ManyToOne
@JoinColumn(name = "cryptoId")
浏览 3提问于2014-12-27得票数 1
1回答
在Hibernate实体中的Cascade关联的两边使用ManyToOne是否合适？为了使我的问题更加具体，让我们假设某人有以下相关实体：
public class Department
{
public long id;
@OneToMany(mappedBy = "department", cascade=cascadeType.REMOVE)
private Set<Employee> employees;
}
public class Employee{
@GeneratedValue(st
浏览 1提问于2013-05-19得票数 3
回答已采纳
1回答
我在从数据库中删除实体时遇到了问题。不管我做什么它都不会删除。
驱动程序类
@Entity
@Table(name = "drivers")
public class Driver {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@OneToMany(mappedBy = "driver", fetch = FetchType.EAGER)
@JsonSerialize(using = RatingsSerialize
浏览 0提问于2017-09-13得票数 1
回答已采纳
1回答
异步更新子带已删除的父级返回
、、、、
我有一个简单的Spring服务，它使用JPA和Hibernate实现存储库模式。
当我删除父实体时，如果@异步方法仍在其子实体上进行，则父实体将被@异步方法的末尾复制。
假设我有一个父实体：
@Entity
public class Parent {
... // fields like id etc.
@JsonManagedReference
@OneToMany(mappedBy = "parent", fetch = FetchType.EAGER, cascade = { CascadeType.ALL }
浏览 3提问于2021-02-23得票数 1
回答已采纳
2回答
我想在这个上下文中创建一个应用程序: Zk 6、Springv3.1.1、JPA2.0、Hibernate 4.1.4，所有这些都带有注释，但我有一些带有JPA概念的pb。
以下是一种案例研究：
3表，所有这些表都通过一个连接表链接；我们处理的是基数0，n。
所以我们有T_E_USER，T_E_TYPE和T_E_AIR。每个表都有一个数字ID和一个简单的VARCHAR字段。
使用T_J_USR_TPE_AIR创建一个连接表，外键引用的3个ID构成一个组合主键。
我使用Hibernate工具来生成我的实体(JPA版本)。这就是问题的源头..。
在每个实体类中，我都有一个类型为se
浏览 0提问于2012-08-06得票数 1
回答已采纳
我对@OneToMany和@ManyToOne注解有一些问题。
我有两套套房和SuiteVersion。SuiteVersion依赖于一个套件。因此，我已经在我的代码中实现了这一点：
班级套房：
@OneToMany(mappedBy = "suite")
@Cascade(CascadeType.DELETE_ORPHAN)
private List<SuiteVersion> listSuiteVersion = new ArrayList<SuiteVersion>();
SuiteVersion类：
@ManyToOne()
@Cascade({
浏览 1提问于2010-08-13得票数 3
回答已采纳
因此，我有一些实体被用作坐标系的基础，在本文中，我们将它们称为A，B，C和D。这些实体中的每一个都有多个@OneToMany关系，我想级联删除。即，当一些A被删除时，每个@OneToMany关系中的所有实体也被删除。相当标准的东西。
然而，我看不出让这些实体显式地跟踪这些关系的意义，而我所要做的就是级联删除。我看不出加载所有这些实体(可能有数百万！)每次将新实体添加到@OneToMany关系中(即，使用延迟加载仅在访问它时加载，但当然是在关系中添加新实体时访问它)。
让我们添加一个小示例：
@Entity
public class A {
@Id
private long id
浏览 2提问于2014-07-24得票数 0
我正在使用Hibernate，我有这两个类。
public class ApplicantYear{
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "APPLICANT_ID")
private Applicant applicant;
.
.
.
}
public class Applicant {
@OneToMany(mappedBy = "applicant", fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, Cascade
浏览 1提问于2012-05-30得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
