Stratégies de récupération JPA : JOIN FETCH, Entity Graph et Criteria API en contexte — avec Spring Boot & Quarkus

@Entity (1)
public class User {
    @Id (2)
    @GeneratedValue(strategy = GenerationType.IDENTITY) (3)
    private Long id;

    private String email;

    @ManyToMany(fetch = FetchType.LAZY) (4)
    @JoinTable( (5)
        name = "user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles = new HashSet<>(); (6)

    // Getters / Setters
}

@Entity
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // Getters / Setters
}

public interface UserRepository extends JpaRepository<User, Long> {

    @Query("SELECT u FROM User u JOIN FETCH u.roles WHERE u.email = :email") (1)
    Optional<User> findByEmailWithRoles(@Param("email") String email); (2)
}

var user = userRepository.findByEmailWithRoles("user@example.com")
                          .orElseThrow(() -> new UserNotFoundException("Utilisateur non trouvé"));
// Accès aux rôles sans risque de LazyInitializationException
var roles = user.getRoles();

@Entity
public class User extends PanacheEntity {
    public String email;

    @ManyToMany
    @JoinTable(
        name = "user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    public Set<Role> roles = new HashSet<>();
}

@Entity
public class Role extends PanacheEntity {
    public String name;
}

@ApplicationScoped (1)
public class UserService {

    public Optional<User> findByEmailWithRoles(String email) {
        return User.find("SELECT u FROM User u JOIN FETCH u.roles WHERE u.email = ?1", email)
                   .firstResultOptional();
    }
}

var user = userService.findByEmailWithRoles("user@example.com")
                       .orElseThrow(() -> new UserNotFoundException("Utilisateur non trouvé"));
// Accès aux rôles sans risque de LazyInitializationException
var roles = user.getRoles();

@Entity
@NamedEntityGraph(
    name = "User.withRoles", (1)
    attributeNodes = @NamedAttributeNode("roles") (2)
)
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String email;

    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(
        name = "user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles = new HashSet<>();

    // Getters / Setters
}

@Entity
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // Getters / Setters
}

public interface UserRepository extends JpaRepository<User, Long> {

    @EntityGraph(value = "User.withRoles", type = EntityGraph.EntityGraphType.FETCH) (1)
    Optional<User> findByEmail(String email);

    @EntityGraph(attributePaths = {"roles"}) (2)
    List<User> findAll();
}

// Utilisation de l'Entity Graph nommé
var user = userRepository.findByEmail("user@example.com")
                         .orElseThrow(() -> new UserNotFoundException("Utilisateur non trouvé"));
// Accès aux rôles sans risque de LazyInitializationException
var roles = user.getRoles();

// Utilisation de l'Entity Graph ad-hoc
var allUsers = userRepository.findAll();
// Tous les utilisateurs ont leurs rôles chargés

@Entity
@NamedEntityGraph(
    name = "User.withRoles",
    attributeNodes = @NamedAttributeNode("roles")
)
public class User extends PanacheEntity {
    public String email;

    @ManyToMany
    @JoinTable(
        name = "user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    public Set<Role> roles = new HashSet<>();
}

@Entity
public class Role extends PanacheEntity {
    public String name;
}

@ApplicationScoped
public class UserService {

    @Inject (1)
    EntityManager entityManager;

    // Méthode 1: Utilisation de l'Entity Graph nommé
    public Optional<User> findByEmailWithRoles(String email) {
        return entityManager.createQuery("SELECT u FROM User u WHERE u.email = :email", User.class)
                .setParameter("email", email)
                .setHint("jakarta.persistence.fetchgraph",
                         entityManager.getEntityGraph("User.withRoles"))
                .getResultStream()
                .findFirst();
    }

    // Méthode 2: Création dynamique d'un Entity Graph
    public List<User> findAllWithRoles() {
        EntityGraph<?> graph = entityManager.createEntityGraph(User.class);
        graph.addAttributeNodes("roles");

        return entityManager.createQuery("SELECT u FROM User u", User.class)
                .setHint("jakarta.persistence.fetchgraph", graph)
                .getResultList();
    }
}

@Entity
@NamedEntityGraphs({
    @NamedEntityGraph(
        name = "User.withRoles",
        attributeNodes = @NamedAttributeNode("roles")
    ),
    @NamedEntityGraph(
        name = "User.withRolesAndDepartment",
        attributeNodes = {
            @NamedAttributeNode("roles"),
            @NamedAttributeNode(value = "department", subgraph = "departmentGraph")
        },
        subgraphs = {
            @NamedSubgraph(
                name = "departmentGraph",
                attributeNodes = @NamedAttributeNode("manager")
            )
        }
    )
})
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String email;

    @ManyToMany(fetch = FetchType.LAZY)
    private Set<Role> roles = new HashSet<>();

    @ManyToOne(fetch = FetchType.LAZY)
    private Department department;

    // Getters / Setters
}

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToOne(fetch = FetchType.LAZY)
    private User manager;

    // Getters / Setters
}

@EntityGraph(value = "User.withRolesAndDepartment", type = EntityGraph.EntityGraphType.FETCH)
Optional<User> findByEmail(String email);

// Extension de PanacheRepository pour ajouter le support des Entity Graphs
@ApplicationScoped
public class UserRepository implements PanacheRepository<User> {

    @Inject
    EntityManager em;

    // Méthode utilisant un Entity Graph
    public Optional<User> findByEmailWithRoles(String email) {
        // Obtenir l'Entity Graph nommé
        EntityGraph<?> graph = em.getEntityGraph("User.withRoles");

        // Utiliser l'Entity Graph avec une requête Panache
        return find("email", email)
                .withHint("jakarta.persistence.fetchgraph", graph)
                .firstResultOptional();
    }

    // Méthode avec Entity Graph dynamique
    public List<User> listAllWithRoles() {
        // Créer un Entity Graph dynamique
        EntityGraph<User> graph = em.createEntityGraph(User.class);
        graph.addAttributeNodes("roles");

        // Appliquer l'Entity Graph à la requête
        return findAll()
                .withHint("jakarta.persistence.fetchgraph", graph)
                .list();
    }
}

@Inject
UserService userService;

// Utilisation de l'Entity Graph nommé
var user = userService.findByEmailWithRoles("user@example.com")
                      .orElseThrow(() -> new NotFoundException("Utilisateur non trouvé"));
// Accès aux rôles sans risque de LazyInitializationException
var roles = user.roles;

// Utilisation de l'Entity Graph dynamique
var allUsers = userService.findAllWithRoles();
// Tous les utilisateurs ont leurs rôles chargés

// Classe utilitaire pour les critères de recherche d'utilisateurs
public class UserCriteria {

    // Interface fonctionnelle pour définir un critère
    @FunctionalInterface
    public interface Criterion {
        void apply(CriteriaBuilder cb, CriteriaQuery<?> query, Root<User> root, List<Predicate> predicates);

        // Méthodes par défaut pour combiner les critères
        default Criterion and(Criterion other) {
            return (cb, query, root, predicates) -> {
                this.apply(cb, query, root, predicates);
                other.apply(cb, query, root, predicates);
            };
        }

        default Criterion or(Criterion other) {
            return (cb, query, root, predicates) -> {
                List<Predicate> thisPredicates = new ArrayList<>();
                List<Predicate> otherPredicates = new ArrayList<>();

                this.apply(cb, query, root, thisPredicates);
                other.apply(cb, query, root, otherPredicates);

                if (!thisPredicates.isEmpty() && !otherPredicates.isEmpty()) {
                    predicates.add(cb.or(
                        cb.and(thisPredicates.toArray(new Predicate[0])),
                        cb.and(otherPredicates.toArray(new Predicate[0]))
                    ));
                } else if (!thisPredicates.isEmpty()) {
                    predicates.addAll(thisPredicates);
                } else if (!otherPredicates.isEmpty()) {
                    predicates.addAll(otherPredicates);
                }
            };
        }
    }

    // Critères réutilisables
    public static Criterion hasEmail(String email) {
        return (cb, query, root, predicates) -> {
            if (email != null && !email.isEmpty()) {
                predicates.add(cb.like(root.get("email"), "%" + email + "%"));
            }
        };
    }

    public static Criterion hasRole(String roleName) {
        return (cb, query, root, predicates) -> {
            if (roleName != null && !roleName.isEmpty()) {
                Join<User, Role> roleJoin = root.join("roles");
                predicates.add(cb.equal(roleJoin.get("name"), roleName));
                query.distinct(true); // Évite les doublons
            }
        };
    }
}

// Repository Panache avec support des critères
@ApplicationScoped
public class UserRepository implements PanacheRepository<User> {

    @Inject
    EntityManager em;

    // Méthode générique pour appliquer des critères
    public List<User> findByCriteria(UserCriteria.Criterion criterion) {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<User> query = cb.createQuery(User.class);
        Root<User> root = query.from(User.class);

        List<Predicate> predicates = new ArrayList<>();

        // Application du critère
        if (criterion != null) {
            criterion.apply(cb, query, root, predicates);
        }

        // Construction de la requête
        if (!predicates.isEmpty()) {
            query.where(predicates.toArray(new Predicate[0]));
        }

        // Tri par défaut
        query.orderBy(cb.asc(root.get("email")));

        // Exécution de la requête
        return em.createQuery(query).getResultList();
    }

    // Exemple d'utilisation
    public List<User> findAdmins() {
        return findByCriteria(
            UserCriteria.hasEmail("john").and(UserCriteria.hasRole("ADMIN"))
        );
    }
}

// Exemple d'utilisation dans un service
@ApplicationScoped
public class UserService {

    @Inject
    UserRepository userRepository;

    public List<User> findActiveAdmins() {
        return userRepository.findByCriteria(
            UserCriteria.hasRole("ADMIN").and(UserCriteria.hasEmail("active"))
        );
    }

    public List<User> findSupportOrSalesUsers() {
        return userRepository.findByCriteria(
            UserCriteria.hasRole("SUPPORT").or(UserCriteria.hasRole("SALES"))
        );
    }
}