Cómo obtener asociaciones FetchType.LAZY con JPA e Hibernate en un controlador Spring

Tengo una clase de persona:

@Entity
public class Person {

    @Id
    @GeneratedValue
    private Long id;

    @ManyToMany(fetch = FetchType.LAZY)
    private List<Role> roles;
    // etc
}

Con una relación de muchos a muchos que es vago.

En mi controlador tengo

@Controller
@RequestMapping("/person")
public class PersonController {
    @Autowired
    PersonRepository personRepository;

    @RequestMapping("/get")
    public @ResponseBody Person getPerson() {
        Person person = personRepository.findOne(1L);
        return person;
    }
}

Y el PersonRepository es solo este código, escrito de acuerdo con esta guía

public interface PersonRepository extends JpaRepository<Person, Long> {
}

Sin embargo, en este controlador realmente necesito los datos perezosos. ¿Cómo puedo activar su carga?

Intentar acceder fallará con

no se pudo inicializar perezosamente una colección de roles: no.dusken.momus.model.Person.roles, no se pudo inicializar el proxy: sin sesión

u otras excepciones según lo que intente.

Mi descripción xml , en caso de que sea necesario.

Gracias.

Tendrá que hacer una llamada explícita a la colección perezosa para inicializarla (la práctica común es llamar .size()para este propósito). En Hibernate hay un método dedicado para esto ( Hibernate.initialize()), pero JPA no tiene equivalente. Por supuesto, tendrá que asegurarse de que se realiza la invocación, cuando la sesión todavía está disponible, así que anote su método de controlador con @Transactional. Una alternativa es crear una capa de Servicio intermedia entre el Controlador y el Repositorio que podría exponer métodos que inicializan colecciones diferidas.

Actualizar:

Tenga en cuenta que la solución anterior es fácil, pero da como resultado dos consultas distintas a la base de datos (una para el usuario y otra para sus funciones). Si desea lograr un mejor rendimiento, agregue el siguiente método a su interfaz de repositorio Spring Data JPA:

public interface PersonRepository extends JpaRepository<Person, Long> {

    @Query("SELECT p FROM Person p JOIN FETCH p.roles WHERE p.id = (:id)")
    public Person findByIdAndFetchRolesEagerly(@Param("id") Long id);

}

Este método utilizará la cláusula fetch join de JPQL para cargar con entusiasmo la asociación de roles en un solo viaje de ida y vuelta a la base de datos y, por lo tanto, mitigará la penalización de rendimiento incurrida por las dos consultas distintas en la solución anterior.

Aunque esta es una publicación antigua, considere usar @NamedEntityGraph (Javax Persistence) y @EntityGraph (Spring Data JPA). La combinación funciona.

Ejemplo

@Entity
@Table(name = "Employee", schema = "dbo", catalog = "ARCHO")
@NamedEntityGraph(name = "employeeAuthorities",
            attributeNodes = @NamedAttributeNode("employeeGroups"))
public class EmployeeEntity implements Serializable, UserDetails {
// your props
}

y luego el repositorio de primavera como a continuación

@RepositoryRestResource(collectionResourceRel = "Employee", path = "Employee")
public interface IEmployeeRepository extends PagingAndSortingRepository<EmployeeEntity, String>           {

    @EntityGraph(value = "employeeAuthorities", type = EntityGraphType.LOAD)
    EmployeeEntity getByUsername(String userName);

}

Tienes algunas opciones

• Escriba un método en el repositorio que devuelva una entidad inicializada como sugirió RJ.

Más trabajo, mejor rendimiento.

• Use OpenEntityManagerInViewFilter para mantener la sesión abierta para toda la solicitud.

Menos trabajo, generalmente aceptable en entornos web.

• Use una clase auxiliar para inicializar entidades cuando sea necesario.

Menos trabajo, útil cuando OEMIV no está en opción, por ejemplo en una aplicación Swing, pero también puede ser útil en implementaciones de repositorio para inicializar cualquier entidad de una sola vez.

Para la última opción, escribí una clase de utilidad, JpaUtils para inicializar entidades en alguna definición.

Por ejemplo:

@Transactional
public class RepositoryHelper {

    @PersistenceContext
    private EntityManager em;

    public void intialize(Object entity, int depth) {
        JpaUtils.initialize(em, entity, depth);
    }
}

solo se puede cargar perezosamente mientras está dentro de una transacción. Por lo tanto, puede acceder a la colección en su repositorio, que tiene una transacción, o lo que normalmente hago es un get with association, o establecer fetchmode en ansioso.

Creo que necesita OpenSessionInViewFilter para mantener su sesión abierta durante el renderizado de vistas (pero no es una buena práctica).

Datos de primavera JpaRepository

Spring Data JpaRepositorydefine los siguientes dos métodos:

• getOne, que devuelve un proxy de entidad adecuado para establecer un@ManyToOne@OneToOne asociación principal o principal cuando persiste una entidad secundaria .
• findById, que devuelve la entidad POJO después de ejecutar la instrucción SELECT que carga la entidad desde la tabla asociada

Sin embargo, en su caso, que no llama a cualquiera getOneo findById:

Person person = personRepository.findOne(1L);

Entonces, supongo que el findOnemétodo es un método que definiste en el PersonRepository. Sin embargo, el findOnemétodo no es muy útil en su caso. Como debe buscar la colección Personjunto con is roles, es mejor usar un findOneWithRolesmétodo.

Métodos personalizados de Spring Data

Puede definir una PersonRepositoryCustominterfaz de la siguiente manera:

public interface PersonRepository
    extends JpaRepository<Person, Long>, PersonRepositoryCustom { 

}

public interface PersonRepositoryCustom {
    Person findOneWithRoles(Long id);
}

Y defina su implementación de esta manera:

public class PersonRepositoryImpl implements PersonRepositoryCustom {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public Person findOneWithRoles(Long id)() {
        return entityManager.createQuery("""
            select p 
            from Person p
            left join fetch p.roles
            where p.id = :id 
            """, Person.class)
        .setParameter("id", id)
        .getSingleResult();
    }
}

¡Eso es!

Puedes hacer lo mismo así:

@Override
public FaqQuestions getFaqQuestionById(Long questionId) {
    session = sessionFactory.openSession();
    tx = session.beginTransaction();
    FaqQuestions faqQuestions = null;
    try {
        faqQuestions = (FaqQuestions) session.get(FaqQuestions.class,
                questionId);
        Hibernate.initialize(faqQuestions.getFaqAnswers());

        tx.commit();
        faqQuestions.getFaqAnswers().size();
    } finally {
        session.close();
    }
    return faqQuestions;
}

Simplemente use faqQuestions.getFaqAnswers (). Size () en su controlador y obtendrá el tamaño de la lista perezosamente inicializada, sin obtener la lista en sí.