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

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)

来自javadoc:

在请求引用时返回加载的实际对象(此选项必须使用字节码增强,如果未增强类,则返回PROXY)

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

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

编译代码后调用Instrumentation任务.仪表实体扩展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(

3. 这两个ManyToOneType和OneToOneType是的子类EntityType和"的EntityType#unwrapProxy"只使用在EntityType#resolveIdentifier(Serializable, SessionImplementor)

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

4. 这是暂定的调用层次结构:AbstractEntityPersister#isInstrumented()- > EntityMetamodel#isInstrumented()- > EntityInstrumentationMetadata#isInstrumented()- >等等BytecodeProviderImpl.EntityInstrumentationMetadataImpl.EntityInstrumentationMetadataImpl()

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

这就是为什么它需要检测代码(例如InstrumentTask)或实现FieldHandled.

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

Answer 2

该FieldHandled接口已被替换为PersistentAttributeInterceptableHibernate中你可以通过执行这一新的接口获得相同的结果界面:

@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;
    }
}