Discussion :

[Lethal]

Bonjour,

Je suis passé au EJB3, c'est super plus d'xml, les annotations et ... les entity qui sont maintenant des POJO, donc plus besoin de créer des DTO.

Par contre imaginons que je veuille lister par exemple des personnes ... mais juste leur nom, prénom et âge.
J'appelle mon sessionBean qui me récupère une liste d'entity "personne" (Avec un requête ejbq dans le genre "SELECT o from Personne o"). Pas de DTO donc je renvois cette liste directement à ma servlet pour ensuite les afficher dans ma JSP.
Mais voilà au lieu de récupérer une liste de 3 champs("Nom","Prénom","age"); j'ai récupéré toutes les infos de la table personne. Ça fait quand même beaucoup de ressources utilisées pour pas grand chose non ?

Donc ma question est "quel design pattern adopter pour vraiment récupérer les données dont j'ai besoin quand j'en ai besoin ? "

- Faire plutot des requetes "SELECT o.x , o.y, o.z from Table o" et construire le DTO correspondant afin de le renvoyer a ma "Vue".
- Mettre tous le champs en LAZY et fetcher qd j'en ai besoin(je ne suis même pas certain que ce soit possible)
- Utiliser une subtilité des EJB3 qui m'aurait échapée ?
- ...

Merci pour vos idées,réponses !

[DevServlet]

Tu peux très bien faire ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SELECT o.nom,o.prenom,... from Personne o)

et il te renverra une collection que tu devras recuperer en List<Object[]>, et caster.

[manblaizo]

- Utiliser une subtilité des EJB3 qui m'aurait échapée ?

En l'occurrence une subtilité de JPA 2.0, Constructor Expressions. En gros, tu crées un DTO avec un constructeur adéquat, et tu utilises l'opérateur NEW dans la requête SELECT.
Exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
package myapp;
 
public class PersonneDTO {
     private String nom, prenom;
     private int age;
 
     public PersonneDTO(String nom, String prenom, int age) {
          this.nom = nom; this.prenom = prenom; this.age = age;
     }
     ...
     // getters
}

...
Puis dans l'EJB, ou le DAO:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
String query = "SELECT NEW myapp.PersonneDTO(p.nom, p.prenom, p.age) FROM Personne p"
 
List<PersonneDTO> result = entityManager.createQuery(query, PersonneDTO.class).getResultList();

[Lethal]

Nikel, c'est exactement le genre de "subtilité" que je cherchais !

Poussons un peu plus loin. Ce qui me simplifie aussi la vie dans les ejb c'est les jointures.
Avec une requete EJBQL habituelle si je veux récupérer la liste des publications d'une personne par exemple ( dans mon entity Personne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 @OneToMany(cascade={CascadeType.REFRESH},mappedBy = "personne")
  private List<Publication> publicationList;

qui est en LAZY par défaut) je n'ai qu'a rajouter left join fetch p.listPublication à ma requete (et un distinct au début) et je récupère le tout.

par contre avec la requête

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

String query = "SELECT NEW myapp.PersonneDTO(p.nom, p.prenom, p.age,lp) FROM Personne p left join p.publicationList lp"

Il tente d'appeller le constructeur Personne(String,String,Publication) et pas Personne(String,String,List<Publication>). Ce qui est normal car c'est le même comportement qu'avec un tableau d'objet...

Vous avez une idée de ce que serait le meilleur moyen pour me retrouver au final avec une Liste de PersonneDTO comportant 2 String et une Liste de PublicationDTO ?

[DevServlet]

Je ne connais pas encore la syntaxe avec NEW mais pour ta question il te suffirait de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

String query = "SELECT p.nom,p.prenom,p.age ,lp FROM Personne p left join p.publicationList lp"

Tout simplement.

[Lethal]

Je ne connais pas encore la syntaxe avec NEW mais pour ta question il te suffirait de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

String query = "SELECT p.nom,p.prenom,p.age ,lp FROM Personne p left join p.publicationList lp"

Tout simplement.

Oui, comme dit précédement mais justement le problème est que si je fais ça et que j'ai par exemple 2 personnes qui on chacune 3 publications j'aurai

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
Nom1 , Prénom1, Age1 , publication1
Nom1 , Prénom1, Age1 , publication2
Nom1 , Prénom1, Age1 , publication3
Nom2 , Prénom2, Age2 , publication4
Nom2 , Prénom2, Age2 , publication5
Nom2 , Prénom2, Age2 , publication6

Puis je ne veux pas récupérer un tableaux d'objet de ma query mais bien une liste de DTO comme dit précédemment.

Mais le problème est qu'au lieu de récupérer une liste de publication dans mon constructeur de DTO personne, je récupère 1 publication. j'aimerais le meme comportement qu'avec les entitiy donc récupérer 2personnesDTO qui possèdent une Liste de publications.

Si il y a une méthode propre tant mieux sinon je ferai un truc du genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    Query lo_query = em.createQuery("SELECT NEW dto.PersonneDTO(p.id,p.nom,p.prenom,p.age,pl.libelle) from Personne p left join p.publicationList pl");
    List<PersonneDTO> lo_listP = lo_query.getResultList();
    PersonneDTO lo_lastP = new PersonneDTO(0L,"foo","foo",25L,"foo");
    PersonneDTO lo_curP;
 
 
    for(int i = 0 ; i < lo_listP.size() ; i++)
    {
      lo_curP = lo_listP.get(i);
      if(lo_curP.getId() == lo_lastP.getId())
      {
        lo_lastP.getPublicationList().addAll(lo_curQ.getPublicationList());
        lo_listP.remove(i);
        i--;
      }
      lo_lastP = lo_curP;
    }
 
    return lo_listP;

avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class PersonneDTO implements Serializable
{
  private Long id;
  private String nom;
  private String prenom;
  private Long age;
  private List<PublicationDTO> publicationList;
 
  public QuestionDTO(Long id,String nom,String prenom,Long age,String publicationlibelle)
  {
    publicationList = new ArrayList<PublicationDTO>();
    this.nom = nom;
    this.prenom = prenom;
    this.age = age
    this.publicationList.add(new PublicationDTO(publicationLibelle));
    this.id = id;
  }
 
  .....
 
}

[DevServlet]

J'ai un peu de mal à te suivre, j'ai pas très bien compris ta petite boucle, mais dis moi,qu'est ce qui te gene dans la récupération d'une collection pareille :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
Nom1 , Prénom1, Age1 , publication1
Nom1 , Prénom1, Age1 , publication2
Nom1 , Prénom1, Age1 , publication3
Nom2 , Prénom2, Age2 , publication4
Nom2 , Prénom2, Age2 , publication5
Nom2 , Prénom2, Age2 , publication6

Je n'ai pas encore utilisé le NEW comme je disais, mais si le but des objets DTO c'est constituer des POJO distincts dans un même objet, c'est pas bête. Mais pour ton pb, peux tu repreciser la question, je pense qu'il est faisable directement en JPQL.
En passant, tes variables JAVA ne sont pas bien nommés, jamais de lettre "_" dans les variables. fais un tour sur les best pratices JAVA.