Introduction à GWT par Alexandre PUGEAT



Communication

Présentation

Une application web est basée sur une architecture client-serveur. L'utilisateur communique le plus souvent avec le serveur via un navigateur web tel que Firefox ou Internet Explorer.

Généralement, la communication entre le serveur et le client utilise le protocole HTTP. Le framework GWT propose un modèle homogène entièrement asynchrone, RPC, Remote Procedure Call.

RCP combine les technologies AJAX et HTTP pour échanger des objets JAVA entre le client et le serveur. Contrairement à RMI ou Corba, les objets sont sérialisés pour les transferts. La sérialisation a pour effet de restreindre la taille des objets échangés.

Un service RPC peut être considéré comme une servlet Java.

Toutefois, il est possible d'utiliser JSON pour la communication entre le client et le serveur. A noter qu'il est tout à fait envisageable d'imaginer un client GWT avec un serveur non JAVA.



GWT RPC

L'API RPC fournie par le framework GWT est solution préconisée par Google. L'architecture de la librairie présentée ci-dessous montre comment implémenter une communication aynchrone RPC :

GWT Logo


Pour résumer, il faut définir l'interface d'un service côté client et son implémentation côté serveur.



Exemple

Dans cette partie, je vais présenter étape par étape comment implémenter un service RPC.

Tout d'abord, on définit notre service synchrone en héritant de RemoteService : 


package com.example.foo.client;

import com.google.gwt.user.client.rpc.RemoteService;

public interface MyService extends RemoteService {
  public String myMethod(String s);
}

Ensuite, on implémente le service côté serveur en héritant de RemoteServiceServlet :


package com.example.foo.server;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import com.example.client.MyService;


public class MyServiceImpl extends RemoteServiceServlet implements
    MyService {

  public String myMethod(String s) {
    // Do something interesting with 's' here on the server.
    return s;
  }
}

Puis, on déclare l'interface asynchrone :


package com.example.foo.client;

interface MyServiceAsync {
  public void myMethod(String s, AsyncCallback callback);
}

La dernière étape consiste à déclarer la servlet dans le fichier web.xml :


<servlet>
  <servlet-name>myServiceImpl</servlet-name>
  <servlet-class>
    com.example.foo.server.MyServiceImpl
  </servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>myServiceImpl</servlet-name>
  <url-pattern>/com.example.foo.Foo/myService</url-pattern>
</servlet-mapping>

Le service est accessible à l'adresse : /com.example.foo.Foo/myService

Enfin, voici un appel asynchrone depuis notre Entry Point :


public class Foo implements EntryPoint {
      private MyServiceAsync myService = (MyServiceAsync) GWT.create(MyService.class);

      public void onModuleLoad() {
        // ... ajout des composants, design, placement...
      }

      void send (String message) {
          myService.myMethod(message, new AsyncCallback() {

            public void onFailure(Throwable caught) {
              Window.alert("RPC to myMethod() failed.");
            }

            public void onSuccess(String result) {
              label.setText(result);
            }
          });
      }
}


<< Environnement de développement Design Pattern >>

GWT Logo