Relation Entity JPA <--> Table SGBD

Version imprimable

22/07/2011, 16h32
scat64

Relation Entity JPA <--> Table SGBD

Bonjour,

nouveau dans JPA, ma question porte sur la meilleur façon de faire pour modéliser côté Java une projection de données de ma base partant de 2 tables (voire plus par la suite). Voici mon cas :

Table Composant
id ---> (clé primaire)
name

Table Version
id ---> (clé primaire)
composant_id ---> clé étrangère sur id de la table Composant
version
date

exemple :
Table Composant : 1 enregistrement
1 (id de table)
toto

Table Version : 2 enregistrements
1 (id table)
1(id sur toto)
v2.0
22/07/2011

2 (id table)
1(id sur toto)
v1.5
19/07/2011

Je veux obtenir le résultat :
toto
v2.0
22/07/2011

J'ai aussi la contrainte d'unicité {composant_id,date} pour la table Version

Je veux obtenir un objet ComposantLastVersion (entity ? simple pojo ? bean... je ne sais pas) qui représente un composant dont la version est la plus récente (où null si aucune version n'est trouvée pour ce composant).
J'ai une idée de la requête à effectuer (encore qu'en JPQL c'est pas gagné :?)
Mais je ne sais pas comment faire à l'aide d'annotation JPA (ou autre) pour représenter cet objet ComposantLastVersion

Avez vous des idées à me fournir ?
Aussi, je ne peux pas modifier ce modèle.

Merci d'avance.

comme il faut que j'avance, j'ai décidé de mixer 2 entities en un bean que j'expose dans ma JSP à la fin.
Le code est le suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public List<ComposantVersionViewBean> getComposantsWithCurrentVersion() {
 
        StringBuilder sb = new StringBuilder();
        sb.append("select c,v from Composant c,Version v ");
        sb.append("where v.composant.id = c.id ");
        sb.append("and v.date = (");
        sb.append("select max(v1.date) from Version v1 ");
        sb.append("where v1.composant.id = c.id)");
        try {
            Query q = emDSIInfo.createQuery(sb.toString());        
            List<Object[]> results = q.getResultList();
            List<ComposantVersionViewBean> composantsVersion = new ArrayList<ComposantVersionViewBean>();
            for(Object[] object : results) {
                Composant composant = (Composant) object[0];
                Version version = (Version) object[1];
                ComposantVersionViewBean cv = new ComposantVersionViewBean(composant,version.getVersion());
                composantsVersion.add(cv);
            }
            return composantsVersion;
        } catch(NoResultException e) {
            log.info("Il n'y a pas de listes de composants avec une version récente (pb init peut-être) ");
            return null;
        }

Mais je suis preneur de toutes remarques.
J'ajoute que cette méthode se trouve dans un DAO déclaré dans ma configuration spring et dont le scope est singleton (par défaut). N'y a-t-il pas un problème de concurrence d'accès lors de la construction de la requête du coup ?
Je me perds un peu.(je vais peut-être aller du coup sur le forum consacré à spring:mouarf:)

Je reviens sur ma première solution qui est de créer un bean destiné seulement à l'affichage. En fait, il est probable qu'à l'avenir, dans mon application, j'ai de nombreux cas comme celui là. Par conséquence, je vais obtenir une multitutes de beans presque identiques à mes entities.

J'ai donc opté pour une seconde solution qui consiste à ajouter des properties pour l'affichage dans mes entites en utilisant l'annotation @transient.

Dans l'exemple précédent, ça revient à écrire l'entity
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 @Entity public class Composant implements serializable { @Id private int id; private String name; @Transient private String version; //getter and setter ... }
En résumé, tout celà concerne des problèmes à la conception. Comme je débute en JPA (ORM en général), je cherche à appliquer les meilleurs pratiques.