在本文中，我们将为您详细介绍休眠：一对一延迟加载，可选=false的相关知识，并且为您解答关于休眠延迟15秒的疑问，此外，我们还会提供一些关于AngularLazyload(延迟加载，惰性加载)机制和

在本文中，我们将为您详细介绍休眠：一对一延迟加载，可选= false的相关知识，并且为您解答关于休眠延迟15秒的疑问，此外，我们还会提供一些关于Angular Lazy load (延迟加载，惰性加载) 机制和 feature module 的学习笔记、angular – 如何在延迟加载的模块中提供服务,并将该服务限定为延迟加载的模块及其组件？、entity-framework – 实体框架中的延迟加载,延迟加载和Eager加载、Hibernate延迟加载以实现一对一的反向解决方法-这项工作如何进行？的有用信息。

• 休眠：一对一延迟加载，可选= false（休眠延迟15秒）
• Angular Lazy load (延迟加载，惰性加载) 机制和 feature module 的学习笔记
• angular – 如何在延迟加载的模块中提供服务,并将该服务限定为延迟加载的模块及其组件？
• entity-framework – 实体框架中的延迟加载,延迟加载和Eager加载
• Hibernate延迟加载以实现一对一的反向解决方法-这项工作如何进行？

休眠：一对一延迟加载，可选= false（休眠延迟15秒）

我遇到了 一个 问题，即 一对一的延迟加载 在hibernate状态下不起作用。我 已经解决了它 ，但仍然 无法 正确 理解
会发生什么。

我的代码（ 延迟加载在这里不起作用 ，当我拉人时-地址也被获取）：

@Entitypublic class Person{  @Id  @SequenceGenerator(name = "person_sequence", sequenceName = "sq_person")  @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "person_sequence")  @Column(name = "id")  private long personID;  @OneToOne(mappedBy="person", cascade=CascadeType.ALL, fetch = FetchType.LAZY)  private Adress address;  //.. getters, setters}@Entitypublic class Address {  @Id  @Column(name="id", unique=true, nullable=false)  @GeneratedValue(generator="gen")  @GenericGenerator(name="gen", strategy="foreign", parameters=@Parameter(name="property", value="person"))  private long personID;  @PrimaryKeyJoinColumn  @OneToOne  private FileInfo person;}

但是 ：如果我添加 optional=false OneToOne关系，则延迟加载 效果很好 ！

@OneToOne(mappedBy="person", cascade=CascadeType.ALL, optional = false, fetch = FetchType.LAZY)private Adress address;

问题/完整性： 请向我解释optional=false注释如何帮助实现延迟加载。

PS 我已经阅读了post1和post2的帖子，并了解了为什么简单的OneToOne不能偷懒，但是我仍然无法掌握optional=false魔术。

答案1

如果关联是可选的，则Hibernate无法在不发出查询的情况下知道给定人员的地址是否存在。因此，它不能使用代理填充地址字段，因为可能没有引用该人的地址，并且不能填充null，因为可能存在引用该人的地址。

当您使关联成为强制性（即optional=false）时，它会信任您并假定一个地址存在，因为关联是强制性的。因此，在知道有引用该人的地址的情况下，它直接用代理填充地址字段。

Angular Lazy load (延迟加载，惰性加载) 机制和 feature module 的学习笔记

const routes: Routes = [
  {
    path: ''items'',
    loadChildren: () => import(''./items/items.module'').then(m => m.ItemsModule)
  }
];

const routes: Routes = [
  {
    path: '''',
    component: ItemsComponent
  }
];

import { NgModule } from ''@angular/core'';
import { CommonModule } from ''@angular/common'';

@NgModule({
  imports: [
    CommonModule
  ],
  declarations: []
})
export class CustomerDashboardModule { }

<p>
  customer-dashboard works!
</p>

本文同步分享在 博客 “汪子熙”（CSDN）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与 “OSC 源创计划”，欢迎正在阅读的你也加入，一起分享。

angular – 如何在延迟加载的模块中提供服务,并将该服务限定为延迟加载的模块及其组件？

import { CommonModule } from '@angular/common';
import { NgModule } from '@angular/core';
import { Component1 } from './component1.component';
import { Component2 } from './component2.component';
import { LazyModuleService } from './lazy-module.service';

@NgModule({
  imports: [
    CommonModule,],declarations: [
    Component1,Component2,})

export class LazyLoadedModule { }

entity-framework – 实体框架中的延迟加载,延迟加载和Eager加载

解决方法

var people = (from p in people SELECT p).ToList();
var jobs = (from j in jobs SELECT j).ToList();

var peopleAndJobs = (from p in people JOIN j on j.personId equals p.personId SELECT p).ToList()

var people = (from p in people SELECT p);
var jobs = (from j in jobs SELECT j);

var peopleAndJobs = (from p in people JOIN j on j.personId equals p.personId SELECT p).ToList()

Hibernate延迟加载以实现一对一的反向解决方法-这项工作如何进行？

我今天遇到问题，在使用按映射的集合时，延迟加载无法正常工作。我发现这篇出色的文章似乎可以解决问题

http://justonjava.blogspot.co.uk/2010/09/lazy-one-to-one-and-one-to-
many.html

我不明白的一件事是使用FieldHandled的解决方法如何工作。谁能帮我理解这一点？有问题的代码如下（从链接中的示例复制）：

@Entitypublic class Animal implements FieldHandled {   private Person owner;   private FieldHandler fieldHandler;   @OneToOne(fetch = FetchType.LAZY, optional = true, mappedBy = "animal")   @LazyToOne(LazyToOneOption.NO_PROXY)   public Person getOwner() {     if (fieldHandler != null) {        return (Person) fieldHandler.readObject(this, "owner", owner);     }     return owner;   }   public void setOwner(Person owner) {     if (fieldHandler != null) {       this.owner = fieldHandler.writeObject(this, "owner", this.owner, owner);       return;     }     this.owner = owner;   }   public FieldHandler getFieldHandler() {     return fieldHandler;   }   public void setFieldHandler(FieldHandler fieldHandler) {     this.fieldHandler = fieldHandler;   }}

我想念什么？也许我对Hibernate的生命周期了解不够？我乐意进行调查，但任何人都可以给我一些指导。

提前致谢。

编辑

我进行了很多更改，因此许多实体实现了FieldHandled，但随后发现我的某些测试失败了。如果仅使用这些方法集来实现该接口，那么我就抽出了SQL，并得到了一些奇怪的信息，这些SQL以不同的顺序发生了。

   public FieldHandler getFieldHandler() {     return fieldHandler;   }   public void setFieldHandler(FieldHandler fieldHandler) {     this.fieldHandler = fieldHandler;   }

这导致测试失败，因为我断言时事情还没有处于正确的状态。这增加了我对该FieldHandler变量的误解。

答案1

下面的代码告诉Hibernate使用拦截处理程序代替代理。

@LazyToOne(LazyToOneOption.NO_PROXY)

从javadoc：

返回请求引用时加载的真实对象（此选项必须增强字节码，如果未增强该类，则退回到PROXY）

可以看出，在使用字节码之前需要对其进行检测。检测“字节码”后，“持久类得到增强”。

这个想法是要愚弄Hibernate，我们要使用的实体类已经被检测了

编译代码后将调用检测任务。工具实体扩展FieldHandled。FieldHandled是“引入增强类的接口”

Hibernate在运行时验证实体，并得出结论，类得到了增强，这就是为什么它使用真实对象而不是代理并且不像往常那样加载相关实体对象的原因。

编辑：

让我们来看看幕后花絮：

1. AnnotationBinder句柄 NO_PROXY选项

   if ( lazy != null ) {toOne.setLazy( !( lazy.value() == LazyToOneOption.FALSE ) );toOne.setUnwrapProxy( ( lazy.value() == LazyToOneOption.NO_PROXY ) );

   }

2. 这两个org.hibernate.mapping.ManyToOne和org.hibernate.mapping.OneToOne是的子类org.hibernate.mapping.ToOne。ToOne#isUnwrapProxy()唯一的用途是#getType：

getMappings（）。getTypeResolver（）。getTypeFactory（）。oneToOne（

1. 这两个ManyToOneType和OneToOneType是的子类EntityType，只有“的EntityType＃unwrapProxy”的用法是在EntityType#resolveIdentifier(Serializable, SessionImplementor)

   boolean isProxyUnwrapEnabled = unwrapProxy &&    session.getFactory()            .getEntityPersister( getAssociatedEntityName() )            .isInstrumented();

2. 这是暂定的呼叫层次结构：AbstractEntityPersister#isInstrumented()-> EntityMetamodel#isInstrumented()-> EntityInstrumentationMetadata#isInstrumented()->等，最后BytecodeProviderImpl.EntityInstrumentationMetadataImpl.EntityInstrumentationMetadataImpl()

    this.isInstrumented = FieldHandled.class.isAssignableFrom( entityClass );

这就是为什么需要检测代码（例如使用InstrumentTask）或实现的原因FieldHandled。

为了使长话短说你可以看一看EntityType#resolveIdentifier(Serializable,SessionImplementor)。这就是为什么即使第二个对象为空也不会加载的原因。

关于休眠：一对一延迟加载，可选= false和休眠延迟15秒的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于Angular Lazy load (延迟加载，惰性加载) 机制和 feature module 的学习笔记、angular – 如何在延迟加载的模块中提供服务,并将该服务限定为延迟加载的模块及其组件？、entity-framework – 实体框架中的延迟加载,延迟加载和Eager加载、Hibernate延迟加载以实现一对一的反向解决方法-这项工作如何进行？等相关内容，可以在本站寻找。