Hibernate关联关系映射
本文参考
Hibernate关联关系映射--级联功能
Hibernate作为持久层框架,初始实现最基本的ORM之外,最重要的就是关系关联映射。通过配置实体间的关联,如one-to-one、one-to-many等,可以实现级联保存,级联更新,级联查询,级联删除等级联操作。在建关联关系表的时候,可以通过设置@OneToOne,@@OneToMany,@@ManyToOne,@ManyToMany的cascade()属性值,来设置关系表之间的级联功能。举例如下
没有仔细研究过Hinbernate的级联(cascade)与反转(inverse),有一篇文章请参考Hibernate级联(cascade)与反转(inverse)详解
- ALL
- PERSIST 新增时,可以参考 spring jpa 如何给外键赋值
- MERGE
- REMOVE
- REFRESH
- DETACH
ClassEntity表
import java.util.List; import javax.persistence.CascadeType; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.OneToMany; import javax.persistence.Table; import lombok.Data; @Data @Entity @Table(name = "tb_class") public class ClassEntity { @Id private String id; @Column private String name; @OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH }) private List<Student> students; }
Hibernate的级联并不好用,而且它实现的功能我们完全可以程序里面自己控制:插入的时候,先插入父表再插入子表;删除的时候,先删除子表再删除父表。而且在代码中控制,语义更明显,效率上和hibernate也没有差异,而且实现难度也比配置级联更容易。如果使用了Hibernate作为持久层框架,又不想使用Hibernate的级联,Hibernate默认级联关系就是none,不设置就好了。
/* * Copyright (c) 2008, 2019 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v. 2.0 which is available at * http://www.eclipse.org/legal/epl-2.0, * or the Eclipse Distribution License v. 1.0 which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ // Contributors: // Linda DeMichiel - 2.1 // Linda DeMichiel - 2.0 package javax.persistence; import java.lang.annotation.Target; import java.lang.annotation.Retention; import javax.persistence.CascadeType; import static java.lang.annotation.ElementType.FIELD; import static java.lang.annotation.ElementType.METHOD; import static java.lang.annotation.RetentionPolicy.RUNTIME; import static javax.persistence.FetchType.EAGER; /** * Specifies a single-valued association to another entity class that * has many-to-one multiplicity. It is not normally necessary to * specify the target entity explicitly since it can usually be * inferred from the type of the object being referenced. If the * relationship is bidirectional, the non-owning * <code>OneToMany</code> entity side must used the * <code>mappedBy</code> element to specify the relationship field or * property of the entity that is the owner of the relationship. * * <p> The <code>ManyToOne</code> annotation may be used within an * embeddable class to specify a relationship from the embeddable * class to an entity class. If the relationship is bidirectional, the * non-owning <code>OneToMany</code> entity side must use the <code>mappedBy</code> * element of the <code>OneToMany</code> annotation to specify the * relationship field or property of the embeddable field or property * on the owning side of the relationship. The dot (".") notation * syntax must be used in the <code>mappedBy</code> element to indicate the * relationship attribute within the embedded attribute. The value of * each identifier used with the dot notation is the name of the * respective embedded field or property. * <pre> * * Example 1: * * @ManyToOne(optional=false) * @JoinColumn(name="CUST_ID", nullable=false, updatable=false) * public Customer getCustomer() { return customer; } * * * Example 2: * * @Entity * public class Employee { * @Id int id; * @Embedded JobInfo jobInfo; * ... * } * * @Embeddable * public class JobInfo { * String jobDescription; * @ManyToOne ProgramManager pm; // Bidirectional * } * * @Entity * public class ProgramManager { * @Id int id; * @OneToMany(mappedBy="jobInfo.pm") * Collection<Employee> manages; * } * * </pre> * * @since 1.0 */ @Target({METHOD, FIELD}) @Retention(RUNTIME) public @interface ManyToOne { /** * (Optional) The entity class that is the target of * the association. * * <p> Defaults to the type of the field or property * that stores the association. */ Class targetEntity() default void.class; /** * (Optional) The operations that must be cascaded to * the target of the association. * * <p> By default no operations are cascaded. */ CascadeType[] cascade() default {}; /** * (Optional) Whether the association should be lazily * loaded or must be eagerly fetched. The EAGER * strategy is a requirement on the persistence provider runtime that * the associated entity must be eagerly fetched. The LAZY * strategy is a hint to the persistence provider runtime. */ FetchType fetch() default EAGER; /** * (Optional) Whether the association is optional. If set * to false then a non-null relationship must always exist. */ boolean optional() default true; }