Discussion :

[clem_alain]

Bonjour,
Dans une application Web, j'arrive à faire de l'injection de dépendance dans une servlet, mais je n'arrive pas à le faire dans un bean et je voudrais bien continuer à respecter l'architecture MVC.
La servlet est là pour établir le lien entre les pages et les objets métiers, c'est donc me semble-t-il au Beans métiers de référencer les EJB.
Mais tout se passe comme si les beans n'avaient pas accès au contexte.
Quelqu'un a-t-il une idée ?
merci,

[salber]

Bonjour,
Dans une application Web, j'arrive à faire de l'injection de dépendance dans une servlet, mais je n'arrive pas à le faire dans un bean et je voudrais bien continuer à respecter l'architecture MVC.
La servlet est là pour établir le lien entre les pages et les objets métiers, c'est donc me semble-t-il au Beans métiers de référencer les EJB.
Mais tout se passe comme si les beans n'avaient pas accès au contexte.
Quelqu'un a-t-il une idée ?
merci,

Une chose importante, l’injection « classique » (sans web beans) ne marche que sur des composants managed (dont le cycle de vie est géré par le conteneur).

Dans quel composant veux tu injecter tes EJB ?
Comment fais tu cette injection ?
Peut on voir un exemple de code ?

[clem_alain]

Bonjour,
Evidemment l'exemple est simpliste, mais l'objectif est dans un premier temps de maîtriser l'environnement.
Je viens du monde .NET où j'ai une assez longue expérience et je dois acquérir des compétences dans J2EE, donc je commence simple.
D'une manière générale d'ailleurs je constate que l'on trouve de tout et n'importe quoi dans cet environnement, y compris du code proposé par les éditeurs qui ne fonctionne pas ou alors qui est incomplet ou bien obsolète.
J'ai un peu l'impression qu'on se gargarise de mots bien ronflants, mais que derrière il n'y pas grand chose. Par exemple on parle beaucoup de J2EE, EJB, ... et en réalité on fait des servlet/jsp/jstl (ce qui est déjà pas mal).
Donc si vous pouviez me dépêtrer, ce serait vraiment le bienvenu ;-)

Voici le contexte :

L'EJB :
package pkgCalcul;

Code :

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

1
2
3
4
5
6
7
8
import javax.ejb.Remote;
@Remote
public interface CalculerRemote {
    public float addition(float nb1, float nb2);
    public float soustraction(float nb1, float nb2);
    public float produit(float nb1, float nb2);
    public float division(float nb1, float nb2);
}

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
package pkgCalcul;
import javax.ejb.Stateless;
@Stateless(mappedName="CalculerRemote")
public class Calculer implements CalculerRemote {
    public Calculer() {
 
    }
    public float addition(float nb1, float nb2){
    	return (nb1 + nb2);
    }
    public float soustraction(float nb1, float nb2){
    	return (nb1 - nb2);
    }
    public float produit(float nb1, float nb2){
    	return (nb1 * nb2);
    }
    public float division(float nb1, float nb2){
    	return (nb1 / nb2);
    }
}

Le Bean de l'application Web :

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
package metier;
import pkgCalcul.*;
public class CalculBean {
    private float _nb1, _nb2, _resultat;
    private int _operation;
    @EJB(mappedName="CalculerRemote")
    private CalculerRemote unCalcul;
    public float getNb1() {
        return _nb1;
    }
    public void setNb1(float nb1) {
        this._nb1 = nb1;
    }
    public float getNb2() {
        return _nb2;
    }
    public void setNb2(float nb2) {
        this._nb2 = nb2;
    }
    public float getResultat() {
        return _resultat;
    }
    public void setResultat(float resultat) {
        this._resultat = resultat;
    }
    public int getOperation() {
        return _operation;
    }
    public void setOperation(int operation) {
        this._operation = operation;
    }
 
    public CalculBean() throws Exception{
    }
 
    public String Calculer() throws Exception{
        int operation = getOperation();
        try{
        switch (operation){
            case 0:
                setResultat(unCalcul.addition(getNb1(), getNb2()));
                break;
            case 1:
                setResultat(unCalcul.soustraction(getNb1(), getNb2()));
                break;
            case 2:
                setResultat(unCalcul.produit(getNb1(), getNb2()));
                break;
            case 3:
                setResultat(unCalcul.division(getNb1(), getNb2()));
                break;
        }
        return ("");
        }catch(Exception ex){
            throw ex;
        }
    }
}

La servlet :

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
public class Calcul extends HttpServlet {
    ...
    private String FaireCalcul(HttpServletRequest request) throws Exception {
        CalculBean rCalcul;
        String pageReponse;
        try {
            pageReponse = "/index.jsp";
            float nb1 = Float.parseFloat(request.getParameter("txtNb1"));
            float nb2 = Float.parseFloat(request.getParameter("txtNb2"));
            int operation = Integer.parseInt(request.getParameter("cbOperation"));
            float resultat = Calculer(operation, nb1, nb2);
            rCalcul = new CalculBean();
            rCalcul.setNb1(nb1);
            rCalcul.setNb2(nb2);
            rCalcul.Calculer();
            request.setAttribute("rCalc", rCalcul);
            return (pageReponse);
        } catch (Exception e) {
            throw new ServletException(e.getMessage());
        }
    }
    ...
}

[salber]

Evidemment l'exemple est simpliste, mais l'objectif est dans un premier temps de maîtriser l'environnement.
Je viens du monde .NET où j'ai une assez longue expérience et je dois acquérir des compétences dans J2EE, donc je commence simple.

Bienvenu dans le monde J2EE, le monde de l'Open.

D'une manière générale d'ailleurs je constate que l'on trouve de tout et n'importe quoi dans cet environnement, y compris du code proposé par les éditeurs qui ne fonctionne pas ou alors qui est incomplet ou bien obsolète.

La communauté est bien active dans ce monde mais il faut faire très attention aux sources . Il faut dire aussi qu'une chose est de trouver du code et une autre est de le faire fonctionner (dans un environnement adéquat).

J'ai un peu l'impression qu'on se gargarise de mots bien ronflants, mais que derrière il n'y pas grand chose. Par exemple on parle beaucoup de J2EE, EJB, ... et en réalité on fait des servlet/jsp/jstl (ce qui est déjà pas mal).

En réalité, les premiers pas dans ce monde ne sont jamais faciles. Mais avec un peu de recherches et de persévérances on fini par attendre le but.
Il faut chercher des repères, comprendre des expressions bizarres (ce que tu appelles les "mots bien ronflants" ). En général, ces expressions sont loin d être de « gros mots pour ne rien dire », ce sont très souvent des mots utilisés dans les différents JSR. Donc vouloir apprendre J2EE c'est accepter ces mots (Servlet, JSP, EJB, JPA, JPQL, etc...).

Donc si vous pouviez me dépêtrer, ce serait vraiment le bienvenu ;-)

En J2EE (sans webBeans et sans spring), tu ne peux utiliser l'injection que dans des classes gérées par un conteneur (Servlet, EJB, Managed Beans JSF, etc...). On ne peut pas faire de l’injection dans une classe simple . Ca veux dire que tu ne peux pas faire d'injection dans ta classe CalculBean.

[clem_alain]

Bonjour,
Effectivement j'ai trouvé la même indication ailleurs.
Un correspondant m'a précisé que cela avait changé avec J2EE6 et où l'on pouvait opter pour l'option CDI dans le descripteur de déploiement et que cela transformait tous les composants (au sens large du terme) en composants gérés ("managés") par le serveur d'applications.
J'ai testé, mais cela n'a pas eu l'effet escompté. Soit je m'y suis mal pris, soit c'était erroné.
J'ai tenté une expérience avec JSF (1.2) et là cela a fonctionné parfaitement. Cet environnement ressemble étrangement à ASP.NET d'ailleurs.
Bizarrement il ne semble pas très utilisé, sauriez-vous pourquoi et par voie de conséquence, faut-il investir dessus ou pas ?

[manblaizo]

Effectivement j'ai trouvé la même indication ailleurs.
Un correspondant m'a précisé que cela avait changé avec J2EE6 et où l'on pouvait opter pour l'option CDI dans le descripteur de déploiement et que cela transformait tous les composants (au sens large du terme) en composants gérés ("managés") par le serveur d'applications.

Oui, c'est bien ça, les choses ont changé avec Java EE6 (au passage, on ne dit pas/plus J2EE6); il suffit d'activer CDI (Contexts and Dependency Injection for Java EE6). C'est ce que salber a appelé WebBeans (en fait c'était son nom durant le développement de la JSR, ils l'ont renommé juste avant la sortie de EE6 parce que 'WebBeans' ne reflétait pas toute son offre...)

J'ai testé, mais cela n'a pas eu l'effet escompté. Soit je m'y suis mal pris, soit c'était erroné.

Normalement, il te suffit d'ajouter un fichier nommé beans.xml (fichier qui peut être totalement vide) dans le WEB-INF de ton application web, et tout est OK pour faire tes injections d'EJB dans un POJO simple.

J'ai tenté une expérience avec JSF (1.2) et là cela a fonctionné parfaitement. Cet environnement ressemble étrangement à ASP.NET d'ailleurs.
Bizarrement il ne semble pas très utilisé, sauriez-vous pourquoi et par voie de conséquence, faut-il investir dessus ou pas ?

Avec JSF ça a fonctionné parce que les beans sont gérés par un container qui donc se charge de faire l'injection, comme le dit salber à propos des managed beans.

JSF est le framework web Java le plus utilisé, juste un peu avant ou après Struts 1.x/2.x, mais ce n'est pas celui qui a la meilleure "presse". En tout cas, jusqu'à la version 1.2 incluse, JSF avait de sérieuses lacunes que beaucoup de développeurs n'arrêtaient pas de dénoncer, certains allant même jusqu'à prédire la mort du framework. Mais rien y a fait, JSF était toujours très utilisé par la majorité silencieuse, surtout qu'il y avait beaucoup de workarounds apportés par les différentes librairies de composants jsf (RichFaces, PrimeFaces, Tomahawk...) et surtout par des frameworks comme Seam.

La plupart des problèmes ont été résolus dans JSF 2.0, ce que tu devrais utiliser puisque tu fais ton apprentissage avec Java EE 6. JSF est devenu beaucoup plus simple à utiliser: plus facile maintenant de créer ses propres composants composites; utilise Facelets par défaut, qui est certainement le meilleur outil de templating actuellement; s'intègre naturellement avec les autres technologies EE6 (Bean Validation, CDI,...).
Bref, il faut l'essayer.