java - 如何使 JPA OneToOne 关系变得懒惰

Question

在我们正在开发的这个应用程序中，我们注意到视图特别慢。我对视图进行了分析，并注意到休眠执行了一个查询，即使数据库中只有两个对象要获取，它也需要 10 秒。所有OneToMany和ManyToMany关系都很懒惰，所以这不是问题。在检查正在执行的实际 SQL 时，我注意到查询中有超过 80 个连接。

进一步检查该问题，我注意到该问题是由实体类的深层层次结构OneToOne和ManyToOne关系引起的。所以，我想，我会让他们偷懒，这应该可以解决问题。但是注释@OneToOne(fetch=FetchType.LAZY)或注释@ManyToOne(fetch=FetchType.LAZY)似乎不起作用。要么我得到一个异常，要么它们实际上并没有被代理对象替换，因此变得懒惰。

任何想法我将如何让它工作？请注意，我不使用persistence.xml来定义关系或配置细节，一切都是在 java 代码中完成的。

score 235 · Accepted Answer

首先，对KLE的回答进行一些澄清：

不受约束（可为空）的一对一关联是唯一一个在没有字节码检测的情况下无法代理的关联。这样做的原因是所有者实体必须知道关联属性是否应该包含代理对象或 NULL，并且由于通常通过共享 PK 进行一对一映射，因此它无法通过查看其基表的列来确定这一点，因此它无论如何都必须急切地获取代理，这使代理毫无意义。这里有更详细的解释。
多对一关联（显然是一对多）不会受到这个问题的影响。Owner 实体可以很容易地检查自己的 FK（如果是一对多，最初创建空集合代理并按需填充），因此关联可以是惰性的。
用一对多代替一对一几乎不是一个好主意。您可以用独特的多对一替换它，但还有其他（可能更好）选项。

Rob H.有一个有效的观点，但是您可能无法根据您的模型实现它（例如，如果您的一对一关联可以为空）。

现在，就原始问题而言：

A）@ManyToOne(fetch=FetchType.LAZY)应该工作得很好。您确定它没有在查询本身中被覆盖吗？可以join fetch在 HQL 中指定和/或通过 Criteria API 显式设置获取模式，这将优先于类注释。如果情况并非如此，并且您仍然遇到问题，请发布您的课程、查询和生成的 SQL，以便进行更深入的对话。

B)@OneToOne更棘手。如果它绝对不可为空，请按照 Rob H. 的建议进行指定，如下所示：

@OneToOne(optional = false, fetch = FetchType.LAZY)

否则，如果您可以更改数据库（将外键列添加到所有者表），请执行此操作并将其映射为“已加入”：

@OneToOne(fetch = FetchType.LAZY)
@JoinColumn(name="other_entity_fk")
public OtherEntity getOther()

在其他实体中：

@OneToOne(mappedBy = "other")
public OwnerEntity getOwner()

如果你不能这样做（并且不能忍受急切的获取）字节码检测是你唯一的选择。但是，我必须同意CPerkins的观点——如果你有80 个！！！由于急切的 OneToOne 协会而加入，那么您将遇到更大的问题 :-)

score 22 · Accepted Answer

要在可空的一对一映射上进行延迟加载，您需要让 hibernate 进行编译时检测并将 a 添加@LazyToOne(value = LazyToOneOption.NO_PROXY)到一对一关系中。

示例映射：

@OneToOne(fetch = FetchType.LAZY)  
@JoinColumn(name="other_entity_fk")
@LazyToOne(value = LazyToOneOption.NO_PROXY)
public OtherEntity getOther()

示例 Ant Build 文件扩展名（用于执行 Hibernate 编译时检测）：

<property name="src" value="/your/src/directory"/><!-- path of the source files --> 
<property name="libs" value="/your/libs/directory"/><!-- path of your libraries --> 
<property name="destination" value="/your/build/directory"/><!-- path of your build directory --> 

<fileset id="applibs" dir="${libs}"> 
  <include name="hibernate3.jar" /> 
  <!-- include any other libraries you'll need here --> 
</fileset> 

<target name="compile"> 
  <javac srcdir="${src}" destdir="${destination}" debug="yes"> 
    <classpath> 
      <fileset refid="applibs"/> 
    </classpath> 
  </javac> 
</target> 

<target name="instrument" depends="compile"> 
  <taskdef name="instrument" classname="org.hibernate.tool.instrument.javassist.InstrumentTask"> 
    <classpath> 
      <fileset refid="applibs"/> 
    </classpath> 
  </taskdef> 

  <instrument verbose="true"> 
    <fileset dir="${destination}"> 
      <!-- substitute the package where you keep your domain objs --> 
      <include name="/com/mycompany/domainobjects/*.class"/> 
    </fileset> 
  </instrument> 
</target>

score 16 · Accepted Answer

除非您使用字节码增强，否则您不能延迟获取父端@OneToOne关联。

但是，大多数情况下，如果您在客户端使用，您甚至不需要父端关联@MapsId：

@Entity(name = "PostDetails")
@Table(name = "post_details")
public class PostDetails {
 
    @Id
    private Long id;
 
    @Column(name = "created_on")
    private Date createdOn;
 
    @Column(name = "created_by")
    private String createdBy;
 
    @OneToOne(fetch = FetchType.LAZY)
    @MapsId
    private Post post;
 
    public PostDetails() {}
 
    public PostDetails(String createdBy) {
        createdOn = new Date();
        this.createdBy = createdBy;
    }
 
    //Getters and setters omitted for brevity
}

使用@MapsId，id子表中的属性同时作为父表主键的主键和外键。

因此，如果您有对父Post实体的引用，您可以使用父实体标识符轻松获取子实体：

PostDetails details = entityManager.find(
    PostDetails.class,
    post.getId()
);

这样，您将不会遇到可能由mappedBy @OneToOne父端关联引起的 N+1 查询问题。

score 14 · Accepted Answer

这是对我有用的东西（没有仪器）：

我不是@OneToOne在两边都使用，而是@OneToMany在关系的反部分（带的那个mappedBy）中使用。这使得该属性成为一个集合（List在下面的示例中），但我将它转换为 getter 中的一个项目，使其对客户端透明。

这种设置是惰性的，也就是说，选择只在getPrevious()或被getNext()调用时进行 - 每次调用只有一个选择。

表结构：

CREATE TABLE `TB_ISSUE` (
    `ID`            INT(9) NOT NULL AUTO_INCREMENT,
    `NAME`          VARCHAR(255) NULL,
    `PREVIOUS`      DECIMAL(9,2) NULL
    CONSTRAINT `PK_ISSUE` PRIMARY KEY (`ID`)
);
ALTER TABLE `TB_ISSUE` ADD CONSTRAINT `FK_ISSUE_ISSUE_PREVIOUS`
                 FOREIGN KEY (`PREVIOUS`) REFERENCES `TB_ISSUE` (`ID`);

班上：

@Entity
@Table(name = "TB_ISSUE") 
public class Issue {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    protected Integer id;

    @Column
    private String name;

    @OneToOne(fetch=FetchType.LAZY)  // one to one, as expected
    @JoinColumn(name="previous")
    private Issue previous;

    // use @OneToMany instead of @OneToOne to "fake" the lazy loading
    @OneToMany(mappedBy="previous", fetch=FetchType.LAZY)
    // notice the type isnt Issue, but a collection (that will have 0 or 1 items)
    private List<Issue> next;

    public Integer getId() { return id; }
    public String getName() { return name; }

    public Issue getPrevious() { return previous; }
    // in the getter, transform the collection into an Issue for the clients
    public Issue getNext() { return next.isEmpty() ? null : next.get(0); }

}

score 13 · Accepted Answer

Hibernate 中 XToOne 的基本思想是它们在大多数情况下并不懒惰。

一个原因是，当 Hibernate 必须决定放置一个代理（带有 id）或 null 时，
它必须查看另一个表才能加入。访问数据库中另一个表的成本很高，因此它还不如在那个时刻获取该表的数据（非惰性行为），而不是在以后需要第二次访问该表的请求中获取该数据。同一张桌子。

已编辑：有关详细信息，请参阅 ChssPly76 的答案。这个不太准确和详细，它没有什么可提供的。感谢 ChssPly76。

score 6 · Accepted Answer

在本机 Hibernate XML 映射中，您可以通过将constrained属性设置为 true来声明一对一映射来完成此操作。我不确定 Hibernate/JPA 注释的等价物是什么，并且快速搜索文档没有提供任何答案，但希望这可以让您继续前进。

score 3 · Accepted Answer

正如 ChssPly76 已经完美解释的那样，Hibernate 的代理对无约束（可为空）的一对一关联没有帮助，但是这里解释了一个技巧，以避免设置检测。这个想法是为了欺骗 Hibernate，我们想要使用的实体类已经被检测了：你在源代码中手动检测它。这简单！我已经使用 CGLib 作为字节码提供程序来实现它并且它可以工作（确保您在 HBM 中配置了lazy="no-proxy" 和 fetch="select"，而不是“join”）。

我认为这是一个很好的替代真正的（我的意思是自动的）插桩，当你只有一个一对一的可空关系你想让它变得懒惰时。主要缺点是解决方案取决于您使用的字节码提供程序，因此请准确注释您的类，因为您将来可能必须更改字节码提供程序；当然，出于技术原因，您也在修改您的模型 bean，这并不好。

score 3 · Accepted Answer

这个问题很老了，但是在 Hibernate 5.1.10 中，有一些新的更好的解决方案。

除了 @OneToOne 关联的父方之外，延迟加载有效。这是因为 Hibernate 没有其他方法可以知道是否将 null 或 Proxy 分配给此变量。您可以在本文中找到更多详细信息

您可以激活延迟加载字节码增强功能
或者，您可以删除父端并使用带有@MapsId 的客户端，如上文所述。这样，您会发现您实际上并不需要父方，因为子级与父级共享相同的 id，因此您可以通过知道父级 id 轻松获取子级。

score 1 · Accepted Answer

一对一关联的最有效映射您可以通过对两个关联实体使用相同的主键值来避免所有这些问题并摆脱外键列。您可以通过使用 @MapsId 注释关联的拥有方来做到这一点。

@Entity
public class Book {
 
    @Id
    @GeneratedValue
    private Long id;
 
    @OneToOne(mappedBy = "book", fetch = FetchType.LAZY, optional = false)
    private Manuscript manuscript;
 
    ...
}


@Entity
public class Manuscript {
 
    @Id
    private Long id;
 
    @OneToOne
    @MapsId
    @JoinColumn(name = "id")
    private Book book;
 
    ...
}


Book b = em.find(Book.class, 100L);
Manuscript m = em.find(Manuscript.class, b.getId());

更多详情请点击此网址

score 1 · Accepted Answer

对于 Kotlin 开发人员：为了允许 Hibernate 从您想要延迟加载的 @Entity 类型继承，它们必须是可继承的/ open，而在 Kotlin 中默认情况下它们不是。为了解决这个问题，我们可以使用all-open编译器插件，并通过将其添加到我们的build.gradle:

allOpen {
   annotation("javax.persistence.Entity")
   annotation("javax.persistence.MappedSuperclass")
   annotation("javax.persistence.Embeddable")
}

如果您像我一样使用 Kotlin 和 Spring，那么您很可能已经在使用kotlin-jpa/no-args和kotlin-spring/all-open编译器插件。但是，您仍然需要添加上述几行，因为插件组合既不会生成此类open。

阅读Léo Millon 的精彩文章以获得进一步的解释。

score 0 · Accepted Answer

如果关系不能是双向的，那么 @ElementCollection 可能比使用惰性 One2Many 集合更容易。

score 0 · Accepted Answer

如果子实体以只读方式使用，则可以简单地lie和 set optional=false。然后确保通过查询预加载该映射实体的每次使用。

public class App {
  ...
  @OneToOne(mappedBy = "app", fetch = FetchType.LAZY, optional = false)
  private Attributes additional;

和

String sql = " ... FROM App a LEFT JOIN FETCH a.additional aa ...";

......也许即使坚持也会奏效......

java - 如何使 JPA OneToOne 关系变得懒惰

12 回答 12

表结构：

班上：

Related

Reference