Comment récupérer les associations FetchType.LAZY avec JPA et Hibernate dans un Spring Controller

J'ai une classe Person:

@Entity
public class Person {

    @Id
    @GeneratedValue
    private Long id;

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

Avec une relation plusieurs-à-plusieurs qui est paresseuse.

Dans mon contrôleur, j'ai

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

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

Et le PersonRepository n'est que ce code, écrit selon ce guide

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

Cependant, dans ce contrôleur, j'ai réellement besoin des données paresseuses. Comment puis-je déclencher son chargement?

Essayer d'y accéder échouera avec

échec de l'initialisation paresseuse d'une collection de rôles: no.dusken.momus.model.Person.roles, impossible d'initialiser le proxy - pas de session

ou d'autres exceptions selon ce que j'essaye.

Ma description xml , en cas de besoin.

Merci.

Vous devrez faire un appel explicite sur la collection paresseuse afin de l'initialiser (la pratique courante est d'appeler .size()dans ce but). Dans Hibernate, il existe une méthode dédiée pour this ( Hibernate.initialize()), mais JPA n'a pas d'équivalent. Bien sûr, vous devrez vous assurer que l'invocation est effectuée, lorsque la session est encore disponible, alors annotez votre méthode de contrôleur avec @Transactional. Une alternative consiste à créer une couche de service intermédiaire entre le contrôleur et le référentiel qui pourrait exposer des méthodes qui initialisent des collections différées.

Mettre à jour:

Veuillez noter que la solution ci-dessus est simple, mais entraîne deux requêtes distinctes dans la base de données (une pour l'utilisateur, une autre pour ses rôles). Si vous souhaitez obtenir de meilleures performances, ajoutez la méthode suivante à votre interface de référentiel 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);

}

Cette méthode utilisera la clause fetch join de JPQL pour charger avec empressement l'association de rôles en un seul aller-retour vers la base de données, et atténuera donc la pénalité de performances encourue par les deux requêtes distinctes dans la solution ci-dessus.

Bien qu'il s'agisse d'un ancien article, veuillez envisager d'utiliser @NamedEntityGraph (Javax Persistence) et @EntityGraph (Spring Data JPA). La combinaison fonctionne.

Exemple

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

puis le repo de printemps comme ci-dessous

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

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

}

Vous avez quelques options

• Écrivez une méthode sur le référentiel qui retourne une entité initialisée comme RJ l'a suggéré.

Plus de travail, meilleures performances.

• Utilisez OpenEntityManagerInViewFilter pour garder la session ouverte pour toute la demande.

Moins de travail, généralement acceptable dans les environnements Web.

• Utilisez une classe d'assistance pour initialiser les entités si nécessaire.

Moins de travail, utile lorsque OEMIV n'est pas en option, par exemple dans une application Swing, mais peut également être utile sur les implémentations de référentiel pour initialiser toute entité en un seul coup.

Pour la dernière option, j'ai écrit une classe utilitaire, JpaUtils pour initialiser les entités à une certaine profondeur.

Par exemple:

@Transactional
public class RepositoryHelper {

    @PersistenceContext
    private EntityManager em;

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

il ne peut être chargé que paresseusement pendant une transaction. Vous pouvez donc accéder à la collection dans votre référentiel, qui a une transaction - ou ce que je fais normalement, c'est un get with association, ou définir fetchmode sur eager.

Je pense que vous avez besoin d' OpenSessionInViewFilter pour garder votre session ouverte pendant le rendu de la vue (mais ce n'est pas une très bonne pratique).

Données de printemps JpaRepository

The Spring Data JpaRepositorydéfinit les deux méthodes suivantes:

• getOne, qui renvoie un proxy d'entité adapté à la définition d'une association @ManyToOneou @OneToOneparente lors de la persistance d'une entité enfant .
• findById, qui renvoie l'entité POJO après l'exécution de l'instruction SELECT qui charge l'entité à partir de la table associée

Cependant, dans votre cas, vous n'avez appelé ni getOneni findById:

Person person = personRepository.findOne(1L);

Donc, je suppose que le findOne méthode est une méthode que vous avez définie dans le PersonRepository. Cependant, la findOneméthode n'est pas très utile dans votre cas. Puisque vous devez récupérer la collection Personavec is roles, il est préférable d'utiliser une findOneWithRolesméthode à la place.

Méthodes de données Spring personnalisées

Vous pouvez définir une PersonRepositoryCustominterface comme suit:

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

}

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

Et définissez sa mise en œuvre comme ceci:

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

C'est tout!

Vous pouvez faire la même chose comme ceci:

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

Utilisez simplement faqQuestions.getFaqAnswers (). Size () nin votre contrôleur et vous obtiendrez la taille si la liste initialisée paresseusement, sans récupérer la liste elle-même.