Tutoriel pour développer et déployer un service web RESTFUL de base sous Eclipse et Karaf

Développement d'un RESTFUL Webservice sous Eclipse et déploiement dans KARAF

Olivier ROZIER

Développant, jusqu'à présent des web services REST sous Talent ESB, la curiosité m'est venue de voir comment on pouvait en créer sous Eclipse dans le but de pouvoir les déployer sous Karaf.

Après beaucoup de recherches sur Internet, je n'ai pas trouvé de tutoriel qui permettait d'en développer rapidement avec un minimum de code.

J'ai donc décidé de me lancer et après plusieurs jours d'essais, j'ai trouvé une solution dont je tenais à vous faire part pour vous faire gagner du temps. Ce tutoriel s'adresse aux développeurs expérimentant la programmation de Web Service RESTful destinés à être déployés sur un serveur d'application basé sur les spécifications OSGI et plus spécifiquement sur Karaf.

Avant cela, il convient de vous présenter les différentes architectures qui rentrent en jeu dans l'utilisation des RESTful Web Services puis nous verrons, par un exemple concret leur mise en œuvre à partir d'Eclipse.

Si vous souhaitez donner votre avis sur le contenu de cet article, exprimez votre opinion, profitez de cette discussion : Commentez

- Titre : Tutoriel pour développer et déployer un service web RESTFUL de base sous Eclipse et Karaf

- Auteur : Olivier ROZIER

- Parution : 12 janvier 2016

- Mise à jour : 22 mars 2020

- Public visé :

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2015 Olivier ROZIER. 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. Qu'est-ce qu'un RESTful webservice ?

- II. Qu'est-ce que KARAF ?

- III. Problématique

- IV. Configuration logicielle

- V. Configuration d'Eclipse et de MAVEN

- VI. Création d'un nouveau projet Maven à l'aide de l'archetype karaf-blueprint

- VII. Compilation et Build

- VIII. Installation et configuration de karaf

- IX. Conclusion

- Index

I - Qu'est-ce qu'un RESTful webservice ?

Les RESTful web services sont devenus de plus en plus populaires. Il s'agit de services basés sur l'architecture REST. Ce type de web service a pour avantages d'être plus léger, plus évolutif et plus facilement maintenable.

L'architecture REST est une architecture s'appuyant sur le protocole HTTP. Elle permet, via une URL, d'effectuer plusieurs types d'opérations sur une ressource.

Ces opérations (utilisant souvent les formats d'échange JSON et XML) sont les suivantes :

- GET
Cette opération permet de récupérer des informations ;

- POST
Elle permet de créer une nouvelle entité en fournissant cette nouvelle entité dans le corps de la requête au format JSON ou XML (par exemple) ;

- PUT
Elle permet de mettre à jour une entité par les informations fournies au format JSON ou XML (par exemple) dans le corps de la requête ;

- DELETE
Elle permet de supprimer une entité via un identifiant fourni en paramètre.

On peut envoyer une requête à un web service REST par utilisation d'un client REST.

À défaut de développer un tel client REST lors des phases de test de votre futur web service REST, on peut utiliser des plugins qui s'installent au sein du navigateur Internet tels :

- RESTClient ( https://addons.mozilla.org/fr/firefox/addon/restclient/ )
Il s'agit d'un plugin pour firefox ;

- Advanced REST client (https://chrome.google.com/webstore/detail/advanced-rest-client/hgmloofddffdnphfgcellkdfbfbjeloo )
Il s'agit d'un plugin pour Chrome.

Il existe un plugin client REST pour la plupart des navigateurs.

Ces clients REST permettent de fournir, en paramètre, le format d'échange des données dans l'entête HTTP en indiquant le « content-type ». Par exemple, voici une capture d'écran de RESTClient :

Afin d'accéder à un RESTful web service, il suffit de saisir une URL. Dans l'exemple que nous allons développer dans ce tutoriel, l'adresse de notre web service est la suivante : http://localhost:8181/cxf/olivier/Cette adressereprésente ce qu'on appelle le « endpoint » (point terminal) de notre web service.

À partir de ce endpoint, on pourra accéder aux ressources - customers ou orders - via les URL suivantes :

http://localhost:8181/cxf/olivier/customers/

ou

http://localhost:8181/cxf/olivier/orders/

Il suffit ensuite de choisir, dans le client REST, la méthode d'accès à la ressource (GET, POST, PUT, DELETE), de fournir éventuellement un identifiant dans l'URL pour identifier l'entité à laquelle on souhaite accéder et/ou de fournir éventuellement le corps (body) du message que l'on souhaite transmettre (au format JSON ou XML par exemple - ce format dépend du header HTTP qu'on a renseigné).

II - Qu'est-ce que KARAF ?

Karaf est un serveur d'application basé sur les spécifications OSGI. Ces spécifications définissent un modèle de développement dans lequel les applications sont composées de plusieurs composants. Ces spécifications permettent aux composants de cacher leur implémentation aux autres composants en communiquant à l'aide de services partagés entre tous les composants.

Karaf est composé, entre autres d'un module appelé « Blueprint ».

Blueprint fournit un framework d'injection de dépendances pour OSGI et a été standardisé par l'alliance OSGI. Il consiste à travailler avec la nature dynamique des composants OSGI, où les services peuvent devenir disponibles ou indisponibles à n'importe quel moment.

Blueprint permet, via un container, de superviser l'état des composants dans le framework et d'accomplir des actions en fonction de leur état.

Un composant est considéré être un composant Blueprint à partir du moment où il contient un ou plusieurs fichiers XML Blueprint. Ces fichiers XML sont localisés sous le répertoire OSGI-INF/blueprint comme nous le verrons plus tard.

Dès que Blueprint a déterminé qu'un composant est un composant Blueprint, il crée un container Blueprint basé sur le nom de ce composant. Ce container Blueprint est responsable de :

- parser les fichiers XML Blueprint ;

- instancier les composants ;

- relier les composants entre eux ;

- enregistrer les services ;

- chercher les références des autres services.

Pour plus d'informations sur Blueprint, voir le site officiel : http://aries.apache.org/modules/blueprint.html

Le site officiel de Apache Karaf est le suivant : http://karaf.apache.org/

Les avantages de OSGI sont présentés sur le site officiel du consortium : http://www.osgi.org/Main/HomePage

III - Problématique

Maintenant que nous avons posé les bases du fonctionnement des architectures REST, OSGI et du fonctionnement de Karaf, il peut être intéressant de savoir comment développer un RESTful web service  en JAVA sous Eclipse avec un minimum de configuration et en gagnant donc un maximum de temps.

Nous utiliserons, pour cela, un archetype MAVEN ainsi que le framework de services open source « Apache CXF ». CXF aide à construire et développer des services en utilisant des API comme JAX-WS et JAX-RS. Dans notre cas, nous utiliserons JAX-RS.

Le but de ce projet est de créer une application simple de gestion de clients et de commandes.

IV - Configuration logicielle

Les logiciels utilisés dans ce tutoriel sont les suivants :

Eclipse Mars

Karaf 4.0.2

V - Configuration d'Eclipse et de MAVEN

1. Il convient d'abord de configurer correctement le MAVEN embarqué dans Eclipse. Pour cela, allez dans Windows ? Preferences ? Maven ? User Settings et vérifiez le répertoire qui apparaît dans la section « User Settings » (ci-dessous, « C:\Users\orozier\.m2\settings.xml »)

2. Créez dans le répertoire « .m2 » (à adapter selon vos besoins) un fichier setting.xml et remplissez-le de la manière suivante :

setting.xml

1. <settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">

3. <localRepository>${user.home}/.m2/repository</localRepository>

4. <interactiveMode>true</interactiveMode>

5. <usePluginRegistry>false</usePluginRegistry>

6. <offline>false</offline>

7. <pluginGroups/>

8. <servers/>

9. <proxies>

10. <proxy>

11. <id>1</id>

12. <active>true</active>

13. <protocol>http</protocol>

14. <host>proxy.XXXXX</host> <!—Écrire le nom de votre proxy-->

15. <port>8080</port><!—Écrire le port de votre proxy-->

16. <nonProxyHosts>localhost|127.0.0.1</nonProxyHosts>

17. </proxy>

18. <proxy>

19. <id>2</id>

20. <active>true</active>

21. <protocol>https</protocol>

22. <host>proxy.XXXXX</host><!—Écrire le nom de votre proxy-->

23. <port>8080</port><!—Écrire le port de votre proxy-->

24. <nonProxyHosts>localhost|127.0.0.1</nonProxyHosts>

25. </proxy>

26. </proxies>

27. <profiles/>

28. <activeProfiles/>

29. </settings>

3. Afin de voir le repository de MAVEN dans Eclipse, allez dans le menu Windows ? Show view ?Other ?Maven ?Maven Repository.
L'onglet « Maven Repositories » apparaît alors.

4. Dans l'arborescence, allez dans « Global Repositories » et cliquez droit sur « central (https://repo.maven.apache.org/maven2) » et choisissez « Rebuild index »

L'intégralité du repository Maven apparaît quelques instants plus tard, ce qui signifie que Maven est correctement configuré. Si ce n'est pas le cas, un fichier log est disponible sous le workspace d'Eclipse dans le répertoire « \.metadata\.plugins\org.eclipse.m2e.logback.configurator\ ».

VI - Création d'un nouveau projet Maven à l'aide de l'archetype karaf-blueprint

Nous avons vu, plus haut, que Karaf s'appuyait sur Blueprint. Nous allons donc chercher un archetype MAVEN adapté à Blueprint afin de nous éviter des efforts de configuration. Nous n'aurons donc plus qu'à adapter le fichier XML de Blueprint selon nos besoins.

1. File ? New ? Maven Project

2. Sur la fenêtre qui s'affiche, cliquez sur le bouton « Next »

3. Dans le champ « Filter », saisissez « blueprint » puis, dans la liste qui apparaît, choisissez la ligne correspondant à « karaf-blueprint-archetype » puis cliquez sur le bouton « Next »

4. Renseignez la fenêtre qui apparaît de cette manière :
Group ID : RestFull_Webservice_Karaf
Artefact Id : TestRestServiceKaraf
Version : 0.0.1-SNAPSHOT
Dans la section « Properties available from archetype », attribuez la valeur « RestFull_Webservice_Karaf.TestRestServiceKaraf ».
Puis cliquez sur le bouton « Finish ».

5. Un nouveau projet est créé dans l'explorateur de projets d'Eclipse :

6. Renommez l'interface « MyService » et la classe « MyServiceImpl » via un clic droit ?« Refactor » ? « Rename » respectivement en « CustomerService » et « CustomerServiceImpl ».
Le fichier CustomerSerice.java contient donc ceci :

CustomerService.java

1. package RestFull_Webservice_Karaf.TestRestServiceKaraf ;

3. public interface CustomerService

4. {

5. public String echo(String message);

6. }

Le fichier CustomerServiceImpl contient ceci :

CustomerServiceImpl.java

1. package RestFull_Webservice_Karaf.TestRestServiceKaraf ;

3. public class CustomerServiceImpl implements CustomerService

4. {

5. public String echo(String message)

6. {

7. return "Echo processed: " + message;

8. }

9. }

7. Nous allons créer une classe CustomerBean en cliquant droit sur le package « RestFull_Webservice_Karaf.TestRestServiceKaraf » ? « New » ? « Class »

8. Complétez la classe de cette manière :

CustomerBean.java

1. package RestFull_Webservice_Karaf.TestRestServiceKaraf;

3. import javax.xml.bind.annotation.XmlRootElement;

5. /**

6. * La classe CustomerBean est un objet JAVA contenant des méthodes get et set

7. * <p/>

8. * En ajoutant l'annotation @XmlRootElement, nous offrons la possibilité à JAXB de transformer cet objet en document XML et inversement.

9. * <p/>

10. * La représentation XML d'un customer ressemblera à ceci :

11. * <Customer>

12. * <id>123</id>

13. * <name>Olivier</name>

14. * </Customer>

15. */

16. @XmlRootElement(name = "Customer")

17. public class CustomerBean

18. {

19. private long id;

20. private String name;

22. public long getId()

23. {

24. return id;

25. }

27. public void setId(long id)

28. {

29. this.id = id;

30. }

32. public String getName()

33. {

34. return name;

35. }

37. public void setName(String name)

38. {

39. this.name = name;

40. }

41. }

9. De la même manière, ajoutez les classes OrderBean, Product et Products.

10. Dans le fichier  pom.xml, ajoutez les lignes suivantes entre la balise fermante </description> et la balise ouvrante <build> afin d'ajouter les bibliothèques nécessaires au webservice en tant que dépendances Maven :

pom.xml

1. <properties>

2. <cxf.version>3.1.3</cxf.version>

3. <osgi.version>6.0.0</osgi.version>

4. <project.build.outputEncoding>UTF-8</project.build.outputEncoding>

5. </properties>

7. <dependencies>

8. <dependency>

9. <groupId>org.osgi</groupId>

10. <artifactId>org.osgi.core</artifactId>

11. <version>${osgi.version}</version>

12. <scope>provided</scope>

13. </dependency>

15. <dependency>

16. <groupId>org.apache.cxf</groupId>

17. <artifactId>cxf-rt-frontend-jaxrs</artifactId>

18. <version>${cxf.version}</version>

19. <scope>provided</scope>

20. </dependency>

21. <dependency>

22. <groupId>org.apache.cxf</groupId>

23. <artifactId>cxf-rt-frontend-jaxws</artifactId>

24. <version>${cxf.version}</version>

25. <scope>provided</scope>

26. </dependency>

27. <dependency>

28. <groupId>org.apache.cxf</groupId>

29. <artifactId>cxf-rt-transports-http</artifactId>

30. <version>${cxf.version}</version>

31. <scope>provided</scope>

32. </dependency>

33. <dependency>

34. <groupId>org.apache.cxf</groupId>

35. <artifactId>cxf-rt-transports-http-jetty</artifactId>

36. <version>${cxf.version}</version>

37. <scope>provided</scope>

38. </dependency>

39. </dependencies>

Le contenu de la balise <osgi.version> dépendra de la version de Karaf utilisée. Les matrices de compatibilité sont disponibles ici :

Pour Karaf 4.0.X :

http://karaf.apache.org/index/documentation/karaf-dependencies/karaf-deps-4.0.x.html

Pour Karaf 3.0.X :

http://karaf.apache.org/index/documentation/karaf-dependencies/karaf-deps-3.0.x.html

Pour Karaf 2.4.X :

http://karaf.apache.org/index/documentation/karaf-dependencies/karaf-deps-2.4.x.html

Pour Karaf 2.3.X :

http://karaf.apache.org/index/documentation/karaf-dependencies/karaf-deps-2.3.x.html

Il suffit, dans le tableau proposé dans chacun des liens ci-dessus, de regarder la ligne « OSGI ».

Dès lors, Karaf utilisera le repository Maven pour récupérer les bibliothèques nécessaires à notre RESTful web service.

11. Dans le fichier pom.xml, supprimez la ligne :

pom.xml

1. <Export-Package>RestFull_Webservice_Karaf.TestRestServiceKaraf *;version=${project.version}</Export-Package>

La balise « Export-Package » permet d'indiquer les packages qui seront exportés afin que d'autres Web Service puissent utiliser les interfaces et les classes de ce package lors de leur exécution. Dans notre cas, aucun Web Service n'aura à appeler de package, la balise « Export-Package » n'est donc pas nécessaire.

12. Configurez le fichier src/main/resources/OSGI-INF/blueprint/my-service.xml  de la manière suivante :

my-service.xml

1. <blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.0.0" xmlns:jaxws="http://cxf.apache.org/blueprint/jaxws" xmlns:jaxrs="http://cxf.apache.org/blueprint/jaxrs" xmlns:cxf="http://cxf.apache.org/blueprint/core" xsi:schemaLocation="http://www.osgi.org/xmlns/blueprint/v1.0.0 http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd http://cxf.apache.org/blueprint/jaxws http://cxf.apache.org/schemas/blueprint/jaxws.xsd http://cxf.apache.org/blueprint/jaxrs http://cxf.apache.org/schemas/blueprint/jaxrs.xsd  http://cxf.apache.org/blueprint/core http://cxf.apache.org/schemas/blueprint/core.xsd">

2. <jaxrs:server address="/olivier" id="someRestService">

3. <jaxrs:serviceBeans>

4. <ref component-id="CustomerServiceImpl"/>

5. </jaxrs:serviceBeans>

6. </jaxrs:server>

7. <bean id="CustomerServiceImpl" class="RestFull_Webservice_Karaf.TestRestServiceKaraf.CustomerServiceImpl" /> </blueprint>

Ce fichier permet d'enregistrer le service dans le registre des services et d'indiquer que son implémentation est CustomerServiceImpl. On remarque au passage qu'on y indique notre endpoint (« olivier » ici).

13. Modifiez le fichier CustomerService.java pour y définir la classe CustomerService comme suit :

CustomerService.java

1. package RestFull_Webservice_Karaf.TestRestServiceKaraf;

3. import javax.ws.rs.Consumes;

4. import javax.ws.rs.DELETE;

5. import javax.ws.rs.GET;

6. import javax.ws.rs.POST;

7. import javax.ws.rs.PUT;

8. import javax.ws.rs.Path;

9. import javax.ws.rs.PathParam;

10. import javax.ws.rs.Produces;

11. import javax.ws.rs.core.Response;

12. public interface CustomerService

13. {

14. /**

15. * Cette méthode est mappée à une requête HTTP GET : "http://localhost:8181/cxf/olivier/customers/{id}". La valeur

16. * de {id} sera passée en paramètre à la méthode par utilisation de l'annotation @PathParam.

17. * <p/>

18. * La méthode retournera un objet de la classe CustomerBean par création d'une réponse HTTP. Cet objet sera transformé en XML par JAXB.

19. * <p/>

20. * Par exemple, l'appel de l'URL "http://localhost:8181/cxf/olivier/customers/123" provoquera l'affichage du customer 123 au format XML.

21. */

22. @GET

23. @Path("/customers/{id}/")

24. @Produces("application/xml")

25. public CustomerBean getCustomer(@PathParam("id") String id);

27. /**

28. * Cette méthode est mappée à une requête HTTP PUT. On peut ainsi envoyer la représentation XML d'un objet customerBean.

29. * La représentation XML sera obtenue par transformation d'un CustomerBean par JAXB.

30. * <p/>

31. * Cette méthode met à jour un objet CustomerBean dans notre map locale puis utilise la classe Response pour construire

32. * une réponse HP appropriée : soit OK si la mise à jour a été effectuée avec succès (Traduction du statut HTTP 200/OK)

33. * ou NON MODIFIE si la mise à jour de l'objet CustomerBean a échoué (Traduction du statut HTTP 304/Not Modified).

34. * <p/>

35. * À NOTER : cette méthode utilise la même valeur de @path que la méthode suivante. La méthode HTTP utilisée déterminera

36. * quelle sera la méthode à invoquer

37. *

38. */

39. @PUT

40. @Path("/customers/")

41. @Consumes({"application/xml", "application/json" })

42. public Response updateCustomer(CustomerBean customer);

46. /**

47. * Utilisation de la requête HTTP POST permettant d'ajouter un nouveau customer au système en uploadant la représentation XML

48. * d'un objet CustomerBean.

49. * Cette opération sera mappée à la méthode ci-dessous et la représentation XML sera transformée en un objet CustomerBean.

50. * <p/>

51. * Après que cette méthode aura ajouté le client dans la map local, elle utilisera la classe Response pour construire la réponse HTTP

52. * en retournant à la fois l'objet CustomerBean inséré et le statut HTTP 200/OK. Ceci permet de récupérer l'ID du nouvel objet CustomerBean.

53. *<p/>

54. * À NOTER : cette méthode utilise la même valeur de @path que la méthode précédente. La méthode HTTP utilisée déterminera

55. * quelle sera la méthode à invoquer

56. */

57. @POST

58. @Path("/customers/")

59. @Consumes({"application/xml", "application/json" })

60. public Response addCustomer(CustomerBean customer);

64. /**

65. * Cette méthode est mappée à une requête HTTP DELETE du type : "http://localhost:8181/cxf/olivier/customers/{id}".

66. * La valeur pour {id} sera passée en tant que paramètre en utilisant l'annotation @PathParam.

67. * <p/>

68. * Cette méthode utilise la classe Response pour créer une réponse HTTP : soit le statut HTTP 200/OK si l'objet CustomerBean

69. * a été correctement supprimé de la map locale, soit le statut HTTP 304/Not Modified si la suppression a échoué.

70. */

71. @DELETE

72. @Path("/customers/{id}/")

73. public Response deleteCustomer(@PathParam("id") String id);

76. /**

77. * Cette méthode est mappée à une requête HTTP GET du type : "http://localhost:8181/cxf/olivier/orders/{id}".

78. * La valeur pour {id} sera passée en tant que paramètre en utilisant l'annotation @PathParam.

79. * <p/>

80. * La méthode retournera un objet de la classe Product par création d'une réponse HTTP. Cet objet sera transformé en XML par JAXB.

81. * <p/>

82. * Par exemple, l'appel de l'URL "http://localhost:8181/cxf/olivier/orders/223" provoquera l'affichage du customer 123 au format XML.

83. */

84. @GET

85. @Path("/orders/{orderId}")

86. @Produces("application/xml")

87. public OrderBean getOrder(@PathParam("orderId") String orderId);

90. /**

91. * Cette méthode est mappée à une requête HTTP GET du type : "http://localhost:8181/cxf/olivier/orders/{id}/products/{productId}".

92. * La valeur pour {id} et {productId} sera passée en tant que paramètre en utilisant l'annotation @PathParam.

93. * <p/>

94. * La méthode retournera un objet de la classe Product par création d'une réponse HTTP. Cet objet sera transformé en XML par JAXB.

95. * <p/>

96. * Par exemple, l'appel de l'URL "http://localhost:8181/cxf/olivier/orders/223/products/323/" provoquera l'affichage du customer 123 au format XML.

97. */

98. @GET

99. @Path("/orders/{orderId}/products/{productId}")

100. @Produces("application/xml")

101. public Product getProduct(@PathParam("orderId") String orderId,@PathParam("productId") int productId);

104. /**

105. * Cette méthode est mappée à une requête HTTP GET du type : "http://localhost:8181/cxf/olivier/orders/{id}/products".

106. * La valeur pour {id} sera passée en tant que paramètre en utilisant l'annotation @PathParam.

107. * <p/>

108. * La méthode retournera un objet de la classe Product par création d'une réponse HTTP. Cet objet sera transformé en XML par JAXB.

109. * <p/>

110. * Par exemple, l'appel de l'URL "http://localhost:8181/cxf/olivier/orders/223/products/323/" provoquera l'affichage du customer 123 au format XML.

111. */

112. @GET

113. @Path("/orders/{orderId}/products")

114. @Produces("application/xml")

115. public Products getProducts(@PathParam("orderId") String orderId);

117. }

14. Modifiez le fichier CustomerServiceImpl.java pour y définir la classe CustomerServiceImpl comme suit :

CustomerServiceImpl.java

1. package RestFull_Webservice_Karaf.TestRestServiceKaraf ;

3. import java.util.HashMap;

4. import java.util.Map;

5. import javax.ws.rs.core.Response;

6. import javax.ws.rs.PathParam;

7. import org.slf4j.Logger;

8. import org.slf4j.LoggerFactory;

9. public class CustomerServiceImpl implements CustomerService

10. {

11. private static final Logger LOG = LoggerFactory.getLogger(CustomerService.class);

13. long currentId = 123;

14. Map<Long, CustomerBean> customers = new HashMap<Long, CustomerBean>();

15. Map<Long, OrderBean> orders = new HashMap<Long, OrderBean>();

17. public CustomerServiceImpl()

18. {

19. init();

20. }

23. /**

24. * Cette méthode est utilisée par le constructeur pour insérer un objet CustomerBean et un objet OrderBean dans la map locale pour tester.

25. */

26. final void init()

27. {

28. LOG.info("Appel de la méthode init de CustomerServiceImpl");

29. CustomerBean c = new CustomerBean();

30. c.setName("Olivier");

31. c.setId(123);

32. customers.put(c.getId(), c);

34. OrderBean o = new OrderBean();

35. o.setDescription("order 223");

36. o.setId(223);

37. orders.put(o.getId(), o);

38. }

42. //code retour = 500: ID invalid

43. //code retour = 204: customer non trouve

44. public CustomerBean getCustomer(String id)

45. {

46. LOG.info("Appel de getCustomer avec l'identifiant: {}", id);

47. long idNumber = Long.parseLong(id);

48. CustomerBean c = customers.get(idNumber);

49. return c;

50. }

53. public Response updateCustomer(CustomerBean customer)

54. {

55. LOG.info("Mise à jour d'un client dont le nom est : {}", customer.getName());

56. CustomerBean c = customers.get(customer.getId());

57. Response r;

58. if (c != null)

59. {

60. customers.put(customer.getId(), customer);

61. r = Response.ok().build();

62. }

63. else

64. {

65. r = Response.notModified().build();

66. }

68. return r;

69. }

72. public Response addCustomer(CustomerBean customer)

73. {

74. LOG.info("Ajout d'un client dont le nom est : {}", customer.getName());

75. customer.setId(++currentId);

77. customers.put(customer.getId(), customer);

78. return Response.ok().type("application/xml").entity(customer).build();

79. }

82. public Response deleteCustomer(String id)

83. {

84. LOG.info("Suppression d'un client dont l'identifiant est : {}", id);

85. long idNumber = Long.parseLong(id);

86. CustomerBean c = customers.get(idNumber);

88. Response r;

89. if (c != null)

90. {

91. r = Response.ok().build();

92. customers.remove(idNumber);

93. }

94. else

95. {

96. r = Response.notModified().build();

97. }

99. return r;

100. }

103. public OrderBean getOrder(String orderId)

104. {

105. LOG.info("Récupération de la commande d'identifiant : {}", orderId);

106. long idNumber = Long.parseLong(orderId);

107. OrderBean c = orders.get(idNumber);

108. return c;

109. }

112. public Product getProduct(String orderId, int productId)

113. {

114. LOG.info("Récupération de la commande: {}", orderId);

115. long idNumber = Long.parseLong(orderId);

116. OrderBean c = orders.get(idNumber);

117. //return c;

119. LOG.info("Récupération du produit d'identifiant : " + productId);

120. Product p = c.getProduct(productId);

121. return p;

122. }

124. public Products getProducts(String orderId)

125. {

126. LOG.info("Récupération des produits de la commande : {}", orderId);

127. long idNumber = Long.parseLong(orderId);

128. OrderBean c = orders.get(idNumber);

129. //return c;

131. Products p = c.getProducts();

132. return p;

133. }

134. }

15. Modifiez le fichier OrderBean.java pour y définir la classe OrderBean comme suit :

OrderBean.java

1. package RestFull_Webservice_Karaf.TestRestServiceKaraf;

3. import java.util.HashMap;

4. import java.util.Map;

5. import java.util.ArrayList;

7. import javax.xml.bind.annotation.XmlRootElement;

9. import org.slf4j.Logger;

10. import org.slf4j.LoggerFactory;

12. /**

13. * La classe OrderBean est un objet JAVA contenant des méthodes get et set et est aussi utilisée pour les commandes retournées par

14. * la classe CustomerServiceImpl.

15. * <p/>

16. * En ajoutant l'annotation @XmlRootElement, nous offrons la possibilité à JAXB de transformer cet objet en document XML et inversement.

17. * <p/>

18. * La représentation XML pour un OrderBean est la suivante :

19. * <Order>

20. * <id>223</id>

21. * <description>Order 223</description>

22. * </Order>

23. */

25. @XmlRootElement(name = "Order")

26. public class OrderBean

27. {

28. private static final Logger LOG = LoggerFactory.getLogger(CustomerService.class);

30. private long id;

31. private String description;

32. //private Map<Long, Product> products = new HashMap<Long, Product>();

33. private Products products = new Products();

35. public OrderBean()

36. {

37. init();

38. }

40. final void init()

41. {

42. products.setProducts(new ArrayList<Product>());

43. Product p1 = new Product();

44. p1.setId(323);

45. p1.setDescription("product 323");

47. Product p2 = new Product();

48. p2.setId(324);

49. p2.setDescription("product 324");

51. products.getProducts().add(p1);

52. products.getProducts().add(p2);

53. }

55. public long getId()

56. {

57. return id;

58. }

60. public void setId(long id)

61. {

62. this.id = id;

63. }

65. public String getDescription()

66. {

67. return description;

68. }

70. public void setDescription(String d)

71. {

72. this.description = d;

73. }

75. public Product getProduct(int productId)

76. {

77. Product prod = null;

78. for(Product p : products.getProducts())

79. {

80. if(p.getId()==productId)

81. {

82. prod = p;

83. }

84. }

85. return prod;

86. }

88. public Products getProducts()

89. {

90. return products;

91. }

92. }

16. Modifiez le fichier Product.java pour y définir la classe Product comme suit :

Product.java

1. package RestFull_Webservice_Karaf.TestRestServiceKaraf;

3. import javax.xml.bind.annotation.XmlRootElement;

5. /**

6. * La classe Product est un objet JAVA contenant des méthodes get et set

7. * <p/>

8. * En ajoutant l'annotation @XmlRootElement, nous offrons la possibilité à JAXB de transformer cet objet en document XML et inversement.

9. * <p/>

10. * La représentation XML d'un Product ressemblera à ceci :

11. *

12. * <Product>

13. * <id>10010</id>

14. * <description>produit 1</description>

15. * </Product>

16. */

17. @XmlRootElement(name = "Product")

18. public class Product

19. {

20. private long id;

21. private String description;

23. public long getId()

24. {

25. return id;

26. }

28. public void setId(long id)

29. {

30. this.id = id;

31. }

33. public String getDescription()

34. {

35. return description;

36. }

38. public void setDescription(String d)

39. {

40. this.description = d;

41. }

42. }

17. Modifiez le fichier Products.java pour y définir la classe Products comme suit :

Products.java

1. package RestFull_Webservice_Karaf.TestRestServiceKaraf;

3. import javax.xml.bind.annotation.XmlRootElement;

4. import javax.xml.bind.annotation.XmlElement;

5. import javax.xml.bind.annotation.XmlAccessType;

6. import javax.xml.bind.annotation.XmlAccessorType;

7. import java.util.List;

9. /**

10. * La classe Product est un objet JAVA contenant une liste de produits.

11. * <p/>

12. * En ajoutant l'annotation @XmlRootElement, nous offrons la possibilité à JAXB de transformer cet objet en document XML et inversement.

13. *

14. * <Products>

15. *     <Product>

16. *         <id>10010</id>

17. *         <description>Produit 1</description>

18. *     </Product>

19. *    <Product>

20. *         <id>10011</id>

21. *         <description>Produit 2</description>

22. *    </Product>

23. * <Products>

24. */

26. @XmlRootElement(name = "Products")

27. @XmlAccessorType (XmlAccessType.FIELD)

28. public class Products

29. {

30. @XmlElement(name = "Product")

31. private List<Product> productsList = null;

33. public List<Product> getProducts()

34. {

35. return productsList;

36. }

38. public void setProducts(List<Product> productsList)

39. {

40. this.productsList = productsList;

41. }

42. }

VII - Compilation et Build

1. Cliquez droit sur le projet ? Run as ?Maven build

2. Dans le champ « Goals », écrivez « clean install », puis appuyez sur le bouton run

3. Le message suivant apparaît alors :

On peut y lire dans quel répertoire récupérer l'archive jar.

Il s'agit du répertoire que vous configurez dans Eclipse via Windows ? Preferences ? Maven ?User Settings

VIII - Installation et configuration de karaf

1. Téléchargez et installez Karaf 4.0.2 sur le site http://karaf.apache.org/index/community/download.html

2. Exécutez le fichier « karaf.bat » qui se situe dans le répertoire « bin ».

3. Installez éventuellement la console d'administration via la commande :
feature:install webconsole

4. À l'issue de cette installation, on peut accéder à la console d'administration de karaf via l'URL : http://localhost:8181/system/console/
Par défaut, l'utilisateur est karaf et le mot de passe est karaf.

5. Ajoutez le repository cxf afin que Karaf puisse installer les caractéristiques propres à cxf. Pour cela, tapez la commande suivante dans l'invite de commande :
feature:repo-add cxf 3.0.6

6. Tapez la commande suivante afin de vérifier que les caractéristiques cxf sont prêtes à être installées :
feature:repo-list
Une ligne « cxf-3.0.6 » doit alors apparaître.

7. Si la ligne cxf-3.0.6 apparaît, l'installation peut être faite via la commande :
feature:install cxf

8. Vérifiez l'installation via la commande suivante :
feature:list | grep cxf

9. Déposez le fichier jar créé plus haut dans le répertoire « deploy » de Karaf puis redémarrez Karaf.

10. On peut désormais voir si notre OSGI bundle a été installé avec la commande :
Bundle:list

Sur la capture d'écran ci-dessus, on peut voir la ligne correspondant à notre bundle « TestRestServiceKara Blueprint Bundle ». Ce libellé peut-être configuré dans le fichier pom.xml avant de construire l'archive Jar dans Eclipse. Il s'agit alors de modifier le contenu des balises :

xml

<name>TestRestServiceKaraf Blueprint Bundle</name>
<description>TestRestServiceKaraf OSGi blueprint bundle project.</description>

11. Via la commande :
cxf:list-endpoints
on peut voir les endpoints cxf qui ont été installés. On peut y voir le nôtre :

IX - Conclusion

Comme nous venons de le voir, le développement de RESTful web service pour Karaf est très rapide et très simple sous Eclipse, notamment avec l'utilisation de MAVEN et de l'archetype « karaf-blueprint ».

Cette méthode n'a rien à envier à Talend ESB.

Le code source de l'exemple dont il est question dans ce tutoriel est disponible à l'adresse suivante : olivier-rozier.developpez.com/tutoriels/rest/restful-webservice-karaf-eclipse/fichiers/TestRestServiceKaraf.zip

Nous venons d'étudier les bases de la création d'un RESTful web service pour Karaf .

Il serait intéressant désormais de connaître la manière de développer un RESTful web service découpé en couches applicatives et la manière d'accéder à une base de données en utilisant les Datasource et Datasource factory de Karaf. C'est ce que nous étudierons dans le tutoriel « Tutoriel pour développer et déployer un service Web RESTFUL OSGI multibundle sous Eclipse et Karaf ».

Je tiens à remercier Mickaël Baron pour la relecture technique de cet article ainsi que Claude Leloup pour la relecture orthographique.

Index

- A -

Eclipse Mars (1)

- K -

PUT (1), (2)

archetype (1)

endpoint (1)

Karaf (1), (2), (3), (4), (5), (6), (7), (8)

- R -

archetype MAVEN (1), (2)

- G -

Karaf . (1)

REST (1), (2), (3), (4), (5), (6), (7), (8), (9), (10)

- B -

GET (1), (2)

Karaf 4.0.2 (1)

RESTful web service (1), (2), (3), (4)

Blueprint (1), (2), (3), (4), (5), (6), (7), (8), (9), (10), (11), (12), (13)

- H -

- M -

- U -

- C -

HTTP (1), (2), (3)

MAVEN (1), (2), (3)

URL (1), (2), (3)

CXF (1)

- J -

- O -

- X -

- D -

JAVA (1)

omman (1)

XML (1), (2), (3), (4), (5), (6), (7)

DELETE (1), (2)

JAX-RS (1), (2)

OSGI (1), (2), (3)

- E -

JAX-WS (1)

- P -

Eclipse (1), (2), (3), (4), (5), (6), (7)

JSON (1), (2), (3), (4)

POST (1), (2)