Come recuperare le associazioni FetchType.LAZY con JPA e Hibernate in un controller Spring

Ho una classe Person:

@Entity
public class Person {

    @Id
    @GeneratedValue
    private Long id;

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

Con una relazione molti-a-molti che è pigro.

Nel mio controller ho

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

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

E il PersonRepository è proprio questo codice, scritto secondo questa guida

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

Tuttavia, in questo controller ho effettivamente bisogno dei dati pigri. Come posso attivare il suo caricamento?

Cercare di accedervi fallirà

impossibile inizializzare pigramente una raccolta di ruoli: no.dusken.momus.model.Person.roles, impossibile inizializzare il proxy - nessuna sessione

o altre eccezioni a seconda di ciò che provo.

La mia descrizione xml , se necessario.

Grazie.

Dovrai effettuare una chiamata esplicita sulla raccolta pigra per inizializzarla (la pratica comune è quella di chiamare .size()per questo scopo). In Hibernate esiste un metodo dedicato per questo ( Hibernate.initialize()), ma JPA non ha equivalenti. Ovviamente dovrai assicurarti che l'invocazione sia terminata, quando la sessione è ancora disponibile, quindi annota il tuo metodo controller @Transactional. Un'alternativa è quella di creare un livello di servizio intermedio tra il controller e il repository che potrebbe esporre metodi che inizializzano raccolte pigre.

Aggiornare:

Si noti che la soluzione sopra è semplice, ma comporta due query distinte nel database (una per l'utente, un'altra per i suoi ruoli). Se si desidera ottenere prestazioni migliori, aggiungere il seguente metodo all'interfaccia del repository JPA Spring Data:

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

}

Questo metodo utilizzerà JPQL clausola fetch join di per caricare con impazienza l'associazione dei ruoli in un singolo round-trip nel database e quindi mitigherà la penalità di prestazione sostenuta dalle due query distinte nella soluzione precedente.

Anche se questo è un vecchio post, considera l'utilizzo di @NamedEntityGraph (Javax Persistence) e @EntityGraph (Spring Data JPA). La combinazione funziona.

Esempio

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

e quindi il repository primavera come di seguito

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

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

}

Hai alcune opzioni

• Scrivi un metodo sul repository che restituisce un'entità inizializzata come suggerito da RJ.

Più lavoro, migliori prestazioni.

• Utilizzare OpenEntityManagerInViewFilter per mantenere aperta la sessione per l'intera richiesta.

Meno lavoro, generalmente accettabile negli ambienti web.

• Utilizzare una classe di supporto per inizializzare le entità quando richiesto.

Meno lavoro, utile quando OEMIV non è disponibile, ad esempio in un'applicazione Swing, ma può essere utile anche nelle implementazioni del repository per inizializzare qualsiasi entità in un colpo solo.

Per l'ultima opzione, ho scritto una classe di utilità, JpaUtils per inizializzare le entità a qualche profondità.

Per esempio:

@Transactional
public class RepositoryHelper {

    @PersistenceContext
    private EntityManager em;

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

può essere caricato pigramente solo all'interno di una transazione. Quindi potresti accedere alla raccolta nel tuo repository, che ha una transazione - o quello che faccio normalmente è un get with association, o impostare fetchmode su desideroso.

Penso che sia necessario OpenSessionInViewFilter per mantenere aperta la sessione durante il rendering della vista (ma non è una buona pratica).

Dati di primavera JpaRepository

I dati di primavera JpaRepositorydefiniscono i seguenti due metodi:

• getOne, che restituisce un proxy di entità adatto per l'impostazione di un'associazione principale @ManyToOneo quando persiste un'entità secondaria .@OneToOne
• findById, che restituisce l'entità POJO dopo aver eseguito l'istruzione SELECT che carica l'entità dalla tabella associata

Tuttavia, nel tuo caso, non hai chiamato sia getOneo findById:

Person person = personRepository.findOne(1L);

Quindi, presumo che il findOnemetodo sia un metodo che hai definito in PersonRepository. Tuttavia, il findOnemetodo non è molto utile nel tuo caso. Dato che devi recuperare Personinsieme a is rolescollection, è meglio usare afindOneWithRoles metodo.

Metodi dati primavera personalizzati

È possibile definire PersonRepositoryCustomun'interfaccia, come segue:

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

}

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

E definirne l'implementazione in questo modo:

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

Questo è tutto!

Puoi fare lo stesso in questo modo:

@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 usare faqQuestions.getFaqAnswers (). Size () nin il tuo controller e otterrai le dimensioni se l'elenco è pigramente integrato, senza recuperare l'elenco stesso.