Apprendre où définir au mieux une NamedQuery proposée dans la spécification JPA avec le langage Java,
Un tutoriel de François-Xavier Robin
Le 2020-05-14 16:52:53, par Mickael Baron, Rédacteur
Bonjour,
François-Xavier Robin nous propose un tutoriel pour apprendre où définir au mieux une NamedQuery proposée dans la spécification JPA via le langage Java
Pour consulter le tutoriel : https://fxrobin.developpez.com/tutor...a-named-query/
N'hésitez pas à laisser des commentaires à la suite.
Mickael BARON pour l'équipe Java de Developpez.com
Retrouver les meilleurs cours et tutoriels pour apprendre le stockage de données avec JPA et le langage Java
François-Xavier Robin nous propose un tutoriel pour apprendre où définir au mieux une NamedQuery proposée dans la spécification JPA via le langage Java
Pour consulter le tutoriel : https://fxrobin.developpez.com/tutor...a-named-query/
N'hésitez pas à laisser des commentaires à la suite.
Mickael BARON pour l'équipe Java de Developpez.com
-
tchize_Expert éminent séniorArticle intéressant sur le concept. Je me sens d'autant plus concerné que je joue avec de gros projets où de multiples applications font une réutilisation d'un même data model. Et dans ce cas là, les @NamedQuery, c'est très limité, on ne peux pas changer le modèle à chaque fois qu'on veux changer une query dans une appli. Et le xml, c'est galère en refactoring
. Ton article va apporter de l'eau à mon moulin
J'aurais cependant plusieurs remarques:
1) ça a l'air bête, mais le projet maven sur github ne fonctionne pas 'out of the box' et crache des "No Persistence provider". C'est dommage vu qu'il viens en appuis de l'article.
2) VII. Le référenceur programmatique de NamedQuery => Ben je propose "VII. Enrôler les named queries"
3) C'est du chipo, mais lombok peut faire mieux. Pas besoin de répéter les getter / setter, d'ajouter le toString, etc alors que l'annotation @Data faite déjà tout le travail il me semble (mea culpa, je n'ai pas vraiment testé)
Code : 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23@Entity @Table(name="VIDEO_GAME") @Data public class VideoGame implements Serializable { @GeneratedValue @Setter(AccessLevel.PRIVATE) private Long id; private String name; @Enumerated(EnumType.STRING) @Column(name="GAME_GENRE") private GameGenre gameGenre; public VideoGame(String name, GameGenre gameGenre) { super(); this.name = name; this.gameGenre = gameGenre; } }
Elle contient pas mal de boilerplate code à réécrire sur chaque enum contenant des query custom. Dans ton exemple il n'y a que "VideoGameQuery", mais en pratique on peut se retrouver avec des centaines de query à gérer.
Une solution basique serait de laisser lombok gérer les getters et constructeurs sur le champ query, comme c'est le cas dans l'entity.
Une solution plus élégante à mon gout serait de jouer avec les annotations et les default methods de l'interface
Exemple:
une annotation custom:
Code : 1
2
3
4
5@Retention(RetentionPolicy.RUNTIME) @Target(value={FIELD}) public @interface EnumQuery { public String query() default ""; }
Code : 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27public interface RegistrableQuery { /** * @return la requête JPQL. */ default String getQuery(){ try { EnumQuery annotation = this.getClass().getField(((Enum<?>) this).name()).getDeclaredAnnotation(EnumQuery.class); if (annotation != null){ return annotation.query(); } else { throw new RuntimeException("enum "+this+" does not have a @EnumQuery annotation"); } } catch (NoSuchFieldException e) { throw new RuntimeException(this+" is a broken enum according to java specs. Should not happend"); } catch (ClassCastException e) { throw new RuntimeException(this+" is not an enum"); } }; /** * @return l'identifiant de la requête JPQL. */ default String getIdentifier() { return String.format("%s_%s", this.getClass(), ((Enum<?>)this).name()); } }
)
L'enum devient alors beaucoup plus simple à lire à mon avis:
Code : 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17public enum VideoGameQuery implements RegistrableQuery { /** * retourne les VideoGame en fonction de leur genre. * Argument JPQL attendu : gameGenre de type GameGenre. */ @EnumQuery(query="SELECT vg FROM VideoGame vg WHERE vg.gameGenre = :gameGenre") FIND_BY_GENRE, /** * retourne les VideoGame en fonction d'un nom approchant (LIKE). * Argument JPQL attendu : name de type String. */ @EnumQuery(query="SELECT vg FROM VideoGame vg WHERE vg.name LIKE :name") FIND_BY_NAME_LIKE; }
le 24/05/2020 à 13:48 -
fxrobinMembre chevronnéBonjour tchize_,
merci pour ton retour, ça fait plaisir.
Pour tes remarques :
1- ah oui étrange, je vérifierai le projet sur GitHub dès que possible. (L'article date de 2018 et a été intégré à DVP que récemment, donc il me faut vérifier l'ensemble).
2- oui, ton titre est bien mieux trouvé que le mien.
3- Alors pour l'usage de Lombok, je suis plus mitigé. Ma réponse est incluse dans mon article : https://fxrobin.developpez.com/tutor...ur-experience/
3 :-) - complètement d'accord sur tes propositions. Une petite "critique cependant" sur cette dernière : si une valeur de l'enum ne comporte l'annotation, ce n'est qu'au Runtime qu'on s'en rend compte.
Avec le constructeur qui impose une requête en paramètre c'est détecté à la compilation. Mais bon, on peut être mettre une requête complètement bidon aussi, je le reconnais.
3 - à bah moi aussi :-)
Au final je ferai un update de l'article sur mon blog en premier : https://www.fxjavadevblog.fr/Enum-JPA-Named-Query/
Puis sur DVP.
Merci à toi.le 25/05/2020 à 19:40 -
fxrobinMembre chevronnéVoilà, le projet sur GitHub est "réparé".
Il construit maintenant un "uber-jar" en incluant toutes dépendances.
Il suffit de faire un "mvn package" puis "java -jar ./target/named-queries-demo-0.0.1-SNAPSHOT.jar"
F.X.le 25/05/2020 à 20:36