Cómo obtener Hibernate FetchProfile para cargar objetos secundarios profundos en la jerarquía

Question

Tengo la misma pregunta que alguien publicado en la comunidad de Hibernate: FetchProfiles.

Por motivos de rendimiento que tienen una relación en el modelo de datos de la siguiente manera:

...C -[FetchType.LAZY]-> D -> [FetchType.LAZY] -> E 

Usando FetchProfile puedo ansiosamente carga D con C, pero no puedo encontrar la manera de cargar con impaciencia E. sé Puedo usar con éxito un NamedQuery usando uniones internas, pero realmente me molesta que no pueda encontrar la manera de hacerlo usando FetchProfile. Un ejemplo de un intento de FetchProfile (todo lo demás se pierde en las brumas del tiempo):

@FetchProfile(name = "cwithDAndE", fetchOverrides = { 
     @FetchProfile.FetchOverride(entity = C.class, association = "dByCId", mode = FetchMode.JOIN), 
     @FetchProfile.FetchOverride(entity = D.class, association = "eByDId", mode = FetchMode.JOIN) 
}) 

habilito la FetchProfile para la sesión y con éxito el uso de un session.get sin errores y C y D poblada - E es todavía flojo y despoblado. En la desesperación recuerdo haber probado una notación de puntos para la asociación de C hacia abajo. Solo puedo encontrar ejemplos que tienen una profundidad de uno.

Esto es una brecha de tipo OCD en mi conocimiento que necesita ser llenado!

Gracias de antemano por cualquier ayuda.

Answer 1

Usted tiene un Obj que contiene un obj B, que contiene un obj. Por defecto son

...A -[FetchType.LAZY]-> B -> [FetchType.LAZY] -> C 

Una clase: Clase de

@FetchProfiles({ 
    @FetchProfile(fetchOverrides = { @FetchOverride(association = "b", entity = A.class, mode = FetchMode.JOIN) }, name = "a-with-b") 
    }) 
@Entity 
@Table(name="EDITOR_IDENTITIES") 
public class A { 
    private B b;  
    //... 
} 

B:

@FetchProfiles({ 
    @FetchProfile(fetchOverrides = { @FetchOverride(association = "c", entity = B.class, mode = FetchMode.JOIN) }, name = "b-with-c") 
    }) 
@Entity 
@Table(name="EDITOR_IDENTITIES") 
public class B { 
    private C c;  
    //... 
} 

clase

adao:

@Repository(value="aDaoImpl") 
@Transactional 
public class ADaoImpl { 

    @Override 
    public A loadByPrimaryKey(long id) 
    { 
     Session session = sessionFactory.getCurrentSession(); 
     session.enableFetchProfile("a-with-b"); 
     session.enableFetchProfile("b-with-c"); 
     Criteria criteria = session.createCriteria(A.class); 
     criteria.add(Restrictions.eq("id", id)); 
     A a = (A) criteria.uniqueResult(); 
     if(identity != null) 
      return identity; 
     else 
      return null; 
    } 
} 

obtendrá A lleno con B lleno de C. Esta es una solución muy básica, puede construir un método Dao tomando una lista del perfil de búsqueda como argumento.