Tutoriel sur le développement d'applications Web avec GWT 2.6 et Eclipse Luna

Marc Autran

Ce tutoriel présente le développement d'applications Web avec GWT version 2.6 et l'environnement de développement Eclipse Luna.

Pour réagir au contenu de cet article, un espace de dialogue vous est proposé sur le forum Commentez  .

- Titre : Tutoriel sur le développement d'applications Web avec GWT 2.6 et Eclipse Luna

- Auteur : Marc Autran

- Parution : 30 mars 2015

- Public visé :

- Licence : Copyright ® 2015 Marc Autran. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- II. Installation de l'environnement

- II-A. Prérequis

- II-B. Installation de GWT dans l'environnement de développement

- II-C. Environnement de production

- III. Le cahier des charges

- IV. Développement de l'application

- IV-A. Création du squelette de l'application

- IV-B. Création de la classe principale

- IV-C. Développement de l'interface graphique

- IV-D. Développement du service RPC

- IV-E. Consommer le service

- V. Test de l'application avec Super Dev Mode

- VI. Conclusion et remerciements

I - Introduction

Le but de cet article est de présenter ce qu'offre le Framework GWT pour la création d'interfaces Web riches reposant sur la technologie AJAX et la consommation de services distants en utilisant la technologie asyncronous RPC.

Les bibliothèques et versions d'Eclipse utilisées pour les besoins de l'article :

- JDK Oracle 7 ;

- Eclipse JEE LUNA ;

- GWT 2.6 ;

- Google Plugin pour ECLIPSE 3.8.

II - Installation de l'environnement

II-A - Prérequis

Il faut en premier lieu disposer au minimum du JDK 7 ou 8, la version 9 n'étant à ce jour proposée par ORACLE qu'en « test release ».

Le deuxième prérequis est l'environnement de développement intégré Eclipse. Disponible pour tous les systèmes d'exploitation sur le site de téléchargement de la fondation Eclipse, il faut choisir la déclinaison JEE for web developpers. Cet article s'appuie sur la version Eclipse LUNA.

Dans la mesure où ce tutoriel s'adresse à un public connaissant déjà JAVA et un IDE, il ne détaillera pas l'installation de ces deux applicatifs de base pour faire du développement Web avec JEE.

II-B - Installation de GWT dans l'environnement de développement

Nous installerons GWT directement depuis Eclipse : menu Help -> Eclipse MarketPlace.

Depuis l'onglet Search de la boite de dialogue Eclipse Marketplace, on lancera une recherche avec le mot GWT pour faire apparaître le plugin GWT pour Eclipse.

Une fois le plugin choisi, il vous proposera les modules que vous pouvez installer. Je conseille de ne pas prendre le module relatif à Android qui ne nous intéresse pas dans le cadre de cet article.

Veuillez ignorer également les alertes de sécurité qui nous informent que le plugin n'est pas signé.

II-C - Environnement de production

Le but de ce tutoriel est de créer et utiliser un service distant avec GWT RPC, ce que nous ferons avec l'environnement de développement déjà installé.

Pour déployer cette solution sur un environnement de production, il faut télécharger un serveur JEE simple (servlet et JSP) tel que TOMCAT qui s'administre facilement avec Eclipse. Mais ce processus de déploiement en production ne sera pas décrit dans cet article.

III - Le cahier des charges

On souhaite développer un écran Web, permettant d'entrer deux nombres, puis de choisir de les multiplier ou de les additionner. L'interface graphique utilisateur se présentera comme ci-dessous :

Le cahier des charges nous impose également d'avoir le traitement métier qui soit dissocié de l'interface graphique. On aura donc un objet métier que l'on désignera OperatorService, aussi éloigné que l'on souhaite et qui nous fournira deux méthodes : additionner et multiplier. Cette architecture nous fait immédiatement penser à la consommation d'un service Web en REST ou en SOAP. Néanmoins un grand nombre de tutoriels illustrent parfaitement cette technologie et dans le cadre de cet article, nous invoquerons ce service distant via GWT RPC.

IV - Développement de l'application

IV-A - Création du squelette de l'application

Le plugin GWT permet dans Eclipse de créer très facilement des applications GWT. En l'occurrence, la barre des boutons sous le menu s'est enrichie d'une icône Google qui fait apparaître un menu. Dans ce menu, on choisira le sous-élément New Web Application Project…

Une boite de dialogue nouveau projet apparaît. Il faut y préciser le nom du projet et le nom du package qui contiendra le code source développé. Les autres champs peuvent garder leur valeur par défaut. Il faut également décocher l'option Generate project sample code pour créer un projet vierge.

Le squelette de notre application Calculatrice est maintenant créé.

Nous allons créer deux sous-packages : com.calcul.client et com.calcul.server.

Le package x.y.client contiendra l'interface graphique utilisateur et le stub du service distant.

Le package server contiendra la Servlet distante qui implémentera le service.

On obtient dans l'explorateur de projet le squelette suivant.

La classe principale dite de départ de l'application s'appellera Calculatrice. On doit indiquer dans le fichier Calculatrice.gwt.xml que la classe Calculatrice est le point d'entrée de l'application.

Voici d'ailleurs le fichier Calculatrice.gwt.xml à ajouter dans le package com.calcul :

1. <?xml version="1.0" encoding="UTF-8"?>

3. <!DOCTYPE module PUBLIC "-//Google Inc.//DTD Google Web Toolkit 2.6.0//EN"

4. "http://google-web-toolkit.googlecode.com/svn/tags/2.6.0/distro-source/core/src/gwt-module.dtd">

5. <module rename-to='calculatrice'>

6. <!-- appliquer le web toolkit principal                        -->

7. <inherits name='com.google.gwt.user.User'/>

9. <!-- appliquer le style d'IHM GWT par defaut. vous pouvez       -->

10. <!-- changer le theme de votre application GWT en decommentant  -->

11. <!-- une des lignes ci-dessous                                  -->

12. <inherits name='com.google.gwt.user.theme.clean.Clean'/>

13. <!-- <inherits name='com.google.gwt.user.theme.standard.Standard'/> -->

14. <!-- <inherits name='com.google.gwt.user.theme.chrome.Chrome'/> -->

15. <!-- <inherits name='com.google.gwt.user.theme.dark.Dark'/>     -->

17. <!-- Specifier le point d'entree                        -->

18. <entry-point class='com.calcul.client.Calculatrice'/>

20. <!-- activer le SuperDevMod -->

21. <add-linker name="xsiframe"/>

22. </module>

À la lecture de ce fichier, on comprend qu'une application GWT se décompose en modules et que notre application est constituée d'un seul module.

Il y a un tag réservé au Super Dev Mode. Cette fonctionnalité permettra de tester l'application dans un navigateur sans avoir recours à un serveur avec des temps de réponse très satisfaisants.

Comme pour toute application JEE, nous devons aussi disposer d'un fichier Calculatrice.html dans le répertoire WAR :

1. <!doctype html>

2. <html>

3. <head>

4. <meta http-equiv="content-type" content="text/html; charset=UTF-8">

5. <link type="text/css" rel="stylesheet" href="Calculatrice.css">

6. <title>Calculator Web Application Project</title>

8. <!-- ce script charge le module compile   -->

10. <script type="text/javascript" language="javascript" src="calculatrice/calculatrice.nocache.js"></script>

11. </head>

13. <body>

15. <!-- OPTIONAL: inclure pour avoir le support de l'historique -->

16. <iframe src="javascript:''" id="__gwt_historyFrame" tabIndex='-1' style="position:absolute;width:0;height:0;border:0"></iframe>

18. <!-- instruction pour les navigateurs ne supportant pas JavaScript -->

19. <noscript>

20. <div style="width: 22em; position: absolute; left: 50%; margin-left: -11em; color: red; background-color: white; border: 1px solid red; padding: 4px; font-family: sans-serif">

21. votre navigateur doit accepter JavaScript pour que l'application fonctionne correctement

22. </div>

23. </noscript>

25. <h1>Calculator Web Application Project</h1>

26. </body>

27. </html>

Le code Java de notre application sera compilé en JavaScript. Cette page HTML doit donc indiquer que c'est ce code JavaScript qu'il faut exécuter : <script type="text/javascript" language="javascript" src="calculatrice/calculatrice.nocache.js"></script>

Bien entendu, on utilisera un fichier Calculatrice.css pour modifier l'apparence dans l'IHM des boutons Additionner et Multiplier.

1. h1 {

2. font-size: 2em;

3. font-weight: bold;

4. color: #777777;

5. margin: 40px 0px 70px;

6. text-align: center;

7. }

9. .btn {

10. -webkit-border-radius: 6;

11. -moz-border-radius: 6;

12. border-radius: 6px;

13. font-family: Arial;

14. color: #ffffff;

15. font-size: 14px;

16. background: #3498db;

17. padding: 6px 16px 6px 16px;

18. text-decoration: none;

19. }

21. .btn:hover {

22. background: #3cb0fd;

23. background-image: -webkit-linear-gradient(top, #3cb0fd, #3498db);

24. background-image: -moz-linear-gradient(top, #3cb0fd, #3498db);

25. background-image: -ms-linear-gradient(top, #3cb0fd, #3498db);

26. background-image: -o-linear-gradient(top, #3cb0fd, #3498db);

27. background-image: linear-gradient(to bottom, #3cb0fd, #3498db);

28. text-decoration: none;

29. }

À ce stade, nous n'avons pas écrit une ligne de Java, mais nous avons le squelette propre de notre application créée ex nihilo comme ci-dessous :

IV-B - Création de la classe principale

Nous avons précédemment défini dans le fichier Calculatrice.gwt.xml que le point d'entrée de l'application était la classe Calculatrice.

Voyons comment on crée cette classe dans le package client :

En GWT, il n'y a pas de classe principale, mais un EntryPoint que la classe Calculatrice doit implémenter.

L'unique méthode de l'interface EntryPoint à implémenter est onModuleLoad() qui place l'objet Ecran en affichage principal

Calculatrice.java

1. package com.calcul.client;

3. import com.google.gwt.core.client.EntryPoint;

4. import com.google.gwt.user.client.ui.RootPanel;

6. public class Calculatrice implements EntryPoint

7. {

8. @Override

9. public void onModuleLoad()

10. {

11. Ecran main = new Ecran();

12. RootPanel.get().add(main);

13. }

14. }

IV-C - Développement de l'interface graphique

Il faut créer avec Eclipse une classe Ecran qui hérite de la classe Composite dans le package client

Ecran

1. package com.calcul.client;

3. import com.google.gwt.core.client.GWT;

4. import com.google.gwt.event.dom.client.ClickEvent;

5. import com.google.gwt.event.dom.client.ClickHandler;

6. import com.google.gwt.user.client.rpc.AsyncCallback;

7. import com.google.gwt.user.client.ui.*;

9. public class Ecran extends Composite {

10. private VerticalPanel vPanel = new VerticalPanel();

11. private HorizontalPanel hPanel1, hPanel2, hPanel3, hPanel4;

12. private Label op1Lbl, op2Lbl, resultLbl;

13. private TextBox op1Txt, op2Txt, resultTxt;

14. private Button addBtn, multBtn;

16. public Ecran() {

17. this.initWidget(this.vPanel);

19. this.op1Lbl = new Label("Operande 1 : ");

20. this.op1Txt = new TextBox();

21. this.hPanel1 = new HorizontalPanel();

22. this.hPanel1.add(op1Lbl);

23. this.hPanel1.add(op1Txt);

24. this.hPanel1.setSpacing(5);

25. this.vPanel.add(hPanel1);

27. this.op2Lbl = new Label("Operande 2 : ");

28. this.op2Txt = new TextBox();

29. this.hPanel2 = new HorizontalPanel();

30. this.hPanel2.add(op2Lbl);

31. this.hPanel2.add(op2Txt);

32. this.hPanel2.setSpacing(5);

33. this.vPanel.add(hPanel2);

35. this.addBtn = new Button("Additionner");

36. this.addBtn.setStyleName("btn");

37. this.addBtn.addClickHandler(new AddBtnHandler());

38. this.multBtn = new Button("Multiplier");

39. this.multBtn.setStyleName("btn");

40. this.multBtn.addClickHandler(new MultBtnHandler());

41. this.hPanel3 = new HorizontalPanel();

42. this.hPanel3.add(addBtn);

43. this.hPanel3.add(multBtn);

44. this.hPanel3.setSpacing(20);

45. this.vPanel.add(hPanel3);

47. this.resultLbl = new Label("Resultat : ");

48. this.resultTxt = new TextBox();

49. this.hPanel4 = new HorizontalPanel();

50. this.hPanel4.add(resultLbl);

51. this.hPanel4.add(resultTxt);

52. this.hPanel4.setSpacing(5);

53. this.vPanel.add(hPanel4);

54. }

56. private class AddBtnHandler implements ClickHandler {

57. @Override

58. public void onClick(final ClickEvent event) {

59. // add your code here

60. }

61. }

63. private class MultBtnHandler implements ClickHandler {

64. @Override

65. public void onClick(final ClickEvent event) {

66. // add your code here

67. }

68. }

69. }

Nous venons de créer l'interface graphique utilisateur demandée, mais sans effet par un clic sur les deux boutons.

Il nous faut maintenant créer et consommer le service distant via RPC.

IV-D - Développement du service RPC

Il faut dans un premier temps créer dans le package client deux interfaces : OperatorService et OperatorServiceAsync

OperatorService

1. package com.calcul.client;

3. import com.google.gwt.user.client.rpc.*;

5. @RemoteServiceRelativePath("operator")

6. public interface OperatorService extends RemoteService {

7. String additionner(String input1, String input2);

8. String multiplier(String input1, String input2);

9. }

Cette interface qui hérite de RemoteService indique qu'un objet distant qui implémentera OperatorService exposera deux méthodes additionner et multiplier.

OperatorServiceAsync

1. package com.calcul.client;

3. import com.google.gwt.user.client.rpc.AsyncCallback;

5. public interface OperatorServiceAsync {

6. void additionner(String input1, String input2, AsyncCallback<String> callback )

7. throws IllegalArgumentException;

8. void multiplier(String input1, String input2, AsyncCallback<String> callback )

9. throws IllegalArgumentException;

10. }

Sachant que ce code sera transformé en JavaScript la compréhension de cette interface asynchrone vient plus facilement en se remémorant le fonctionnement de l'objet AJAX XmlHttpResponse qui ouvre une connexion, envoie des paramètres et en reçoit en retour au format texte ou XML.

Et enfin dans le package server, on doit implémenter l'interface OperatorService dans une RemoteServiceServlet.

OperatorServiceImpl

1. package com.calcul.server;

3. import com.calcul.client.OperatorService;

4. import com.google.gwt.user.server.rpc.RemoteServiceServlet;

6. @SuppressWarnings("serial")

7. public class OperatorServiceImpl extends RemoteServiceServlet implements

8. OperatorService

9. {

10. @Override

11. public String additionner(String input1, String input2)

12. {

13. float val1 = Float.valueOf(input1).floatValue();

14. float val2 = Float.valueOf(input2).floatValue();

15. float res = val1 + val2;

16. return  String.valueOf(res);

17. }

19. @Override

20. public String multiplier(String input1, String input2)

21. {

22. float val1 = Float.valueOf(input1).floatValue();

23. float val2 = Float.valueOf(input2).floatValue();

24. float res = val1 * val2;

25. return  String.valueOf(res);

26. }

27. }

Bien entendu comme dans toute application JEE, il faut indiquer dans le fichier web.xml où trouver cette servlet et comment la nommer.

web.xml

1. <?xml version="1.0" encoding="UTF-8"?>

2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

3. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

4. http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

5. version="2.5"

6. xmlns="http://java.sun.com/xml/ns/javaee">

7. <!-- Servlets -->

8. <!-- Default page to serve -->

10. <servlet>

11. <servlet-name>operatorServlet</servlet-name>

12. <servlet-class>com.calcul.server.OperatorServiceImpl</servlet-class>

13. </servlet>

15. <servlet-mapping>

16. <servlet-name>operatorServlet</servlet-name>

17. <url-pattern>/calculatrice/operator</url-pattern>

18. </servlet-mapping>

20. <welcome-file-list>

21. <welcome-file>Calculatrice.html</welcome-file>

22. </welcome-file-list>

24. </web-app>

IV-E - Consommer le service

On peut maintenant appeler le service dans la classe Ecran en surchargeant la méthode onClick des deux ClickHandler de la manière suivante.

AddBtnHandler

1. private class AddBtnHandler implements ClickHandler

2. {

4. @Override

5. public void onClick(final ClickEvent event)

6. {

7. final OperatorServiceAsync getService = GWT.create(OperatorService.class);

8. getService.additionner(op1Txt.getText(), op2Txt.getText(), new AsyncCallback<String>()

9. {

10. public void onFailure(Throwable caught)

11. {

12. System.out.println(event.getSource().toString());

13. }

15. public void onSuccess(String result)

16. {

17. resultTxt.setText(result);

18. }

19. });

20. }

21. }

23. private class MultBtnHandler implements ClickHandler

24. {

26. @Override

27. public void onClick(final ClickEvent event)

28. {

29. final OperatorServiceAsync getService = GWT.create(OperatorService.class);

30. getService.multiplier(op1Txt.getText(), op2Txt.getText(), new AsyncCallback<String>()

31. {

32. public void onFailure(Throwable caught)

33. {

34. System.out.println(event.getSource().toString());

35. }

37. public void onSuccess(String result)

38. {

39. resultTxt.setText(result);

40. }

41. });

42. }

43. }

V - Test de l'application avec Super Dev Mode

Le Super Dev Mode permet de tester notre application dans un bac à sable réduit à un simple navigateur.

Pour cela, il suffit de choisir par un clic droit dans l'explorateur de projet Run as … Web Application (Super Dev Mode).

Après quelques secondes, la vue développement mode permet de lancer le test dans le navigateur souhaité.

Le mode Super Dev Mode permet de tester à chaud chaque modification du code source après sauvegarde des fichiers source dans Eclipse en cliquant dans le navigateur sur l'icône GWT en bas à droite qui relance la compilation dans le navigateur.

VI - Conclusion et remerciements

GWT est un Framework professionnel. À ce titre, il a vocation à être utilisé dans l'environnement habituel de développement JEE et tout particulièrement à l'aide d'un outil de Build tel que MAVEN et de tests unitaires comme JUnit.

Le projet MOJO propose un plugin gwt-maven (pour construire un projet GWT dans Eclipse comme on le ferait avec n'importe quel projet JEE. Les sources et informations sur ce plugin sont disponibles sur le site du projet MOJO à l'URL : http://mojo.codehaus.org/gwt-maven-plugin/.

Quant à JUnit, il est implémenté dans GWT pour tester la plupart des composants que le Framework crée en JavaScript. La documentation est également disponible sur le site du projet GWT à l'URL : http://www.gwtproject.org/doc/latest/tutorial/JUnit.html.

Cet article nous a permis, à travers un exemple simple de comprendre :

- comment GWT permet de réaliser une interface AJAX en écrivant uniquement Java ;

- comment créer un service distant et comment l'invoquer en GWT RPC.

On a également pu constater à quel point Eclipse intègre GWT pour le développement et le test.

Nous tenons à remercier Claude Leloup pour sa relecture attentive de cet article et Mickaël Baron pour la mise au gabarit.