Discussion :

[geforce]

Bonjour,

Je cherche un outil (avec ou sans un IDE comme NetBeans) qui me donne une façon de générais du code de met entity (spécifique a mois mais tés standard)
Par exemple a partir d’un Template (que je définis == une portion de code) plus ou moins paramétrable en devrais pouvoir le faire.

Ce qui m’a poussé à avoir ce besoin : je suis en charge de réalisé les entités d’un projet avec leur CRUD par défaut (Ajouter, supprimer, modifier, rechercher) je sais comme le faire mais comme j’ai plus de 100 entity j’ai besoin de les régénérais a tout moment selon ce Template.

Merci de m’indiquer une solution

[dark.jabberwock]

Je pense qu'un outil style Acceleo peut t'intéresser. Personnellement, je m'en suis servi pour une problématique quasi-similaire à la tienne. http://eclipse.org/acceleo/

J'avais un modèle UML et un template. Il me génère mes fichiers Java en sortie (définition de services notamment et config spring associée dans mon cas).

[OButterlin]

La partie CRUD peut être généralisée grâce aux génériques.
Reste la recherche selon critères qui doit être implémentée de manière spécifique, mais bon, ce n'est pas très gênant je trouve...
Exemple :

- interface

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
 
public interface GenericDAO<T, I extends Serializable>
{
    public T find(I id);
 
    public List<T> findAll();
 
    public T save(T t);
 
    public T update(T t);
 
    public void delete(I id);
 
    public void delete(T t);
}

- implémentation

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
public abstract class GenericDAOImpl<T, I extends Serializable> implements GenericDAO<T, I>
{
    protected Class<? extends T> clazz;
 
    /**
     * Constructeur générique
     */
    @SuppressWarnings("unchecked")
    protected GenericDAOImpl()
    {
        this.clazz = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }
 
    /**
     * Récupération de l'objet pour la clé recherchée
     */
    public T find(I id)
    {
        try
        {
            return (T) getEntityManager().find(clazz, id);
        }
        catch (Exception e)
        {
            return null;
        }
    }
 
    /**
     * Suppression de l'objet pour la clé recherchée
     */
    public void delete(I id)
    {
        delete(find(id));
    }
 
    /**
     * Suppression de l'objet
     */
    public void delete(T t)
    {
        t = (T)getEntityManager().merge(t);
        getEntityManager().remove(t);
    }
 
    /**
     * Ajouter
     */
    public T save(T t)
    {
        getEntityManager().persist(t);
        getEntityManager().flush();
        return (T) t; 
    }
 
    /**
     * Modifier un objet
     */
    public T update(T t)
    {
        T entity = (T) getEntityManager().merge(t);
        return (T) entity;
    }
 
 
    /**
     * Récupération de tous les enregistrements
     */
    @SuppressWarnings("unchecked")
    public List<T> findAll()
    {
        return getEntityManager().createQuery("select a from " + clazz.getName() + " a").getResultList();
    }
}

Ensuite, tu n'as plus qu'à créer la classe par entité.
Ci-joint un exemple

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
22
23
24
25
26
27
28
29
30
31
 
@Stateless(name="ArbcoeffEJB")
public class ArbcoeffEJBImpl extends GenericDAOImpl<Arbcoeff, Integer> implements ArbcoeffEJBLocal
{
    @PersistenceContext(unitName="ArborePU")
    protected EntityManager entityManager;
 
    /**
     * Entity Manager
     */
    public EntityManager getEntityManager()
    {
        return entityManager;
    }
 
    /**
     * Recherche des coefficients d'un dépôt
     */
    @SuppressWarnings("unchecked")
    public List<Arbcoeff> rechercheArbcoeff(Integer uidElement, DTOContexte dtoContexte)
    {
        StringBuilder sb = new StringBuilder();
        sb.append("select a from Arbcoeff a join fetch a.domaine b");
        sb.append(" where a.domaine.douid = :uidElement");
 
        Query query = entityManager.createQuery(sb.toString());
        query.setParameter("uidElement", uidElement);
 
        return query.getResultList();    
    }
}

avec son interface

Code :

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

1
2
3
4
5
@Local
public interface ArbcoeffEJBLocal extends GenericDAO<Arbcoeff, Integer>
{
    public List<Arbcoeff> rechercheArbcoeff(Integer uidElement, DTOContexte dtoContexte);
}

[dark.jabberwock]

Effectivement, l'utilisation des génériques pour la partie CRUD est très intéressante. Pourquoi n'y ai je pas pensé ?

Enfin, pour la partie non générique si tu pars d'un modèle UML ou ECore avec comme IDE Eclipse, la génération par Acceleo est très intéressante. C'est un gain de temps surtout si par la suite tu peux réutiliser tes templates pour d'autres projets.

[geforce]

Oui merci la méthode du générique est très intéressante sans doute je vais l'utilisés mais j'ai besoin de quelque chose de plus productif (vue le nombre d'entity que j'ai)

En m’a dit qu'il existe des logicielle qui permet de générés tout ce que l'on veut comme code en utilisant que un Template et une ligne de commande de cette outil et en généré ce que l'on a besoin (j'ai du code spécifique mais qui ce répète souvent selon un paramètre)

J’ai pas trouvés d'outil ou de mécanisme qui permet de faire ça ? (pour-ton je ne dois pas être le premier à avoir ce besoin)

[dark.jabberwock]

Personnellement, je ne vois pas comment un template peut générer tout seul ce dont tu as besoin. Pour moi il lui faut forcément un modèle sur lequel se référer ne serait ce que pour savoir quels sont les éléments à générer.

Si c'est bien du model to text qu'il te faut, il y a plusieurs implémentations actuellement :

• Acceleo
• Eclipse M2T
• MOFScript

Il y en a peut être d'autres. Si ce n'est pas ce genre de mécanisme, je ne peux pas t'aider plus que cela.