L'héritage JPA @EntityGraph inclut des associations facultatives de sous-classes

Étant donné le modèle de domaine suivant, je veux charger tous les Answers, y compris leurs Values et leurs sous-enfants respectifs, et les mettre dans un AnswerDTOpour ensuite les convertir en JSON. J'ai une solution de travail mais elle souffre du problème N + 1 dont je veux me débarrasser en utilisant un ad-hoc @EntityGraph. Toutes les associations sont configurées LAZY.

@Query("SELECT a FROM Answer a")
@EntityGraph(attributePaths = {"value"})
public List<Answer> findAll();

En utilisant un ad-hoc @EntityGraphsur la Repositoryméthode, je peux m'assurer que les valeurs sont pré-récupérées pour empêcher N + 1 sur l' Answer->Valueassociation. Bien que mon résultat soit satisfaisant, il existe un autre problème N + 1, en raison du chargement paresseux de l' selectedassociation de l' MCValueal.

Utiliser ceci

@EntityGraph(attributePaths = {"value.selected"})

échoue, car le selectedchamp n'est bien sûr qu'une partie de certaines des Valueentités:

Unable to locate Attribute  with the the given name [selected] on this ManagedType [x.model.Value];

Comment puis-je dire à JPA d'essayer de récupérer l' selectedassociation uniquement si la valeur est a MCValue? J'ai besoin de quelque chose comme ça optionalAttributePaths.

Vous pouvez uniquement utiliser un EntityGraphsi l'attribut d'association fait partie de la superclasse et par cela fait également partie de toutes les sous-classes. Sinon, le EntityGraphéchouera toujours avec le Exceptionque vous obtenez actuellement.

La meilleure façon d'éviter votre problème de sélection N + 1 consiste à diviser votre requête en 2 requêtes:

La 1ère requête récupère les MCValueentités à l'aide d'un EntityGraphpour récupérer l'association mappée par l' selectedattribut. Après cette requête, ces entités sont ensuite stockées dans le cache de premier niveau d'Hibernate / le contexte de persistance. Hibernate les utilisera lorsqu'il traitera le résultat de la 2e requête.

@Query("SELECT m FROM MCValue m") // add WHERE clause as needed ...
@EntityGraph(attributePaths = {"selected"})
public List<MCValue> findAll();

La 2e requête récupère ensuite l' Answerentité et utilise un EntityGraphpour récupérer également les Valueentités associées . Pour chaque Valueentité, Hibernate instanciera la sous-classe spécifique et vérifiera si le cache de 1er niveau contient déjà un objet pour cette combinaison de classe et de clé primaire. Si tel est le cas, Hibernate utilise l'objet du cache de 1er niveau au lieu des données renvoyées par la requête.

@Query("SELECT a FROM Answer a")
@EntityGraph(attributePaths = {"value"})
public List<Answer> findAll();

Parce que nous avons déjà récupéré toutes les MCValueentités avec les selectedentités associées , nous obtenons maintenant des Answerentités avec une valueassociation initialisée . Et si l'association contient une MCValueentité, son selectedassociation sera également initialisée.

Je ne sais pas ce que Spring-Data fait là-bas, mais pour ce faire, vous devez généralement utiliser l' TREATopérateur pour pouvoir accéder à la sous-association, mais l'implémentation de cet opérateur est assez boguée. Hibernate prend en charge l'accès implicite aux propriétés de sous-type, ce dont vous auriez besoin ici, mais apparemment Spring-Data ne peut pas gérer cela correctement. Je peux vous recommander de jeter un œil à Blaze-Persistence Entity-Views , une bibliothèque qui fonctionne au-dessus de JPA qui vous permet de mapper des structures arbitraires sur votre modèle d'entité. Vous pouvez mapper votre modèle DTO d'une manière sûre de type, également la structure d'héritage. Les vues d'entité pour votre cas d'utilisation pourraient ressembler à ceci

@EntityView(Answer.class)
interface AnswerDTO {
  @IdMapping
  Long getId();
  ValueDTO getValue();
}
@EntityView(Value.class)
@EntityViewInheritance
interface ValueDTO {
  @IdMapping
  Long getId();
}
@EntityView(TextValue.class)
interface TextValueDTO extends ValueDTO {
  String getText();
}
@EntityView(RatingValue.class)
interface RatingValueDTO extends ValueDTO {
  int getRating();
}
@EntityView(MCValue.class)
interface TextValueDTO extends ValueDTO {
  @Mapping("selected.id")
  Set<Long> getOption();
}

Avec l'intégration des données de printemps fournie par Blaze-Persistence, vous pouvez définir un référentiel comme celui-ci et utiliser directement le résultat

@Transactional(readOnly = true)
interface AnswerRepository extends Repository<Answer, Long> {
  List<AnswerDTO> findAll();
}

Il générera une requête HQL qui sélectionne exactement ce que vous avez mappé dans ce AnswerDTOqui ressemble à ce qui suit.

SELECT
  a.id, 
  v.id,
  TYPE(v), 
  CASE WHEN TYPE(v) = TextValue THEN v.text END,
  CASE WHEN TYPE(v) = RatingValue THEN v.rating END,
  CASE WHEN TYPE(v) = MCValue THEN s.id END
FROM Answer a
LEFT JOIN a.value v
LEFT JOIN v.selected s

Mon dernier projet a utilisé GraphQL (une première pour moi) et nous avons eu un gros problème avec les requêtes N + 1 et essayer d'optimiser les requêtes pour qu'elles ne se joignent aux tables que lorsqu'elles sont requises. J'ai trouvé irremplaçable Cosium / spring-data-jpa-entity-graph . Il étend JpaRepositoryet ajoute des méthodes pour passer un graphe d'entité à la requête. Vous pouvez ensuite créer des graphiques d'entités dynamiques au moment de l'exécution pour ajouter des jointures gauches uniquement aux données dont vous avez besoin.

Notre flux de données ressemble à ceci:

1. Recevoir la requête GraphQL
2. Analyser la requête GraphQL et convertir en liste de nœuds de graphe d'entité dans la requête
3. Créer un graphique d'entité à partir des nœuds découverts et passer dans le référentiel pour exécution

Pour résoudre le problème de l'inclusion de nœuds non valides dans le graphe d'entité (par exemple à __typenamepartir de graphql), j'ai créé une classe utilitaire qui gère la génération du graphe d'entité. La classe appelante transmet le nom de la classe pour laquelle elle génère le graphique, qui valide ensuite chaque nœud du graphique par rapport au métamodèle géré par l'ORM. Si le nœud n'est pas dans le modèle, il le supprime de la liste des nœuds de graphe. (Cette vérification doit être récursive et vérifier également chaque enfant)

Avant de trouver cela, j'avais essayé les projections et toutes les autres alternatives recommandées dans les documents Spring JPA / Hibernate, mais rien ne semblait résoudre le problème avec élégance ou au moins avec une tonne de code supplémentaire.

Modifié après votre commentaire:

Je m'excuse, je n'ai pas sous-entendu votre problème au premier tour, votre problème se produit au démarrage de spring-data, pas seulement lorsque vous essayez d'appeler findAll ().

Ainsi, vous pouvez maintenant parcourir l'exemple complet qui peut être extrait de mon github: https://github.com/bdzzaid/stackoverflow-java/blob/master/jpa-hibernate/

Vous pouvez facilement reproduire et résoudre votre problème dans ce projet.

En effet, les données Spring et hibernate ne sont pas capables de déterminer le graphique "sélectionné" par défaut et vous devez spécifier la manière de collecter l'option sélectionnée.

Donc, tout d'abord, vous devez déclarer les NamedEntityGraphs de la classe Answer

Comme vous pouvez le voir, il existe deux NamedEntityGraph pour la valeur d' attribut de la classe Answer

• Le premier pour tous Valeur sans relation spécifique avec la charge

• Le second pour la valeur Multichoice spécifique . Si vous supprimez celui-ci, vous reproduisez l'exception.

Deuxièmement, vous devez être dans un contexte transactionnel answerRepository.findAll () si vous souhaitez récupérer des données de type LAZY

@Entity
@Table(name = "answer")
@NamedEntityGraphs({
    @NamedEntityGraph(
            name = "graph.Answer", 
            attributeNodes = @NamedAttributeNode(value = "value")
    ),
    @NamedEntityGraph(
            name = "graph.AnswerMultichoice",
            attributeNodes = @NamedAttributeNode(value = "value"),
            subgraphs = {
                    @NamedSubgraph(
                            name = "graph.AnswerMultichoice.selected",
                            attributeNodes = {
                                    @NamedAttributeNode("selected")
                            }
                    )
            }
    )
}
)
public class Answer
{

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(updatable = false, nullable = false)
    private int id;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "value_id", referencedColumnName = "id")
    private Value value;
// ..
}