WSIF permet l'utilisation de types complexes définis par l'utilisateur
via le mappage de types complexes vers les classes Java™.
Vous pouvez définir ce mappage
manuellement ou automatiquement.
Pourquoi et quand exécuter cette tâche
Tout appel des méthodes WSIFService mapType et mapPackage utilisé pour le mappage
manuel remplace toute information de mappage équivalente générée automatiquement. Cela permet
de conserver la compatibilité amont et d'effectuer des mappages moins standard.
Pour mapper les types complexes
définis par l'utilisateur avec les classes Java, effectuez l'une des procédures suivantes :
Procédure
- Mappage manuel des types complexes.
La méthode à suivre pour créer ces mappages manuellement dépend du fournisseur. Dans le cas des fournisseurs Java et EJB, les mappages sont indiqués dans le fichier WSDL de l'élément binding. L'exemple
suivant fournit la syntaxe permettant de définir le mappage :
<binding .... >
<ejb:binding|java:binding/>
<format:typeMapping style="Java" encoding="Java"/>?
<format:typeMap typeName="qname" formatType="nmtoken"/>*
</format:typeMapping>
...
</binding>
Dans cet exemple :
- Un point d'interrogation ("?") signifie "facultatif" et un astérisque
("*") signifie "0 ou plus".
- L'attribut typeName de format:typeMap est le nom qualifié d'un type complexe
ou d'un type simple utilisé par l'une des opérations.
- L'attribut formatType de format:typeMap est le nom complet
de la classe Java vers laquelle l'élément spécifié par
typeName est mappé.
Si vous utilisez le fournisseur Apache SOAP, vous spécifiez le mappage d'un type
complexe vers une classe Java dans le code client via deux méthodes de
l'interface org.apache.wsif.WSIFService :
public void mapType(QName elementType, Class javaType)
et
public void mapPackage(String namespaceURI, String packageName)
Utilisez
la méthode mapType pour spécifier un mappage entre un élément schéma XML
et une classe Java. La méthode utilise un élément QName représentant le type complexe ou le type simple et la
classe Java correspondante vers laquelle ce type est mappé.
La méthode mapPackage
permet de spécifier un mappage plus général entre un espace de nom et un package Java. Tout type simple, complexe ou personnalisé dont l'espace de nom correspond à celui
du mappage est mappé vers une classe Java dans le package correspondant. Le nom de la classe est dérivé du nom du type complexe standard à l'aide de conventions de dénomination XML vers Java standard.
- Mappage automatique des types complexes.
Pour les types
complexes définis dans le fichier WSDL, où un bean généré permet de représenter
ce type dans Java, le modèle de programmation WSIF (Web Services Invocation Framework)
requiert qu'un appel soit effectué à la méthode WSIFService.mapType(). Cet appel indique à WSIF le nom de classe et de package du bean qui représente le type de schéma XML qui est identifié à l'aide d'un QName. Pour faciliter les choses, la méthode WSIFService.mapPackage()
fournit un mécanisme permettant d'en spécifier une version générique dans lequel
toute classe d'un package spécifié est mappé vers l'espace de nom d'un élément QName. Il s'agit
d'un mécanisme permettant de mapper manuellement un type de schéma XML vers une classe Java et le processus inverse (une entrée de mappage fournit un mappage bidirectionnel).
Il existe de nombreuses façons de convertir un
élément QName représentant un nom de type de schéma XML en un nom et une classe de package Java. Pour activer le mappage de type automatique,
définissez la fonction WSIF_FEATURE_AUTO_MAP_TYPES sur l'instance WSIFServiceFactory :
WSIFServiceFactory factory = WSIFServiceFactory.newInstance();
factory.setFeature(WSIFConstants.WSIF_FEATURE_AUTO_MAP_TYPES, new Boolean(true));
WSIF mappe les types en convertissant la partie URI du type de schéma XML QName en nom
de package et en convertissant la partie locale en nom de classe.
WSIF effectue ce
mappage à l'aide des méthodes WSIFUtils getPackageNameFromNamespaceURI et
getJavaClassNameFromXMLName.