Intergiciels Heuristiques Contraintes Composants Agile Vivado Agents

M2

TD n°1

Le but du TD est de comprendre comment faire intéragir des composants entre eux ou d'y accéder. Grosso modo il faut réussir à réaliser ça :

                                   Serveur Wildfly
                      +---------------------------------------+
                      |                                       |
   +--------+         |  +--------------+   +--------------+  |     +----------+
   | Client |---------|  | Calculatrice |   |   Addition   |  |     |   JPA    |
   +--------+         |  +--------------+   +--------------+  |-----|  entity  |
                      |                     | Soustraction |  |     +----------+
                      |                     +--------------+  |
                      |                     | Multiplicat. |  |
                      |                     +--------------+  |
                      |                     |   Division   |  |
                      |                     +--------------+  |
                      |                                       |
                      +---------------------------------------+

Notes :

• Pour l'instant, on ne s'occupe pas de de la partie JPA.
• Il y a plein de trucs utiles ici si vous voulez comprendre par vous même

Création du bean pour les opérations

Il faut tout d'abord créer un stateless bean qui va fournir un moyen de réaliser les opérations (addition, etc.). Il est possible de créer un bean qui s'occupe de toutes les opérations ou un bean par opération.

Dans Eclipse, il faut créer un projet File -> New -> Other et ensuite aller dans EJB et EJB project.

Il faut ensuite créer un composant local, un composant remote et le bean en lui même.

Dans le fichier OperationBean.java :

package Operation;

import javax.ejb.Stateless;

@Stateless
public class OperationBean implements OperationRemote, OperationLocal {
    @Override
    public int ajouter(int a, int b) {
      return a + b;
    }
}

Dans le fichier OperationLocal.java :

package Operation;

import javax.ejb.Local;

@Local
public interface OperationLocal {
  public int ajouter(int a, int b);
}

Dans le fichier OperationRemote.java :

package Operation;

import javax.ejb.Remote;

@Remote
public interface OperationRemote {
  public int ajouter(int a, int b);
}

Note : Si les imports javax.ejb.* marchent pas, il faut faire clique droit sur le projet, ensuite aller dans Properties et après Targeted runtimes et là il faut sélectionner le serveur Wildlfy.

Si vous ne l'avez pas configuré, il faut cliquer sur New et sélectionner dans la fenêtre qui s'affiche Wildfly 14 runtime (ou la version que vous avez téléchargé) et cliquer sur Browse, sélectionner le dossier dans lequel se trouve le Wildfly décompressé et cliquer sur Finish.

Finalement, pour déployer le projet sur le serveur Wildfly, il faut lancer le projet dans Eclipse et sélectionner "Run on server".

Pour voir si le composant a bien été déployé, il est possible de vérifier en allant sur http://localhost:9990/. Il faut ensuite rentrer l'utilisateur et le mot de passe et cliquer sur "Deployments".

Création du client

Le client est une application Java classique qui va essayer de communiquer avec les composants déployés sur le serveur Wildfly.

Toute la démarche est expliquée dans le lien donné en haut de la page mais il faut grosso modo créer un projet Java classique dans Eclipse, faire clique droit dessus, aller dans Properties et ensuite Java Build Path, cliquer sur Add External JARs et sélectionner le fichier [dossier wildfly]/bin/client/jboss-client.jar.

Ensuite, il faut créer le client en lui même :

package ehbienlebonjour;

import java.util.Hashtable;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import Operation.OperationBean;
import Operation.OperationRemote;

public class Client {

    public static void main(String[] args) throws Exception {
        invokeStatelessBean();
    }

    private static void invokeStatelessBean() throws NamingException {
        final OperationRemote statelessRemoteCalculator = lookupRemoteStatelessCalculator();

        System.out.println("Composant obtenu.");

        int a = 204;
        int b = 340;

        System.out.println("Addition de " + a + " et " + b + " via le remote bean");

        int sum = statelessRemoteCalculator.ajouter(a, b);
        System.out.println("La calculette a retourné = " + sum);
    }

    private static OperationRemote lookupRemoteStatelessCalculator() throws NamingException {
        final Hashtable jndiProperties = new Hashtable();

        jndiProperties.put(Context.URL_PKG_PREFIXES, "org.jboss.ejb.client.naming");

        final Context context = new InitialContext(jndiProperties);

        final String appName       = "";
        final String moduleName    = "Operation";
        final String distinctName  = "";
        final String beanName      = OperationBean.class.getSimpleName();
        final String viewClassName = OperationRemote.class.getName();

        return (OperationRemote) context.lookup("ejb:" + appName + "/" + moduleName + "/" + distinctName + "/" + beanName + "!" + viewClassName);
    }
}

Finalement, il faut ajouter un fichier jboss-ejb-client.properties disponible via le CLASSPATH (le plus simple est de le claquer dans le dossier src du projet) avec le contenu suivant :

endpoint.name=client-endpoint
remote.connectionprovider.create.options.org.xnio.Options.SSL_ENABLED=false

remote.connections=default

remote.connection.default.host=localhost
remote.connection.default.port=8080
remote.connection.default.connect.options.org.xnio.Options.SASL_POLICY_NOANONYMOUS=false

remote.connection.default.username=mouloud
remote.connection.default.password=mouloud

Création de la calculatrice

Il faut recréer un projet de type EJB pour réaliser la calculatrice qui va appeler le bean que l'on a créé en premier.

Deux possibilités (au moins) :

• Ou re-créer un projet comme le premier avec un Bean qui fait appel au OperationBean (et changer le Bean que l'on appelle dans le client)
• Ou créer un servlet (par exemple) qui fait appel au premier Bean créé

Pour créer un servlet, il faut créer un "Dynamic Web Project" dans Eclipse et. Il faut cocher la case "Generate web.xml deployment descriptor" et inclure

Il faut ensuite créer le servlet en lui même.

package Calculatrice;

import java.io.IOException;
import java.io.Writer;

import javax.ejb.EJB;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import Addition.OperationRemote;

@WebServlet("/addition")
public class CalculetteServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    @EJB
    private OperationRemote operation;

    public CalculetteServlet() {
        super();
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        Integer a = Integer.valueOf(request.getParameter("a"));
        Integer b = Integer.valueOf(request.getParameter("b"));

        Writer out = response.getWriter();

        out.write("<html><head><title>Resultat</title></head><body>");
        out.write("Resulat = " + operation.ajouter(a, b));
        out.write("</body></html>");

        out.flush();
        out.close();
    }

    /* Appelées par l'annotation @EJB */
    public OperationRemote getOperation() {
        return this.operation;
    }

    public void setOperation(OperationRemote operation) {
        this.operation = operation;
    }
}

Et après il faut faire la merde habituelle pour rajouter le premier projet avec les beans dans le build path de ce projet ci.

Finalement, il faut le déployer sur le serveur Wildfly (en faisant clique droit sur le projet et ensuite Run as -> Run on server) et aller à l'adresse http://localhost:8080/Calculatrice/addition?a=10&b=30 (en remplaçant dans l'URL Calculatrice par le nom de votre projet Eclipse).