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.
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.
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>
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().
@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.
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.
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.
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 à true.
et associez le paramètre des conseils pour l'exposition des méthodes JAX-WS 2.1.6 à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