TP Implémentation de services sur Java/Spring/CXF

L'objectif de ce TP est de comprendre les principes d'implémentation de Web services illustrés à travers la plateforme Java en utilisant le _framework_ SpringBoot ainsi que le _framework_ CXF.

Un projet de démarrage est fourni et comprend l'implémentation de base des fonctionnalités métier (module `metier`). Il vous sera demandé de compléter ce projet en développant une application SpringBoot permettant d'exposer sous la forme d'un ensemble de services Web.

Modalités de rendu

Ce TP est à rendre pour le dimanche 18/12/2016 en inscrivant l'indentifiant d'un projet forge dans la case tomuss `TP8_ImplWS` de l'UE “TIW1 Intergiciels et Services”. Cet identifiant devra être saisi par les deux membres du binôme le cas échéant.

On rappelle que l'indentifiant d'un projet forge étudiant:
* Commence par `p`
* N'est pas une URL (ne contient pas `http`, ni `https`)

Code métier fourni

Le module `metier` implémente une fonctionnalité simple de création et gestion de cours en ligne. Il est possible de créer un cours avec des intervenants (_i.e._ des enseignants), d'y ajouter des participants (_i.e._ des élèves) et d'envoyer une facture aux différentes organisations ayant envoyé des personnes suivre ce cours (en pratique: afficher une ligne dans le log).

Le module `services` contient un embryon de projet SpringBoot et constituera la base du code à développer dans ce TP.

Services SOAP

On implémentera le service décrit dans le fichier `cours.wsdl`. On commencera par générer du code Java correspondant à la description du service et on implémentera le coeur du service. On reconsitituera ensuite de manière simplifiée le travail effectué par le framework CXF pour exposer le service.

Génération de code

Utiliser le plugin `cxf-codegen-plugin` (doc) pour générer une interface Java représentant le service à implémenter.

Le code généré ne devra pas être versionné et se trouvera (par défaut) dans l'arborescence du répertoire `target`.
Il est d'ailleurs conseillé de ne pas configurer de `sourceRoot`.

Parcourir le code généré et faire le lien avec le contenu du fichier `cours.wsdl`.

Composant d'implémentation du service

Créer un composant Spring:

qui implémente l'interface générée ;
annoté par `@WebService`;
qui utilise le composant `CoursManager` pour l'implémentation du métier.

Déployer ce composant dans CXF. On pourra pour celui s'inspirer du tutoriel suivant: Bringing Spring Boot & Apache CXF up and running, en particulier en adaptant le code ci-dessous pour activer le framework CXF :

  @SpringBootApplication
  public class SimpleBootCxfApplication {
   
      public static void main(String[] args) {
  	SpringApplication.run(SimpleBootCxfApplication.class, args);
      }
   
      @Bean
      public ServletRegistrationBean dispatcherServlet() {
          return new ServletRegistrationBean(new CXFServlet(), "/soap-api/*");
      }
   
      @Bean(name=Bus.DEFAULT_BUS_ID)
      public SpringBus springBus() {      
          return new SpringBus();
      }
  }

Lire la suite de ce tutoriel pour comprendre comment exposer le composant Spring comme service via CXF (_i.e._ ajouter le bean das la configuration et le rendre disponible via un endpoint CXF).

> Attention: bien remplir l'annotation `@WebService` en spécifiant de préférence à cet endroit l'emplacement du wsdl, plutôt que dans la configuration du `EndpointImpl`CXF. Attention également aux packages de `javax.xml.ws.Endpoint` et de `org.apache.cxf.jaxws.EndpointImpl` (non précisés dans le tutoriel)

Allez à l'URL http://localhost:8080/soap-ui/ et vérifiez que votre service est bien listé.

Tester son fonctionnement avec soapUI.

Contrôleur du service

Le rôle de ce contrôleur est double: extraire le contenu XML dans des instances de classes Java et aiguiller la suite du traitement vers la bonne méthode du composant d'implémentation du service.

Créer un nouveau composant Spring implémentant l'interface [`Provider<Source>`](https://docs.oracle.com/javaee/7/api/index.html?javax/xml/ws/Provider.html). La méthode `invoke` devra convertir le XML du _payload_ en objets Java et appeler la bonne méthode du composant d'implémentation du service que vous avez mis en place à l'étape précédente.

Déployer ce composant comme un Web service à une autre adresse et tester avec [soapUI](http://www.soapui.org/).

Contrôleur principal (_front_)

Implémenter un contrôleur point d'accès au service via un [`@Controller`](http://docs.spring.io/spring/docs/current/javadoc-api/index.html?org/springframework/web/servlet/mvc/Controller.html) SpringMVC. Ce contrôleur traitera les requêtes HTTP et extraira le contenu (_payload_) du message via l'API SAAJ. Il redirigera ensuite le traitement vers le composant Web service provider de l'étape précédente.

Utiliser [soapUI](http://www.soapui.org/) pour tester votre contrôleur point d'accès.

Comme indiqué dans `cours.wsdl`, le service déployé devra être accessible à l'adresse [`http://localhost:8080/services-sans-cxf/cours`](http://localhost:8080/services-sans-cxf/cours). Il faut donc bien configurer le `@RequestMapping` en fonction de cette URL.

Auteur: Emmanuel Coquery