Hibernate uno-a-uno: getId() sin obtener todo el objeto

Question

Quiero buscar el ID de una relación uno-a-uno sin cargar todo el objeto. Pensé que podía hacer esto utilizando la carga diferida de la siguiente manera:

class Foo { 
    @OneToOne(fetch = FetchType.LAZY, optional = false) 
    private Bar bar; 
} 


Foo f = session.get(Foo.class, fooId); // Hibernate fetches Foo 

f.getBar(); // Hibernate fetches full Bar object 

f.getBar().getId(); // No further fetch, returns id 

Quiero f.getBar() para no gatillo otra exploración. Quiero que hibernate me proporcione un objeto proxy que me permita llamar a .getId() sin buscar realmente el objeto Bar.

¿Qué estoy haciendo mal?

Answer 1

Uso estrategia de acceso a la propiedad

En lugar de

@OneToOne(fetch=FetchType.LAZY, optional=false) 
private Bar bar; 

Uso

private Bar bar; 

@OneToOne(fetch=FetchType.LAZY, optional=false) 
public Bar getBar() { 
    return this.bar; 
} 

Ahora funciona bien!

Un proxy se inicializa si llama a cualquier método que no sea el método de obtención de identificador. Pero solo funciona cuando se usa la estrategia de acceso a la propiedad. Tenlo en mente.

Ver: Hibernate 5.2 user guide

Answer 2

Puede utilizar una consulta HQL. El método getBar() realmente devolverá un proxy, que no será recuperado hasta que invoque algún método vinculado a datos. No estoy seguro de cuál es exactamente tu problema. ¿Puedes darnos más antecedentes?

Answer 3

Sólo para añadir a la Arthur Ronald FD Garcia'post: puede forzar acceso a la propiedad @Access(AccessType.PROPERTY) (o desaprobado @AccessType("property")), ver http://256stuff.com/gray/docs/misc/hibernate_lazy_field_access_annotations.shtml

Otra solución puede ser:

public static Integer getIdDirect(Entity entity) { 
    if (entity instanceof HibernateProxy) { 
     LazyInitializer lazyInitializer = ((HibernateProxy) entity).getHibernateLazyInitializer(); 
     if (lazyInitializer.isUninitialized()) { 
      return (Integer) lazyInitializer.getIdentifier(); 
     } 
    } 
    return entity.getId(); 
} 

Funciona para entidades independientes, también.

Answer 4

En org.hibernate.Session tiene una función que realizan el trabajo sin carga diferida la entidad:

pública Serializable getIdentifier (objeto Object) lanza HibernateException;

encontrados en 3.3.2.GA de hibernación:

public Serializable getIdentifier(Object object) throws HibernateException { 
     errorIfClosed(); 
     checkTransactionSynchStatus(); 
     if (object instanceof HibernateProxy) { 
      LazyInitializer li = ((HibernateProxy) object).getHibernateLazyInitializer(); 
      if (li.getSession() != this) { 
       throw new TransientObjectException("The proxy was not associated with this session"); 
      } 
      return li.getIdentifier(); 
     } 
     else { 
      EntityEntry entry = persistenceContext.getEntry(object); 
      if (entry == null) { 
       throw new TransientObjectException("The instance was not associated with this session"); 
      } 
      return entry.getId(); 
     } 
    } 

Answer 5

La persistencia de Java con Hibernate libro menciona esto en "13.1.3 La representación entendimiento":

Mientras se accede sólo el propiedad de identificador de base de datos, no inicialización del proxy es necesario. (Tenga en cuenta que esto no es verdadero si mapea la propiedad del identificador con acceso directo al campo; Hibernate entonces ni siquiera sabe que el método getId() existe. Si lo llama, el proxy debe ser inicializado.)

Sin embargo, en base a @xmedeko respuesta en esta página he desarrollado un truco para evitar inicializar el proxy incluso cuando se utiliza la estrategia de acceso directo campo. Simplemente modifique el método getId() como se muestra a continuación.

En lugar de:

public long getId() { return id; } 

Uso:

public final long getId() { 
     if (this instanceof HibernateProxy) { 
      return (long)((HibernateProxy)this).getHibernateLazyInitializer().getIdentifier(); 
     } 
     else { return id; } 
    } 

La idea aquí es para marcar el método getId() como final, por lo que los proxies no pueden anularlo. Entonces, llamar al método no puede ejecutar ningún código proxy y, por lo tanto, no puede inicializar el proxy. El método mismo verifica si su instancia es un proxy, y en este caso devuelve el id del proxy. Si la instancia es el objeto real, devuelve la identificación.

Answer 6

cambiar su método de obtención de esta manera:

public Bar getBar() { 
    if (bar instanceof HibernateProxy) { 
     HibernateProxy hibernateProxy = (HibernateProxy) this.bar; 
     LazyInitializer lazyInitializer = hibernateProxy.getHibernateLazyInitializer(); 
     if (lazyInitializer.getSession() == null) 
      bar = new Bar((long) lazyInitializer.getIdentifier()); 
    } 

    return bar; 
} 

Answer 7

añadir @AccessType ("propiedad")

@Id 
@GeneratedValue(strategy = GenerationType.IDENTITY) 
@AccessType("property") 
protected Long id; 

Answer 8

ahora hay una biblioteca de tipo de datos de hibernación Jackson aquí:

https://github.com/FasterXML/jackson-datatype-hibernate

Y usted c una configurar las funciones de:

Hibernate4Module hibernate4Module = new Hibernate4Module(); 
hibernate4Module.configure(Hibernate4Module.Feature.SERIALIZE_IDENTIFIER_FOR_LAZY_NOT_LOADED_OBJECTS, true); 

Esto incluirá la identificación de la relación-cargado perezoso

Answer 9

Por desgracia, la respuesta aceptada es erróneo. También otras respuestas no proporcionan la solución más simple o clara.

Utilice el Nivel de acceso de propiedad para ID de la clase BAR.

@Entity 
public class Bar { 

    @Id 
    @Access(AccessType.PROPERTY) 
    private Long id; 

    ... 
} 

tan simple como que :)