对于Kotlin开发者:为了允许Hibernate继承你想要惰性加载的@Entity类型，它们必须是可继承/开放的，而在Kotlin中它们默认不是这样的。为了解决这个问题，我们可以使用完全开放的编译器插件，并通过添加到我们的build.gradle来指导它处理JPA注释:

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

如果你像我一样使用Kotlin和Spring，你很可能也在使用Kotlin -jpa/no-args和Kotlin - Spring /all-open编译器插件。但是，您仍然需要添加上面的代码行，因为插件的组合不会打开这样的类。

阅读Léo Millon的文章，了解更多的解释。

As already perfectly explained by ChssPly76, Hibernate's proxies don't help with unconstrained (nullable) one-to-one associations, BUT there is a trick explained here to avoid to set up instrumentation. The idea is to fool Hibernate that the entity class which we want to use has been already instrumented: you instrument it manually in the source code. It's easy! I've implemented it with CGLib as bytecode provider and it works (ensure that you configure lazy="no-proxy" and fetch="select", not "join", in your HBM).

我认为这是真正的(我是说自动的)插装的一个很好的替代方案，当您只有一个一对一的可空关系时，您想让它变得懒惰。主要的缺点是这个解决方案依赖于你正在使用的字节码提供程序，所以准确地注释你的类，因为你将来可能不得不改变字节码提供程序;当然，您还因为技术原因修改了您的模型bean，这是不好的。

除非您正在使用字节码增强，否则您不能惰性地获取父端@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()
);

这样，您就不会有N+1个查询问题，这可能是由父端mappedBy @OneToOne关联引起的。

在原生Hibernate XML映射中，可以通过将受约束的属性设置为true来声明一个一对一的映射来实现这一点。我不确定Hibernate/JPA注释等价于它是什么，快速搜索文档也没有提供答案，但希望这能给您一个线索。

为了让惰性加载工作在可为空的一对一映射上，您需要让hibernate进行编译时插装，并向一对一关系添加@LazyToOne(value = LazyToOneOption.NO_PROXY)。

示例映射:

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

示例Ant构建文件扩展名(用于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>

如果子实体是只读的，那么可以简单地设置optional=false。 然后确保每个映射实体的使用都是通过查询预加载的。

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

and

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

．.． 也许坚持也会有用……