Génération de code Standardisé

Version imprimable

19/10/2011, 15h17
geforce

Génération de code Standardisé

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
19/10/2011, 15h55
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).

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:

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:

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:

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:

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

20/10/2011, 11h43
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.
23/10/2011, 19h19
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) :aie:
24/10/2011, 08h28
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.