API Java des services Web XML

L'API Java™ des services Web XML (JAX-WS), également appelée JSR-224, est le modèle de programmation de services Web nouvelle génération qui étend la base mise à disposition par le modèle de programmation de l'API Java pour RPC à base XML (JAX-RPC). Avec JAX-WS, le développement de services Web et de clients est simplifié, grâce à une meilleure indépendance de la plateforme pour les applications Java via l'utilisation de proxys dynamiques et d'annotations Java. Les outils de service Web inclus dans ce produit prennent en charge JAX-WS 2.0, 2.1 et 2.2.

JAX-WS est un nouveau modèle de programmation qui simplifie le développement d'application via la prise en charge d'un modèle standard basé sur les annotations permettant de développer des clients et des applications de service Web. La norme de programmation JAX-WS s'aligne de façon stratégique sur la tendance en cours du secteur d'activité vers un modèle de messagerie davantage orienté document et remplace le modèle de programmation d'appel de procédure éloignée, comme défini par JAX-RPC. Bien que ce produit prenne encore en charge les applications et le modèle de programmation JAX-RPC, JAX-RPC impose des limites et ne prend pas en charge de nombreux services orientés document courants. JAX-WS constitue le modèle de programmation stratégique pour le développement de services Web et est un élément requis de la plateforme Java EE 5.

L'implémentation de la norme de programmation JAX-WS fournit les améliorations suivantes pour le développement de clients et services Web :
Meilleure indépendance de la plateforme pour les applications Java
L'utilisation des API JAX-WS simplifie le développement des clients et des services Web grâce à une meilleure indépendance vis-à-vis des plateformes pour les applications Java. JAX-WS bénéficie des avantages des proxys dynamiques alors que JAX-RPC utilise des modules de remplacement générés. Le client de proxy dynamique appelle un service Web reposant sur une interface de noeud final de service qui est générée ou fournie. Le client de proxy dynamique est similaire au client de module de remplacement dans le modèle de programmation JAX-RPC. Bien que le client de proxy dynamique JAX-WS et le client de module de remplacement JAX-RPC reposent tous les deux sur l'interface de noeud final de service qui est générée à partir d'un fichier WSDL, il existe une différence majeure. Le client de proxy dynamique est généré de façon dynamique au moment de l'exécution, à l'aide de la fonctionnalité de proxy dynamique Java 5, alors que le client de module de remplacement JAX-RPC est un fichier Java non portable qui est généré par des outils. Contrairement aux clients de module de remplacement JAX-RPC, le client de proxy dynamique n'exige pas que vous régénériez un module de remplacement avant l'exécution du client sur un serveur d'applications d'un fournisseur différent, car l'interface générée ne nécessite pas les informations relatives au fournisseur concerné. Reportez-vous au chapitre 4 de la spécification JAX-WS 2.0 pour plus d'informations sur l'utilisation de clients de proxy dynamiques.
Annotations

JAX-WS introduit la prise en charge de l'annotation des classes Java avec des métadonnées afin d'indiquer que la classe Java est un service Web. JAX-WS prend en charge l'utilisation d'annotations reposant sur la spécification Metadata Facility for the Java Programming Language (JSR 175), la spécification Web Services Metadata for the Java Platform (JSR 181), ainsi que l'utilisation d'annotations définies par la spécification JAX-WS 2.0. L'utilisation d'annotations dans la source Java et dans la classe Java simplifie le développement de services Web via la définition de quelques-unes des informations supplémentaires qui sont généralement extraites des fichiers de descripteur de déploiement, des fichiers WSDL ou du mappage de métadonnées des fichiers XML et WSDL vers les artefacts source.

Par exemple, vous pouvez incorporer une balise @WebService simple dans la source Java pour exposer le bean sous la forme d'un service Web.

@WebService 

public class QuoteBean implements StockQuote {

       public float getQuote(String sym) { ... }

}

L'annotation @WebService indique à l'environnement d'exécution du serveur qu'il doit exposer toutes les méthodes publiques sur ce bean sous forme de service Web. D'autres niveaux de granularité peuvent être contrôlés via l'ajout d'annotations supplémentaires dans des méthodes ou paramètres individuels. L'utilisation d'annotations simplifie considérablement l'exposition d'artefacts Java sous forme de services Web. En outre, dans la mesure où les artefacts sont créés à partir de l'utilisation de quelques-uns des outils de mappage descendant en démarrant à l'aide d'un fichier WSDL, des annotations sont incluses dans les classes source et Java afin de capturer les métadonnées conjointement avec les fichiers source.

Appel asynchrone des services Web

Avec JAX-WS, les services Web peuvent être appelés de manière synchrone ou asynchrone. JAX-WS prend en charge un mécanisme d'interrogation et de rappel lors de l'appel asynchrone des services Web. En utilisant un modèle d'interrogation, le client peut émettre une demande et obtenir en retour un objet réponse qui est interrogé pour déterminer si le serveur a répondu. Lorsque le serveur répond, la réponse réelle est extraite. Avec le modèle d'interrogation, le client peut continuer de traiter d'autres travaux sans attendre une réponse. Le modèle de rappel permet au client de fournir un gestionnaire d'appel pour accepter et traiter l'objet réponse entrante. Les modèles de rappel et d'interrogation permettent au client de continuer à traiter les travaux tout en fournissant un modèle plus dynamique et plus efficace pour appeler les services Web.

Par exemple, une interface de service Web comporte des méthodes pour les demandes synchrones et asynchrones.

@WebService
public interface CreditRatingService {
      // Opération synchrone
      Score      getCreditScore(Customer customer);
      // Opération asynchrone avec interrogation
      Response<Score> getCreditScoreAsync(Customer customer);
      // Opération asynchrone avec rappel
      Future<?> getCreditScoreAsync(Customer customer, 
         AsyncHandler<Score> handler);
}

L'appel asynchrone qui utilise le mécanisme de rappel nécessite une entrée supplémentaire de la part du programmeur client. Le gestionnaire d'appel est un objet contenant le code de l'application qui est exécuté lorsqu'une réponse asynchrone est reçue. Voici un exemple de code pour un gestionnaire d'appel asynchrone :

CreditRatingService svc = ...;

Future<?> invocation = svc.getCreditScoreAsync(customerFred,
	new AsyncHandler<Score>() {
	   public void handleResponse (
	       Response<Score> response)
	     {
	       Score score = response.get();
	       // Effectuez des travaux ici...
	     }
   }
);

Voici un exemple de code pour un client d'interrogation asynchrone :

CreditRatingService svc = ...;
Response<Score> response = svc.getCreditScoreAsync(customerFred);

while (!response.isDone()) {
		// Effectuez une opération en attendant
}

// Aucun transtypage nécessaire grâce aux génériques
Score score = response.get();
</Score>
Utilisation de l'injection de ressource

JAX-WS prend en charge l'injection de ressource pour simplifier davantage le développement de services Web. JAX-WS utilise cette fonction clé de Java EE 5 pour déplacer la charge représentée par la création et l'initialisation de ressources communes dans un environnement d'exécution Java de votre application de services Web vers l'environnement de conteneur d'application proprement dit. JAX-WS fournit un support pour un sous-ensemble d'annotations définies dans JSR-250 pour l'injection de ressource et le cycle de vie de l'application dans son environnement d'exécution.

Le serveur d'applications prend également en charge la syntaxe de l'annotation @Resource ou @WebServiceRef pour déclarer des clients gérés JAX-WS et pour demander l'injection de services et de ports JAX-WS. Quand l'une de ces annotations est utilisée dans une zone ou une méthode, une instance de service ou de port JAX-WS est alors injectée. La syntaxe de ces annotations entraîne également la liaison du type spécifié par l'annotation dans l'espace de nom JNDI.

L'annotation @Resource est définie par la spécification relative aux annotations communes JSR-250 qui est incluse dans Java EE 5 (Java Platform, Enterprise Edition 5). En plaçant l'annotation @Resource sur une variable de type javax.xml.ws.WebServiceContext au sein d'une implémentation de noeud final de service, vous pouvez demander une injection de ressource et collecter l'interface javax.xml.ws.WebServiceContext liée à cet appel de noeud final particulier. A partir de l'interface WebServiceContext, vous pouvez collecter l'élément MessageContext pour la demande associée à l'appel de méthode particulier en utilisant la méthode getMessageContext().

L'exemple suivant illustre l'utilisation des annotations @Resource et @WebServiceRef pour l'injection de ressource :
@WebService
public class MyService {
    
    @Resource
    private WebServiceContext ctx;

    @Resource
    private SampleService svc;

    @WebServiceRef
    private SamplePort port;

    public String echo (String input) {
        …
    }
     
}

Pour plus d'informations sur l'injection de ressources, reportez-vous aux sections 5.2.1 et 5.3 de la spécification JAX-WS.

Liaison de données avec JAXB 2.2
JAX-WS exploite l'API et les outils JAXB 2.0 comme technologie de liaison pour les mappages entre les objets Java et les documents XML. Les outils JAX-WS comptent sur les outils JAXB pour la liaison de données par défaut permettant des mappages bidirectionnels entre les objets Java et les documents XML. La liaison de données JAXB remplace la liaison de données décrite par la spécification JAX-RPC.

WebSphere Application Server version 7.0 prend en charge la spécification JAXB 2.1. JAX-WS 2.1 nécessite JAXB 2.1 pour la liaison de données. JAXB 2.1 fournit des améliorations, telles qu'un support de compilation amélioré et la prise en charge de l'annotation @XMLSeeAlso, ainsi que la prise en charge d'un schéma 1.0 complet.

WebSphere Application Server version 8.0 ou ultérieure et WebSphere Application Server Liberty Profile version 8.5.5 prennent en charge la spécification JAXB 2.2. JAX-WS 2.2 requiert JAXB 2.2 pour la liaison des données. JAXB 2.2 fournit des extensions mineures à ses annotations pour améliorer la génération de schéma et offrir de meilleures caractéristiques d'intégration avec JAX-WS.

Clients dynamiques et statiques
L'API de programmation de client dynamique pour JAX-WS est appelée client Dispatch (javax.xml.ws.Dispatch). Le client Dispatch est un client orienté messagerie XML. Les données sont envoyées en mode PAYLOAD ou MESSAGE. En mode PAYLOAD, le client Dispatch est chargé uniquement de fournir le contenu de l'élément <soap:Body>, et JAX-WS ajoute les éléments <soap:Envelope> et <soap:Header>. En mode MESSAGE, le client Dispatch est chargé de fournir l'enveloppe SOAP entière, notamment les éléments <soap:Envelope>, <soap:Header> et <soap:Body>, et JAX-WS n'ajoute pas d'informations supplémentaires au message. Le client Dispatch prend en charge les appels asynchrones à l'aide d'un mécanisme de rappel ou d'interrogation. </soap:Body></soap:Header></soap:Envelope></soap:Header></soap:Envelope></soap:Body>

Le modèle de programmation client statique pour JAX-WS est appelé client proxy. Le client de proxy appelle un service Web reposant sur une interface de noeud final de service qui est générée ou fournie.

Support MTOM
JAX-WS permet d'envoyer des pièces jointes binaires, telles que des images ou fichiers conjointement avec des demandes de services Web. JAX-WS ajoute un support pour la transmission optimisée de données binaires, comme défini par le mécanisme MTOM (Message Transmission Optimization Mechanism).
Structures de charge multiples
JAX-WS présente les technologies de liaison suivantes à l'utilisateur : XML Source, SOAP Attachments API for Java (SAAJ) 1.3 et Java Architecture for XML Binding (JAXB) 2.0. XML Source permet aux utilisateurs de transmettre à l'environnement d'exécution un élément javax.xml.transform.Source représentant les données d'un objet Source à transmettre à l'environnement d'exécution. SAAJ 1.3 permet désormais de transmettre un document SOAP entier via l'interface, à la place de la charge proprement dite. Cette opération est effectuée par le client qui transmet l'objet SAAJ SOAPMessage via l'interface. JAX-WS tire parti du support JAXB 2.0 en tant que technologie de liaison de données de choix entre Java et XML.
Prise en charge de SOAP 1.2
La prise en charge de SOAP 1.2 a été ajoutée dans JAX-WS 2.0. JAX-WS prend en charge SOAP 1.1 et SOAP 1.2. SOAP 1.2 fournit une définition plus spécifique du modèle de traitement SOAP, qui élimine plusieurs des ambiguïtés qui menaient parfois à des problèmes d'interopérabilité en l'absence de profils WS-I (Web Services-Interoperability). SOAP 1.2 réduit les risques de problèmes d'interopérabilité avec les implémentations SOAP 1.2 d'un fournisseur à l'autre. Il ne peut pas être utilisé avec des versions antérieures.
Prise en charge des paramètres de méthode et des types de retour
JAX-WS 2.2 prévoit le support des paramètres et des types de retour des méthodes. Dans JAX-WS, vous pouvez définir une opération de service Web avec un paramètre d'opération et un type de retour optionnel. Si le paramètre d'opération et le type de retour définissent une propriété targetNamespace vide en spécifiant la valeur "" pour cette propriété, avec soit l'annotation @WebParam, soit l'annotation @WebResult, l'environnement d'exécution JAX-WS se comporte de la façon suivante :
  • Si l'opération est de style 'document', le style de paramètre est WRAPPED et le paramètre n'est pas mappé à un en-tête. Un espace de nom vide est mappé avec les paramètres d'opération et les types de retour.
  • Si le style de paramètre n'est pas WRAPPED, la valeur de la propriété targetNamespace spécifiée avec l'annotation @WebParam ou @WebResult est utilisée.

JAX-WS 2.1.6

Lorsqu'un service Web JAX-WS est créé à partir d'une classe Java, les méthodes publiques de la classe sont exposées en tant qu'opérations et font partie du contrat WSDL du service Web. Le mappage entre ces méthodes et opérations est régi principalement par JSR-181 et JSR-250. Selon ces règles, une méthode publique dans une classe Java et sa hiérarchie jusqu'à l'objet java.lang.Object exclu sont exposées lorsque les conditions suivantes sont satisfaites :
  • La méthode est annotée avec @WebMethod ou @WebMethod(exclude=false) et la classe conteneur possède une annotation @WebService
  • La méthode ne possède pas d'annotation @WebMethod mais la classe conteneur possède une annotation @WebService et aucune autre méthode n'est annotée avec @WebMethod ou @WebMethod(exclude=false)
JAX-WS 2.1.6 modifie les règles d'exposition des méthodes d'une classe Java dans l'interface de service Web. A présent, une méthode publique dans une classe Java ainsi que sa hiérarchie jusqu'à l'objet java.lang.Object exclu sont exposées lorsque les conditions suivantes sont satisfaites :
  • L'annotation @WebMethod ou @WebMethod(exclude=false) est appliquée à la méthode.
  • La méthode ne possède pas d'annotation @WebMethod mais la classe conteneur possède une annotation @WebService.
Exemple :
public class Base
{
  @WebMethod(exclude=false)
  public void superExposed(String s) {}
  public String supernoanno(String s) {}
}

@WebService
public class BeanImpl extends Base
{
  @WebMethod(exclude=false)
  public void exposed(String s) {}
  public String nonpublic(String s) {}
}
Avant JAX-WS 2.1.6, la seule méthode exposée était public void exposed(String s). Dans JAX-WS 2.1.6 et versions ultérieures, les méthodes suivantes sont exposées :
public void exposed(String s)
public String nonpublic(String s)
public void superExposed(String s)

WebSphere Application Server versions 7.0.0.7 et ultérieures incluent ces modifications par le biais d'IBM® JDK 6 SR6. Pour que le plan de travail vous guide lors de l'utilisation de JAX-WS 2.1.6, accédez à Fenêtre > Préférences > Général > Stratégies de service > Modèles de programmation WebSphere > JAX-WS et associez le paramètre des conseils pour l'exposition des méthodes JAX-WS 2.1.6 à true.

JAX-WS 2.2

Les environnements d'exécution de serveur qui prennent en charge JAX-WS version 2.2 et les spécifications Web services for Java EE (JSR 109) version 1.3 sont les suivants :
  • WebSphere Application Server Liberty Profile version 8.5.5
  • WebSphere Application Server version 8.5
  • WebSphere Application Server version 8.0

La spécification JAX-WS 2.2 remplace la spécification JAX-WS 2.1 et inclut certaines de ses fonctions. JAX-WS 2.2 ajoute le support côté client pour l'utilisation des annotations en rapport avec WebServiceFeature, telles que @MTOM et @Addressing, et des annotations @RespectBinding. Le support de ces annotations était déjà disponible côté serveur à compter de la version 2.1 de JAX-WS. La spécification Web Services for Java EE 1.3 introduit également le support de ces annotations WebServiceFeature, ainsi que le support permettant d'utiliser des éléments du descripteur de déploiement pour configurer ces fonctions à la fois sur le client et sur le serveur. JAX-WS 2.2 nécessite JAXB (Java Architecture for XML Binding) version 2.2 pour la liaison de données.

Pour plus d'informations sur JAX-WS, voir la spécification JSR-224 officielle : JSR 224: Java API for XML-Based web services (JAX-WS) 2.0

Icône indiquant le type de rubrique Rubrique
Dispositions pour les centres de documentation | Commentaires en retour

Icône d'horodatage Dernière mise à jour: May 29, 2014 10:11

Nom de fichier : cjaxws.html