Como buscar associações FetchType.LAZY com JPA e Hibernate em um Spring Controller

Eu tenho uma classe Person:

@Entity
public class Person {

    @Id
    @GeneratedValue
    private Long id;

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

Com uma relação muitos-para-muitos que é preguiçosa.

No meu controlador eu tenho

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

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

E o PersonRepository é apenas esse código, escrito de acordo com este guia

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

No entanto, neste controlador, eu realmente preciso dos dados preguiçosos. Como posso acionar o carregamento?

Tentar acessá-lo falhará com

falhou ao inicializar preguiçosamente uma coleção de funções: no.dusken.momus.model.Person.roles, não foi possível inicializar o proxy - nenhuma Sessão

ou outras exceções, dependendo do que eu tente.

Minha descrição xml , caso necessário.

Obrigado.

Você precisará fazer uma chamada explícita na coleção lenta para inicializá-la (a prática comum é chamar .size()para esse fim). No Hibernate, existe um método dedicado para isso ( Hibernate.initialize()), mas o JPA não tem equivalente. É claro que você precisará garantir que a chamada seja feita, quando a sessão ainda estiver disponível, então anote seu método do controlador @Transactional. Uma alternativa é criar uma camada de Serviço intermediária entre o Controlador e o Repositório que possa expor métodos que inicializam coleções preguiçosas.

Atualizar:

Observe que a solução acima é fácil, mas resulta em duas consultas distintas no banco de dados (uma para o usuário e outra para suas funções). Se você deseja obter melhor desempenho, inclua o seguinte método na interface do repositório do 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);

}

Esse método usará a cláusula de junção de busca do JPQL para carregar ansiosamente a associação de funções em uma única viagem de ida e volta ao banco de dados e, portanto, reduzirá a penalidade de desempenho incorrida pelas duas consultas distintas na solução acima.

Embora essa seja uma postagem antiga, considere usar @NamedEntityGraph (Javax Persistence) e @EntityGraph (Spring Data JPA). A combinação funciona.

Exemplo

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

e depois o repo da primavera como abaixo

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

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

}

Você tem algumas opções

• Escreva um método no repositório que retorne uma entidade inicializada como o RJ sugeriu.

Mais trabalho, melhor desempenho.

• Use OpenEntityManagerInViewFilter para manter a sessão aberta para toda a solicitação.

Menos trabalho, geralmente aceitável em ambientes da web.

• Use uma classe auxiliar para inicializar entidades quando necessário.

Menos trabalho, útil quando o OEMIV não está disponível, por exemplo, em um aplicativo Swing, mas também pode ser útil em implementações de repositório para inicializar qualquer entidade de uma só vez.

Para a última opção, escrevi uma classe de utilitário, JpaUtils para iniciar entidades em algum deph.

Por exemplo:

@Transactional
public class RepositoryHelper {

    @PersistenceContext
    private EntityManager em;

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

só pode ser carregado lentamente enquanto estiver dentro de uma transação. Assim, você pode acessar a coleção em seu repositório, que possui uma transação - ou o que eu normalmente faço é um get with association, ou definir fetchmode para ansioso.

Acho que você precisa do OpenSessionInViewFilter para manter sua sessão aberta durante a renderização de exibição (mas não é uma boa prática).

Dados da Primavera JpaRepository

Os dados do Spring JpaRepositorydefinem os dois métodos a seguir:

• getOne, que retorna um proxy de entidade adequado para definir uma associação @ManyToOneou @OneToOnepai ao persistir em uma entidade filho .
• findById, que retorna a entidade POJO após executar a instrução SELECT que carrega a entidade da tabela associada

No entanto, no seu caso, você não chamar tanto getOneou findById:

Person person = personRepository.findOne(1L);

Então, suponho que o findOnemétodo é um método que você definiu no PersonRepository. No entanto, o findOnemétodo não é muito útil no seu caso. Como você precisa buscar a coleção Personjunto com o is roles, é melhor usar um findOneWithRolesmétodo.

Métodos personalizados de dados de primavera

Você pode definir uma PersonRepositoryCustominterface, da seguinte maneira:

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

}

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

E defina sua implementação assim:

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

É isso aí!

Você pode fazer o mesmo assim:

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

Basta usar faqQuestions.getFaqAnswers (). Size () em seu controlador e você obterá o tamanho da lista inicializada preguiçosamente, sem buscar a própria lista.