REST Web Service avec Spring

La mise en œuvre d’un web service REST peut être facilement réalisée en utilisant la librairie Spring 4 via les annotations en basant sur la norme Servlet 3.0.

Près-requis

Vous avez une environnement Eclipse fonctionnel avec à minima un jdk 1.6 et un tomcat 7.0.
Vous avez réalisé et réussi les tutoriaux Rest Web Service Get avec Spring et Rest Web Service Get avec Spring.

Préparation du projet

On va réutiliser les projets SpringRestWS et SpringRestClient en les complétant dans ce tutorial.
Si vous n’avez plus ces projets opérationnels, vous pouvez les récupérer comme suit :

    • Dans un premier répertoire :
      git clone https://github.com/draoullig/SpringRestWS.git
      cd SpringRestWS
      git checkout step1
    • Dans un second répertoire :
      git clone https://github.com/draoullig/SpringRestClient.git
      cd SpringRestClient
      git checkout step1

Importer les projet sous Eclipse via File>Import>General>Existing Projects into Workspace et sélectionner SpringRestWS dans le répertoire dans lequel vous avez réalisé le git clone, puis finissez l’import.
Refaire la même opération pour le projet SpringRestClient.

SpringRestWS

On va ajouter certaines fonctionnalités au contrôleur du service pour proposer l’ajout, la modification, la suppression et la consultation d’un client.

Client.java

Désormais, le web service va recevoir des données pour la gestion des clients. Ces données sont au format json, dans ce cas il faut ajouter un constructeur par défaut à la classe Client pour que le mapping réalisé via Jackson se déroule correctement.

Ouvrir le fichier Client.java du projet SpringRestWS en double cliquant dessus.
Ajouter le constructeur suivant à la classe Client au-dessous du constructeur existant et enregistrer :

Dans notre contrôleur les clients sont stockés dans une ArrayList. Dans le cas d’une modification, on va modifier un client déjà présent dans la liste. Dans ce cas l’implémentation ArrayList s’appuie sur la fonction equals de l’objet stocké pour effectuer sa recherche. Nous allons surchargé la fonction equals de la classe Client pour que la comparaison s’effectue uniquement sur sa propriété identifiant.

Ajouter le code suivant à la fin de la classe Client et enregistrer :

ClientControleur.java

On va ajouter les méthodes permettant de réaliser un ajout (add), une mise à jour (update), une suppression (delete) et une consultation à la classe.

Ouvrir le fichier ClientControleur.java en double cliquant dessus.

Remplacer les import existants par les suivants :

Ajouter le code suivant à la fin de la classe ClientControleur et enregistrer :

La fonction addClient est définie côté REST via la méthode POST. Cette fonction attend un client qui se trouve dans le corps de la requête via l’annotation @RequestBody. Ce client est simplement ajouté à la liste et la fonction renvoie le résultat boolean de l’ajout.
La fonction updateClient est définie côté REST via la méthode PUT. Cette fonction met à jour les informations du client dans la liste en considérant que l’identifiant du client n’a pas changé et en se basant sur la fonction equals que nous avons surchargé dans la classe Client. Elle retourne le client avant sa mise à jour.
La fonction deleteClient est définie côté REST via la méthode DELETE. Cette fonction attend l’id (identifiant) du client à supprimer dans l’url. Ceci est précisé via les annotations @RequestMapping(value = et @PathVariable. Le client est simplement retiré de la liste.
La fonction getClient se différencie de la fonction getClients par un mapping d’url différent défini dans l’annotation. Elle récupère l’id du client dans l’url comme la fonction deleteClient précédente. Elle renvoie le premier client de la liste en se basant sur la fonction equals de la classe Client pour sa recherche.

SpringRestClient

On va mettre à jour la classe RestClient pour qu’il utilise les nouvelles fonctionnalités proposés par le service REST.

RestClient.java

Ouvrir le fichier RestClient.java du projet SpringRestClient en double cliquant dessus.

Ajouter le nouvel import suivant à ceux déjà présent dans la classe :

Remplacer le code existant de la fonction main et enregistrer :

L’url du service est variabilisé pour en faciliter sa mise à jour.
Dans le cas de l’ajout, on utilise la méthode postForObject dans laquelle on précise l’url de destination, le client à ajouter ainsi que le type de retour attendu. On teste ce boolean pour afficher le message.
Dans le cas de la modification, on utilise la méthodes exchange dans laquelle on précise l’url de destination, le client à modifier ainsi que le type de retour attendu. On teste le prénom du client retourné qui doit correspondre à Gaëtan et non à Amélie. La modification se base sur un identifiant inchangé.
Dans le cas de la consultation du client, on précise l’identifiant du client et le mapping sur l’url /{id} s’effectue automatiquement.
Dans le cas de la suppression, on précise l’identifiant du client à supprimer et le mapping sur l’url /{id} s’effectue automatiquement.

Runtime

SpringRestWS

Pour tester le web service, il est nécessaire de déployer le projet SpringRestWS sous un Tomcat v7.0.
Pour cela dans la vue Server, effectuer un clic droit sur le serveur cible et cliquer sur Add and Remove.
Dans la boite de dialogue Add and Remove, pousser le projet SpringRestWS dans la partie Configured et cliquer sur Finish.
Dans la vue Server, effectuer à nouveau un clic droit sur le serveur cible et cliquer sur Debug.
La vue Console devrait ressembler à ceci :

SpringRestWS

Effectuer un clic droit sur la classe RestClient dans la vue Project Explorer, puis Debug As/Java Application.

La vue Console devrait ressembler à ceci :

Gestion des erreurs

Spring propose un mécanisme côté service REST qui permet de centraliser facilement l’interception et la gestion des erreurs au niveau des contrôleurs.
Penser à arrêter votre serveur avant de modifier le code en effectuant un clic droit sur le serveur cible et en cliquant sur Stop.

Package

Création d’un nouveau package exception sous le package fr.gillouard.spring.restws dans le projet SpringRestWS.
Pour cela faire un clic droit sur le package fr.gillouard.spring.restws.pojo et cliquer sur  New/Package.
Remplacer pojo par exception dans le champs Name de la boite de dialogue New Java Package et cliquer sur Finish.

Error

Cette classe pojo va permettre de renvoyer une erreur généralisée au format json en cas d’anomalie de traitement dans le service web REST.
Cette classe est la représentation la plus usuelle pour la gestion d’erreur dans le cas de service web REST.
Elle se compose :

  • Code status HTTP
  • Code erreur interne au service web
  • Message fonctionnel
  • Message technique
  • Lien vers une documentation descriptive de l’erreur

Création d’une nouvelle classe dans le package fr.gillouard.spring.restws.pojo. Pour cela faire un clic droit sur le package et cliquer sur New/Class.
Saisir Error dans le champs Name de la boite de dialogue New Java Class puis cliquer sur Finish.
Ouvrir le fichier Error.java en double cliquant dessus.

Ajouter le code suivant au corps de la classe Error :

ErrorHandler

Cette classe va permettre de centraliser la gestion d’erreur au sein du web service REST.

Création d’une nouvelle classe dans le package fr.gillouard.spring.restws.exception. Pour cela faire un clic droit sur le package et cliquer sur New/Class.
Saisir ErrorHandler dans le champs Name de la boite de dialogue New Java Class puis cliquer sur Finish.
Ouvrir le fichier ErrorHandler.java en double cliquant dessus.

Ajouter les imports suivants à la classe :

Ajouter l’annotation suivante à la classe ErrorHandler :

Ajouter le code suivant au corps de la classe et enregistrer:

L’annotation @ControllerAdvice permet d’associer cette classe à tous les contrôleurs du service web. Ainsi dès qu’une erreur sera levée au sein d’un contrôleur, elle sera traitée via cette classe.

Dans cette classe ErrorHandler, on traite deux types d’erreurs :

  • la méthode internalServerError va traiter toutes les erreurs de type Exception, elle va retourner un objet Error sous format json (@ResponseBody) dans le corps de la response et le status http du header sera INTERNAL_SERVER_ERROR. Tout ceci étant spécifié via les annotations. La fonction se contente de créer une erreur de type technique pour l’exemple et transforme la stacktrace de l’erreur en chaine via la méthode utilitaire getStackTrace.
  • la méthode indexOutOfBoundsExceptionError va traiter toutes les erreurs de type IndexOutOfBoundsException, elle va retourner un objet Error sous format json (@ResponseBody) dans le corps de la response et le status http du header sera INTERNAL_SERVER_ERROR. Tout ceci étant spécifié via les annotations. La fonction se contente de créer une erreur de type fonctionel pour l’exemple et transforme la stacktrace de l’erreur en chaine via la méthode utilitaire getStackTrace.

ClientControleur.java

Pour illustrer la gestion d’erreur, on va modifier la méthode getClients de la classe ClientControleur pour que cette dernière lève une exception.
Pour cela, ouvrir le fichier ClientControleur.java en double cliquant dessus.

Remplacer l’implémentation de la fonction getClients existante par le code ci-dessous et enregistrer :

Ce code se bornant à renvoyer une exception avec le message “Test erreur” à chaque appel.

ClientRestError

On va ajouter une classe dans le projet SpringRestClient pour tester la gestion des erreurs.

Création d’une nouvelle classe dans le package fr.gillouard.spring.restclient. Pour cela faire un clic droit sur le package fr.gillouard.spring.restclient et cliquer sur New/Class.
Saisir RestClientError dans le champs Name de la boite de dialogue New Java Class et cocher public static void main(String[] args) puis cliquer sur Finish.
Ouvrir le fichier RestClientError.java en double cliquant dessus.

Ajouter les imports suivants à la classe :

Ajouter le code suivant dans la fonction main et enregistrer :

Le premier appel essaye de récupérer la liste des clients qui renvoie désormais toujours une exception. Cette dernière est juste interceptée et affichée sous forme de chaîne. Il serait assez facile de la transformer en classe Error si cette dernière était importé dans le projet pour réaliser un traitement plus fin.
Le second appel essaye de consulter un client, mais l’identifiant est inconnu ce qui entraîne une levé d’exception qui est interceptée et affichée sous forme de chaîne.
On remarquera que l’affichage des deux chaînes, permet de vérifier les types différents d’erreurs et que les stacktraces sont bien rapatriées.

Runtime Error

Dans la vue Server, effectuer à nouveau un clic droit sur le serveur cible et cliquer sur Debug.
Un fois le serveur démarré, effectuer un clic droit sur la classe RestClientError dans la vue Project Explorer, puis Debug As/Java Application.

La vue Console devrait ressembler à ceci :

Conclusion

Ce tutorial a permis d’expliquer la mise en oeuvre d’un web service REST en utilisant Spring sur les commandes de base HTTP.
Un mécanisme de gestion d’erreur sur la partie contrôleur a été décrite et implémentée.
Ce tutorial est un tour succint sur les possibilités offertes par le framework Spring, je vous invite fortément à compléter ces informations par la documentation présente sur le site http://spring.io/ surtout les onglets Docs et Guides.

Solution

L’ensemble des sources de ce tutorial est disponible sous le tag step2 sous les projets SpringRestWS et SpringRestClient présent sur mon dépôt Github


Tester des requêtes à travers un proxy via telnet

Il est parfois nécessaire d’effectuer des tests telnet sur des urls.

Si vous êtes derrière un proxy, le test s’avère un peu plus compliqué à mettre en œuvre :

  1. Dans un terminal, effectuer un telnet sur le serveur proxy : telnet proxy.url proxy.port
  2. Effectuer un requête GET sur l’url distante à tester : GET http://www.google.com/ HTTP/1.1
  3. Le résultat de la requête devrait s’afficher.
  4. Si votre proxy nécessite une identification il est nécessaire d’ajouter un Proxy-Authorization à la requête GET.
    1. Pour cela via la commande echo -n username:password | openssl base64, récupérer la chaine codée en base 64.
    2. Ajouter la ligne Proxy-Authorization: Basic chaine encodée à la requête précédente.
    3. Voici un exemple : GET http://www.google.com/ HTTP/1.1
      Proxy-Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=

Ajouter un proxy à Boot2Docker sous Mac OS

  1. Démarrer Boot2Docker via boot2docker start
  2. Se logguer sur Boot2Docker via boot2docker ssh
  3. Modifier le fichier Profile via sudo vi /var/lib/boot2docker/profile
  4. Ajouter la configuration du proxy (Supprimer la partie user:password si votre proxy ne nécessite pas d’identification) :
    • export https_proxy=http://user:pass@proxy.host.com:port
    • export http_proxy=http://user:pass@proxy.host.com:port
  5. Sauvegarder et fermer le fichier
  6. Rédémarrer le service docker via : sudo /etc/init.d/docker restart
  7. Quitter la session ssh via : exit

Rest Client Get avec Spring

La mise en œuvre d’un client REST Get peut être facilement réalisée en utilisant la librairie Spring 4.

Près-requis

Vous avez une environnement Eclipse fonctionnel avec à minima un jdk 1.6 et un tomcat 7.0.
Vous avez réalisé et réussi le tutorial Rest Web Service Get avec Spring.

Préparation du projet

Pour commencer, je vous invite à récupérer le squelette du projet sur mon github dans un répertoire projet via les commandes :

git clone https://github.com/draoullig/SpringRestClient.git

cd SpringRestClient

git checkout step0

mkdir src

Importer le projet sous Eclipse via File>Import>General>Existing Projects into Workspace et sélectionner SpringRestClient dans le répertoire dans lequel vous avez réalisé le git clone, puis finissez l’import.

Dans la vue “Java EE – Eclipse”, ajouter le package fr.gillouard.spring.restclient via un click droit sur src>New>Package et valider.

Les librairies nécessaires au projet sont présentes dans le répertoire /lib.

Pojo

Les classes Pojo vont permettre de récupérer le modèle issu du web service Rest.

Package

Création d’un nouveau package pojo sous le package fr.gillouard.spring.restclient.
Pour cela faire un clic droit sur le package fr.gillouard.spring.restclient et cliquer sur New/Package.
Ajouter .pojo à fr.gillouard.spring.restclient dans le champs Name de la boite de dialogue New Java Package et cliquer sur Finish.

Client

Copier la classe Client présent dans le projet SpringRestWS sous le package fr.gillouard.spring.restws.pojo dans le package fr.gillouard.spring.restclient.pojo du projet SpringRestClient.

Pour la conversion java à json, il est nécessaire d’ajouter un constructeur par défaut à cette classe après la dernière déclaration de membre privé :

RestClient

La classe RestClient effectue l’appel vers le web service Rest et affiche dans la console les résultats de l’appel.

Création d’une nouvelle classe dans le package fr.gillouard.spring.restclient. Pour cela faire un clic droit sur le package fr.gillouard.spring.restclient et cliquer sur New/Class.
Saisir RestClient dans le champs Name de la boite de dialogue New Java Class, supprimer le .pojo dans le nom du package du champs Package et cocher public static void main(String[] args) puis cliquer sur Finish.
Ouvrir le fichier RestClient.java en double cliquant dessus.

Ajouter les imports suivants :

Ajouter le code suivant à la fonction main de la classe :

La classe RestTemplate de Spring encapsule toute la mécanique d’appel à un service REST.
Il est nécessaire de préciser l’url de destination, la méthode d’appel, les paramètres éventuels et le type de retour.
Pour la conversion de données entre le java et le json, Spring utilise les librairies Jackson ce qui demande dans notre cas de définir explicitement le type de retour parce que nous attendons une liste de client via l’instruction new ParameterizedTypeReference<List<Client>>() {}. Si ce paramétrage est absent, nous obtiendrions une liste de type LinkedHashMap qui est la conversion par défaut de Jackson pour un flux json représentant une liste.
Les instructions suivantes affichent la taille de la liste, les noms et prénoms récupérés.

Runtime

Pour tester le client, il est nécessaire de déployer le projet CodelabRestWS sous un Tomcat v7.0 et de l’exécuter (Se référer au tutorial correspondant).
Effectuer un clic droit sur la classe RestClient dans la vue Project Explorer, puis Debug As/Java Application.

La vue Console devrait ressembler à ceci :

Conclusion

Ce tutorial a permis d’expliquer la mise en oeuvre d’un client REST en utilisant Spring.
Les tutoriaux suivants permettront de compléter la richesse fonctionnelle de ce client.

Solution

L’ensemble des sources de ce tutorial est disponible sous le tag step1.


Arrêter ou supprimer une liste de container Docker

Il peut être fastidieux de supprimer un ensemble de container Docker qui sont en fonctionnement.

Il est possible de tous les arrêter ou de tous les supprimer via les commandes suivantes :


Rest Web Service Get avec Spring

La mise en œuvre d’un web service REST peut être facilement réalisée en utilisant la librairie Spring 4 via les annotations en basant sur la norme Servlet 3.0.

Pour mieux appréhender le protocole REST, il est vivement conseillé de lire la page suivante : http://www.restapitutorial.com/lessons/restquicktips.html

Près-requis

Vous avez une environnement Eclipse fonctionnel avec à minima un jdk 1.6 et un tomcat 7.0.

Préparation du projet

Pour commencer, je vous invite à récupérer le squelette du projet sur mon github dans un répertoire projet via les commandes :

git clone https://github.com/draoullig/SpringRestWS.git

cd SpringRestWS

git checkout step0

mkdir src

Importer le projet sous Eclipse via File>Import>General>Existing Projects into Workspace et sélectionner SpringRestWS dans le répertoire dans lequel vous avez réalisé le git clone, puis finissez l’import.

Dans la vue “Java EE – Eclipse”, ajouter le package fr.gillouard.spring.restws via un click droit sur src>New>Package et valider.

Les librairies nécessaires au projet sont présentes dans le répertoire /web/WEB-INF/lib.

Pojo

Les classes Pojo vont permettre de gérer le modèle associé au web service.
Ce tutorial s’appuie sur un modèle simple constitué d’une seul objet client caractérisé par un identifiant, un nom et un prénom.

Package

Création d’un nouveau package pojo sous le package fr.gillouard.spring.restws.
Pour cela faire un clic droit sur le package fr.gillouard.spring.restws et cliquer sur New/Package.
Ajouter .pojo à fr.gillouard.spring.restws dans le champs Name de la boite de dialogue New Java Package et cliquer sur Finish.

Client

Création d’une nouvelle classe dans le package fr.gillouard.spring.restws.pojo. Pour cela faire un clic droit sur le package et cliquer sur New/Class.
Saisir Client dans le champs Name de la boite de dialogue New Java Class puis cliquer sur Finish.
Ouvrir le fichier Client.java en double cliquant dessus.

Ajouter le code suivant au corps de la classe Client et enregistrer :

Cette classe Client regroupe les champs identifiant, nom et prenom avec les accesseurs get et set sur chaque champs et un constructeur pour la création de l’objet.

Contrôleur

Les classes contrôleur vont permettre d’exposer le web service en REST à partir des annotations Spring.

Package

Création d’un nouveau package controller sous le package fr.gillouard.spring.restws.
Pour cela faire un clic droit sur le package fr.gillouard.spring.restws.pojo et cliquer sur New/Package.
Remplacer pojo par controller dans le champs Name de la boite de dialogue New Java Package et cliquer sur Finish.

Client Contrôleur

Cette classe va permettre de récupérer les clients via un appel REST de type GET.

Création d’une nouvelle classe dans le package fr.gillouard.spring.restws.controller. Pour cela faire un clic droit sur le package et cliquer sur New/Class.
Saisir ClientControleur dans le champs Name de la boite de dialogue New Java Class puis cliquer sur Finish.
Ouvrir le fichier ClientControleur.java en double cliquant dessus.

Ajouter les imports suivants :

Ajouter les annotations suivantes à la classe :

Ajouter le code suivant dans le corps de la classe et sauvegarder :

L’annotation @RestController permet d’indiquer que cette classe est un contrôleur qui utilise des flux json pour faire du REST.
L’annotation @RequestMapping permet d’indiquer le mapping d’url pour lequel le contrôleur doit répondre, dans ce cas-ci il s’agit de l’url /client.

La liste des clients est géré simplement via une ArrayList dans le cas de ce tutorial.
La fonction getClients est annotée via @RequestMapping pour indiquer que le mapping est réalisé sur l’url /client sur une requête http de format GET.
Cette fonction retourne tous les clients de la liste.

Spring java configuration

Désormais Spring permet de réaliser toute sa configuration sans utiliser un ligne de xml. Dans cette section, la configuration du service web REST va être décrite.

Package

Création d’un nouveau package config sous le package fr.gillouard.spring.restws.
Pour cela faire un clic droit sur le package fr.gillouard.spring.restws.pojo et cliquer sur New/Package.
Remplacer pojo par config dans le champs Name de la boite de dialogue New Java Package et cliquer sur Finish.

SpringConfig

Cette classe permet de créer l’injection du contexte Spring du projet.

Assurez vous que les librairies de votre serveur d’exécution (Ici Tomcat 7.0 à minima) soient bien dans le classpath du projet.

Création d’une nouvelle classe dans le package fr.gillouard.spring.restws.config. Pour cela faire un clic droit sur le package et cliquer sur New/Class.
Saisir SpringConfig dans le champs Name de la boite de dialogue New Java Class puis cliquer sur Finish.
Ouvrir le fichier SpringConfig.java en double cliquant dessus.

Ajouter les imports suivants :

Ajouter les annotations suivantes à la classe :

Faire hériter la classe de WebMvcConfigurationSupport via :

Ajouter le code suivant dans le corps de la classe :

L’annotation @Configuration permet de préciser que cette classe réalise le chargement du contexte Spring et le met à disposition.
L’annotation @ComponentScan("fr.gillouard.spring.restws") permet d’indiquer que la création du contexte est réalisé en scannant tous les classes de la hiérarchie de package précisé. Ainsi les annotations de la classe ClientController sont analysées et traitées.
La classe de configuration ne contient qu’un constructeur parce que tout le traitement est effectué par les annotations.

WebAppInitializer

Cette classe va être instanciée au démarrage du conteneur (Norme Servlet 3) et charge la configuration du contexte pour le serveur d’exécution.

Création d’une nouvelle classe dans le package fr.gillouard.spring.restws.config. Pour cela faire un clic droit sur le package et cliquer sur New/Class.
Saisir WebAppInitializer dans le champs Name de la boite de dialogue New Java Class puis cliquer sur Finish.
Ouvrir le fichier WebAppInitializer.java en double cliquant dessus.

Ajouter les imports suivants :

Implémenter la classe de WebApplicationInitializer via :

Ajouter le code suivant dans le corps de la classe et sauvegarder :

La classe implémente la méthode onStartup définit de la norme Servlet 3 et qui est exécutée au démarrage du serveur.
La méthode crée le contexte Spring en utilisant les annotations via la classe AnnotationConfigWebApplicationContext et en chargeant la classe SpringConfig.
Le contexte Spring est mis à disposition du serveur d’exécution et toutes les requêtes entrantes sur le serveur sont traités via les mécanismes Spring.

Runtime

Pour tester le web service, il est nécessaire de déployer le projet SpringRestWS sous un Tomcat v7.0.
Pour cela dans la vue Server, effectuer un clic droit sur le serveur cible et cliquer sur Add and Remove.
Dans la boite de dialogue Add and Remove, pousser le projet SpringRestWS dans la partie Configured et cliquer sur Finish.
Dans la vue Server, effectuer à nouveau un clic droit sur le serveur cible et cliquer sur Debug.

La vue Console devrait ressembler à ceci :

Pour tester le web service, ouvrer un navigateur et saisir l’url suivante : http://localhost:8080/SpringRestWS/client en changeant le port en fonction de la configuration de votre serveur Tomcat.

Vous devriez obtenir ceci :

appel_web_service_1

La liste des clients est vide côté service, ce qui explique ce résultat.

Dans la vue Server, effectuer à nouveau un clic droit sur le serveur cible et cliquer sur Stop.

Data

Nous allons ajoutons des clients au service pour obtenir un résultat plus concluant.

Pour cela, ouvrir le fichier ClientControleur.java en double cliquant dessus.

Ajouter le code suivant dans le corps de la classe sous la ligne private final List<Client> clients = new ArrayList<Client>(); :

Ce code ajoute un constructeur a la classe dans lequel on ajoute des clients à la liste.

Dans la vue Server, effectuer à nouveau un clic droit sur le serveur cible et cliquer sur Debug.

Effectuer un rafraîchissement dans votre navigateur sur la page précédente et vous devriez obtenir ceci :

Dans la vue Server, effectuer à nouveau un clic droit sur le serveur cible et cliquer sur Stop.

Conclusion

Ce tutorial a permis d’expliquer la mise en œuvre d’un web service REST en utilisant Spring uniquement sur la commande GET.

Solution

L’ensemble des sources de ce tutorial est disponible sous le tag step1.


Le lancement d’Eclipse reste bloqué sur le chargement du workspace

Le lancement d’Eclipse reste bloqué sur le chargement du workspace ce qui se traduit par l’immobilisation de la barre de progression.

Pour débloquer le workspace incriminé, il faut accèder à ce dernier via le gestionnaire de fichier de votre OS ou en ligne de commande. Attention, il s’agit de fichiers cachés.
Ouvrir le répertoire .metadata/.plugins/org.eclipse.core.resources du workspace, et supprimer le fichier appelé .snap.
Lancer Eclipse et normalement ce dernier devrait réussir à charger de nouveau le workspace.


Relancer eclipse après une fermeture intempestive

Lorsque Eclipse se ferme de façon intempestive et qu’il est impossible de le relancer, ce dernier restant bloqué sur le chargement du Workbench, voici une petite procèdure qui peut permettre de corriger la situation :

1 – Se positionner dans le repertoire workspace
2 – cd .metadata/.plugins
3 – mv org.eclipse.core.resources org.eclipse.core.resources.bak (Déplacer le répertoire resources)
4 – Démarrer eclipse. (Un message d’erreur est possible parce qu’il ne retrouve plus ses projets)
5 – Fermer tous les fichiers ouverts.
6 – Quitter eclipse
7 – rm -rf org.eclipse.core.resources (Détruire le nouveau répertoire resources)
8 – mv org.eclipse.core.resources.bak/ org.eclipse.core.resources (Restaurer le répertoire original)
9 – Démarrer eclipse qui devrait récupérer le workspace original


Signature d’un jar à partir d’un certificat et d’une clé privée

Voici la marche à suivre pour signer un jar si l’on dispose de la clé privée et des certificats Verisign :

1 – Création d’un pkcs12 :

openssl pkcs12 -export -in certificat_verisign.cer -inkey cle_privee.key -name alias_nom -out sortie.p12

2 – Signature du jar à partir du pkcs12 :

jarsigner -storetype pkcs12 -keystore sortie.p12 .jar alias_nom

3 – Pour verifier que c’est bon :

jarsigner -verify .jar


Renommer un projet GWT sous Eclipse

Voici une petite procédure pour renommer un projet GWT sous Eclipse :

  1. Renommez le projet gwt.
  2. Renommez le fichier ancien_nom_projet.gwt.xml en nouveau_nom_projet.gwt.xml.
  3. Dans ce fichier, renommez la valeur spécifiée dans le champs ‘rename-to’ avec le nouveau nom de projet.
  4. Renommez le fichier ancien_nom_projet.html en nouveau_nom_projet.html présent dans le répertoire war.
  5. Faites de même avec le fichier .css présent dans le répertoire war.
  6. Mettez à jour les références dans nouveau_nom_projet.html du fichier css.
  7. Dans le fichier nouveau_nom_projet.html, il y a un nom spécifié pour le nocache.js. Trouvez la ligne : src = ‘ancien_nom_projet/ancien_nom_projet.nocache.js’ et la remplacer par src = ‘nouveau_nom_projet/nouveau_nom_projet.nocache.js’
  8. Dans le fichier web.xml, si vous avez des lignes <url-pattern>/ancien_nom_projet/...</url-pattern>, les remplacer par <url-pattern>/nouveau_nom_projet/...</url-pattern>
  9. Si vous utilisez l’injection Guice dans votre projet, changez les urls avec le nouveau nom de projet dans le mapping.
  10. Détruisez le répertoire de sortie (war/ancien_nom_projet), il sera reconstruit automatiquement avec le bon nom de projet.
  11. Dans Eclipse, détruisez votre ancienne “Run Configuration“. Lorsque vous lancerez via  “Run As > Web Application” sur le projet renommé, la configuration sera recréée.
  12. Il ne vous reste plus qu’à lancer la compilation du projet via la boite de dialogue associée de GWT. Si la référence à l’ancien projet est toujours présente dans cette dernière, il faut la mettre à jour via les boutons add et remove de la boite de dialogue.