Hacer que una relación de uno sea perezosa

Para que la carga perezosa funcione en asignaciones uno a uno nullables, debe dejar que hibernate haga compile la instrumentación en tiempo y agregue un @LazyToOne(value = LazyToOneOption.NO_PROXY) a la relación uno a uno.

Ejemplo de mapeo:

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

Ejemplo de extensión de archivo de compilación Ant (para hacer la instrumentación de tiempo de compilación de Hibernación):

<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>

La idea básica detrás de los XToOnes en Hibernación es que no son perezosos en la mayoría de los casos.

Una razón es que, cuando Hibernate tiene que decidir poner un proxy (con el id) o un null,
tiene que buscar en la otra tabla de todos modos para unirse. El costo de acceder a la otra tabla en la base de datos es significativo, por lo que también podría recuperar los datos de esa tabla en ese momento (comportamiento no perezoso), en lugar de recuperarlos en una solicitud posterior que requeriría un segundo acceso a la misma mesa.

Editado: para más detalles, consulte la respuesta de ChssPly76 . Este es menos preciso y detallado, no tiene nada que ofrecer. Gracias ChssPly76.

Aquí hay algo que ha estado funcionando para mí (sin instrumentación):

En lugar de usar @OneToOne en ambos lados, uso @OneToMany en la parte inversa de la relación (la que tiene mappedBy). Eso hace que la propiedad sea una colección (List en el ejemplo a continuación), pero la traduzco en un elemento en el getter, haciéndolo transparente para los clientes.

Esta configuración funciona perezosamente, es decir, los selects solo se realizan cuando se llama a getPrevious() o getNext() - y solo uno selecciona para cada llamada.

La estructura de la tabla:

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`);

La clase:

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

}

En asignaciones XML nativas de Hibernación, puede lograr esto declarando una asignación one-to-one con el atributo constrained establecido en true. No estoy seguro de cuál es el equivalente de la anotación de hibernación/APP, y una búsqueda rápida del doc no proporcionó ninguna respuesta, pero espero que eso les dé una pista para continuar.

Como ya ha explicado perfectamente ChssPly76, los proxies de Hibernate no ayudan con asociaciones uno a uno sin restricciones (anulables), PERO hay un truco explicado aquí para evitar configurar instrumentación. La idea es engañar a Hibernar que la clase de entidad que queremos usar ya ha sido instrumentada: la instrumentas manualmente en el código fuente. Es fácil! Lo he implementado con CGLib como proveedor de bytecode y funciona (asegúrese de configurar lazy="no-proxy" y fetch= "select", no" join", en su HBM).

Creo que esta es una buena alternativa a real (me refiero a la instrumentación automática) cuando solo tienes una relación anulable de uno a uno que quieres hacer perezosa. El principal inconveniente es que la solución depende del proveedor de bytecode que esté utilizando, por lo que comente su clase con precisión porque podría tener que cambiar el proveedor de bytecode en el futuro; por supuesto, también está modificando su modelo bean por una razón técnica y esto es no está bien.