GWT : Créer un service RPC

Le framework GWT permet depuis le client JavaScript de faire des appels RPC (Remote Procedure Call ou appels de procédures distantes) au serveur GWT.

L’objectif est de permettre au JavaScript client d’exécuter des méthodes sur le serveur et d’en récupérer le résultat. Tout cela de façon totalement asynchrone (Ajax). Les échanges entre le client et le serveur sont faites de façon asynchrone car la plupart des navigateurs n’accordent qu’un seul Thread pour exécuter le JavaScript.

Infrastructure RPC

Pour permettre à JavaScript de faire des appels RPC il faut écrire le service côté serveur et la vue qu’en a le client. Le code d’un service RPC est séparé en deux packages : fr.mkhelif.gwt.client et fr.mkhelif.gwt.server.

Dans ce tutoriel nous allons créer un service Hello qui va tout simplement dire bonjour.

Package client

Le package client doit contenir les interfaces décrivant les méthodes du service.

/**
 * @author Marwan KHELIF
 */
public interface HelloService extends RemoteService {
	public String sayHello (String name);
} // HelloService

Voilà le code du service côté client qui sera utilisé pour effectuer des appels RPC en JavaScript.

On crée alors une interface qui sera utilisé par GWT pour effectuer les appels asynchrone. Cette interface est identique à celle que l’on vient d’écrire sauf que toutes les méthodes doivent retourner void et posséder un dernier argument en plus.

/**
 * @author Marwan KHELIF
 */
public interface HelloServiceAsync {
	public void sayHello (String name, AsyncCallback callback);
} // HelloServiceAsync

La classe AsyncCallBack contient deux méthodes qui permettent de gérer le résultat de l’appel :

public void onSuccess (Object result)
public void onFailure (Throwable ex)

Package server

Le package server (peut être nommé différemment) contient le code des services définis dans le package client.

Voilà donc notre implémentation du service Hello :

/**
 * @author Marwan KHELIF
 */
public class HelloServiceImpl extends RemoteServiceServlet implements HelloService {
	public String sayHello (String name) {
		return "Hello " + name + "!";
	} // sayHello ()
} // HelloService

Voilà notre service est prêt à fonctionner, il faut maintenant le rendre disponible aux clients. Pour cela il faut modifier le fichier de l’application GWT : MyApplication.gwt.xml

<module>
	
	<inherits name="com.google.gwt.user.User" />

	


	<servlet path="/hello" class="fr.mkhelif.gwt.server.HelloServiceImpl" />
</module>

Voilà notre service RPC est prêt à l’emploi.

Échange de données

Afin d’échanger des données entre le client (JavaScript) et le serveur (Java) il faut sérialiser les données pour qu’elles puissent transiter par le protocole HTTP. La sérialisation fournie avec GWT est différente de celle de Java.

Un type d’objet peut être utilisé en paramètre ou en retour d’une méthode de Service si c’est :

1. un type primitif : int, char, byte, double, boolean…
2. un objet de type : String, Date ou un wrapper de type primitif (Double, Long, Integer, Float, Boolean, …).
3. un tableau d’objets sérialisables.
4. une classe utilisateur qui implémente com.google.gwt.user.client.rpc.IsSerialisable ou java.io.Serialisable.

Dans notre exemple nous n’utilisons que le type String, il n’y a donc aucun problème de sérialisation.

Appel d’un service GWT

Une fois notre service crée, il faut effectuer des appels a sa méthode sayHello. Pour cela il faut demander à GWT de nous donner une référence vers ce service puis on appelle la méthode.

Instanciation du service

Pour instancier le service il suffit d’appeler :

HelloServiceAsync service = (HelloServiceAsync) GWT.create (HelloService.class);

Le cast de HelloService vers HelloServiceAsync est toujours sûr car l’objet Proxy créé implémente l’interface asynchrone.

Association du service à l’URL

Une fois notre service instancié il faut le lier avec le point d’entrée du service sur le serveur : /hello. Pour cela on effectue l’appel suivant :

((ServiceDefTarget) service).setServiceEntryPoint (GWT.getModuleBaseURL () + "/hello");

Voilà le service est mappé avec le serveur, on peut effectuer l’appel à la méthode.

Appel d’une méthode de service

Pour appeler la méthode du service :

service.sayHello ("Marwan KHELIF", new AsyncCallBack () {
	public void onFailure (Throwable caught) {
		// Traitement en cas d'erreur
	} // onFailure ()

	public void onSuccess (Object result) {
		// Traitement en cas de succès
		Window.alert ((String) result);
	} // onFailure ()
});

Voilà la méthode a été appelée sur le service RPC.

Conclusion

Les services RPC est l’un des points les plus importants du framework GWT. Ils permettent d’effectuer très simplement des appels au serveur en JavaScript et ainsi mettre à jour l’interface graphique grâce aux données.