Question

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

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

我不明白的一件事是使用FieldHandled的解决方法是如何工作的。任何人都可以帮我理解这个吗？有问题的代码如下（从链接上的示例中复制）：

@Entity
public 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变量的误解。

Answer 1

以下代码告诉Hibernate使用拦截处理程序而不是代理。

@LazyToOne(LazyToOneOption.NO_PROXY)

From javadoc:

在请求引用时返回加载的实际对象（此选项必须使用字节码增强，如果类没有增强，则返回PROXY）

可以看出，在使用之前需要检测字节码。在''字节码被检测'后，'持久类被增强'。

我的想法是欺骗Hibernate我们想要使用的实体类已经被检测了

编译代码后调用Instrumentation任务。 Instrumented entity extends FieldHandled。 FieldHandled是“引入增强类的接口”

Hibernate在运行时验证实体，并得出结论，类已被增强，这就是它使用真实对象而不是代理和isn't loading related entity object as it normally did的原因。

编辑：

让我们来看看引擎盖：

AnnotationBinder handles NO_PROXY选项

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

org.hibernate.mapping.ManyToOne和org.hibernate.mapping.OneToOne都是org.hibernate.mapping.ToOne的子类。 ToOne#isUnwrapProxy()仅限#getType使用{/ 1}}：

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

ManyToOneType和OneToOneType都是EntityType的子类，只有'EntityType＃unwrapProxy'的使用位于EntityType#resolveIdentifier(Serializable, SessionImplementor)

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

以下是暂定的呼叫层次结构：AbstractEntityPersister#isInstrumented() - ＆gt; EntityMetamodel#isInstrumented() - ＆gt; EntityInstrumentationMetadata#isInstrumented() - ＆gt;等等，最后BytecodeProviderImpl.EntityInstrumentationMetadataImpl.EntityInstrumentationMetadataImpl()
```
 this.isInstrumented = FieldHandled.class.isAssignableFrom( entityClass );
```

这就是为什么需要对代码进行检测（例如InstrumentTask）或实施FieldHandled。

为了简短说明，你可以看一下EntityType#resolveIdentifier(Serializable, SessionImplementor)。 That's the reason why second object is not loaded even if it's nullable.

Answer 2

FieldHandled接口已被Hibernate 5中的PersistentAttributeInterceptable接口替换。您可以通过实现这个新接口来实现相同的结果：

@Entity
public class Animal implements PersistentAttributeInterceptable {
    private Person owner;
    private PersistentAttributeInterceptor interceptor;

    @OneToOne(fetch = FetchType.LAZY, optional = true, mappedBy = "animal")
    @LazyToOne(LazyToOneOption.NO_PROXY)
    public Person getOwner() {
        if (interceptor != null) {
            return (Person) interceptor.readObject(this, "owner", owner);
        }
        return owner;
    }

    public void setOwner(Person owner) {
        if (interceptor != null) {
            this.owner = interceptor.writeObject(this, "owner", this.owner, owner);
            return;
        }
        this.owner = owner;
    }

    @Override
    public PersistentAttributeInterceptor $$_hibernate_getInterceptor() {
        return interceptor;
    }

    @Override
    public void $$_hibernate_setInterceptor(PersistentAttributeInterceptor interceptor) {
        this.interceptor = interceptor;
    }
}

Hibernate延迟加载反向一对一解决方法 - 这是如何工作的？

2 个答案: