WSDL
La classe Zend_Soap_Wsdl est utilisée par le composant
Zend_Soap_Server pour manipuler des documents WSDL. Néanmoins, vous pouvez vous-même
utiliser les services fournis par cette classe pour vos propres besoins. La classe
Zend_Soap_Wsdl contient à la fois un analyseur et un constructeur de documents
WSDL.
Si vous ne voulez pas l'utiliser pour vos propres besoins, vous pouvez alors
passer cette section de la documentation.
Constructeur Zend_Soap_Wsdl
Le constructeur de Zend_Soap_Wsdl prend 3 paramètres :
$name - nom du service Web décrit.$uri - URI d'accès au fichier WSDL. (Une référence
dans le système de fichier local est possible.)$strategy - identifiant optionnel pour identifier la
détection de stratégie des types complexes. Ceci est un booléen
$extractComplexTypes avant la version 1.7 et peut toujours être
paramétrer via un booléen pour la compatibilité ascendante. Par défaut le
comportement de détection de la 1.6 est activé. Pour avoir de plus amples
informations concernant les stratégies de détection des types complexes,
lisez : ajoutez des types
complexes.addMessage()addMessage($name, $parts) ajoute un message de description au
document WSDL (/definitions/message de l'élément).
Chaque message correspond à une méthode en terme de fonctionnalité de
Zend_Soap_Server et
Zend_Soap_Client.
Le paramètre $name représente le nom du message.
Le paramètre $parts est un tableau de paramètre des messages
décrivant les paramètres d'appel SOAP. Le tableau est associatif: 'nom du paramètre'
(nom du paramètre d'appel SOAP) => 'type du paramètre'.
La correspondance de types est effectuée grâce à addTypes() et
addComplexType()(voyez après).
Les paramètres de messages peuvent être soit "element", soit "type" (voyez
).
"element" doit correspondre à un élément de définition de type. "type"
correspond à une entrée complexType.
Tous les types standards XSD possèdent une définition "element" et
"complexType" (Voyez ).
Tous les éléments non standards, qui doivent être ajoutés avec la méthode
Zend_Soap_Wsdl::addComplexType(), sont décrits en utilisant
un noeud "complexType" décrits dans la section "/definitions/types/schema/" du
document WSDL.
Ainsi, la méthode addMessage() utilise toujours un attribut
"type" pour décrire des types.
addPortType()addPortType($name) ajoute un nouveau type de portage au document WSDL
(/definitions/portType).
Ceci fait la jointure entre des méthodes du service décrites en tant
qu'implémentations de Zend_Soap_Server.
Voyez pour plus de
détails.
addPortOperation()addPortOperation($portType, $name, $input = false, $output = false, $fault =
false) ajoute des définitions de portage au portage défini dans le document WSDL
(/definitions/portType/operation).
Chaque opération de portage correspond à une méthode de classe (si le Web Service
est basé sur une classe) ou à une fonction (si le Web Service est basé sur des
fonctions), ceci en terme d'implémentation de Zend_Soap_Server.
Cette méthode ajoute aussi les messages d'opération correspondants aux portages,
ceci dépend des paramètres $input, $output and
$fault.
Zend_Soap_Server génère 2 messages pour chaque opération de portage
lorsque le service est décrit au travers de la classe
Zend_Soap_Server:
Le message d'entrée nommé $methodName .
'Request'.
Les message de sortie nommé $methodName .
'Response'.
Voyez pour les
détails.
addBinding()addBinding($name, $portType) ajoute de nouvelles correspondances
(bindings) au document WSDL (/definitions/binding).
Le noeud du document WSDL "binding" définit le format du message et les détails du
protocole pour les opérations et messages définis par un portage "portType" particulier
(voyez ).
La méthode crée le noeud de correspondance et le retourne. Il peut alors être
utilisé.
L'implémentation de Zend_Soap_Server utilise le nom $serviceName .
"Binding" pour la correspondance ("binding") de l'élément du document
WSDL.
addBindingOperation()addBindingOperation($binding, $name, $input = false, $output = false, $fault
= false) ajoute une opération à l'élément de correspondance avec le nom spécifié
(/definitions/binding/operation).
Cette méthode prend un objet XML_Tree_Node tel que retourné par
addBinding(), en paramètre ($binding) pour ajouter un élément
"operation" avec des entrées input/output/false dépendantes des paramètres
spécifiés.
Zend_Soap_Server ajoute les correspondances pour chaque
méthode du Web Service avec des entrées et sorties, définissant l'élément "soap:body"
comme <soap:body use="encoded"
encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
Voyez les détails à .
addSoapBinding()addSoapBinding($binding, $style = 'document', $transport =
'http://schemas.xmlsoap.org/soap/http') ajoute des correspondances (bindings)
SOAP ("soap:binding") à l'élément (déjà lié à un portage de type) avec le style et le
transport spécifié (Zend_Soap_Server utilise le style RPC sur
HTTP).
L'élément "/definitions/binding/soap:binding" est alors utilisé pour spécifier que
la correspondance est relative au format du protocole SOAP.
Voyez pour les
détails.
addSoapOperation()addSoapOperation($binding, $soap_action) ajoute une opération SOAP
("soap:operation") à l'élément de correspondance avec l'action spécifiée. L'attribut
"style" de l'élément "soap:operation" n'est pas utilisé alors que le modèle de
programmation (RPC-oriented ou document-oriented) devrait utiliser la méthode
addSoapBinding()
L'attribut "soapAction" de l'élément "/definitions/binding/soap:operation"
spécifie la valeur de l'en-tête SOAPAction pour l'opération. Cet attribut est requis
pour SOAP sur HTTP et ne doit pas être renseigné pour les autres
modes de transports.
Zend_Soap_Server utilise $serviceUri . '#' .
$methodName pour le nom de l'action SOAP.
Voyez pour plus de
détails.
addService()addService($name, $port_name, $binding, $location) ajoute un élément
"/definitions/service" au document WSDL avec le nom du Web Service spécifié, le nom du
portage, la correspondance, et l'adresse.
WSDL 1.1 autorise d'avoir plusieurs types de portage par service. Cette
particularité n'est pas utilisée dans Zend_Soap_Server et est non
supportée par la classe Zend_Soap_Wsdl.
Utilisations de Zend_Soap_Server : $name . 'Service' comme nom du Web Service,$name . 'Port' comme nom de portage des types,'tns:' . $name . 'Binding''tns:' namespace est l'URI du script
('http://' .$_SERVER['HTTP_HOST'] .
$_SERVER['SCRIPT_NAME']).
comme nom de la correspondance,
l'URI du script'http://' .$_SERVER['HTTP_HOST'] .
$_SERVER['SCRIPT_NAME'] en tant qu'URI du service pour les Web Service utilisant des
classes.
où $name est un nom de classe pour le Web Service
utilisant des classes, ou un nom de script pour le Web Service qui utilise des
fonctions.
Voyez pour les
détails.
Correspondance de type
Le WSDL de Zend_Soap utilise les correspondances suivantes pour faire correspondre
les type SOAP à des types PHP : chaînes PHP <-> xsd:string.entiers PHP <-> xsd:int.flottants PHP <-> xsd:float.booléens PHP <-> xsd:boolean.tableaux PHP <-> soap-enc:Array.objets PHP <-> xsd:struct.
Classe PHP <-> basé sur la stratégie des types complexes (Voir :
cette section)Zend_Soap_AutoDiscover sera créé avec
la classe
Zend_Soap_Wsdl_Strategy_DefaultComplexType en
tant qu'algorithme de détection pour les types complexes. Le premier
paramètre du constructeur AutoDiscover accepte toute stratégie de
types complexes implémentant
Zend_Soap_Wsdl_Strategy_Interface ou une
chaîne correspondant au nom de la classe. Pour une compatibilité
ascendante, avec $extractComplexType les variables
booléennes sont analysées comme avec Zend_Soap_Wsdl. Regardez le
manuel Zend_Soap_Wsdl sur
l'ajout des types complexes pour plus d'informations.
.
Type PHP vide <-> void.
Si le type na aucune correspondance avec les valeurs ci-dessus, alors
xsd:anyType est utilisé.
Où xsd: est l'espace de noms
"http://www.w3.org/2001/XMLSchema", soap-enc: est l'espace de noms
"http://schemas.xmlsoap.org/soap/encoding/", tns: est un "espace de noms
cible" pour le service.
Récupérer des infos sur les typesgetType($type) peut être utilisée pour récupérer la
correspondance d'un type PHP spécifié : getType('int');
...
class MyClass {
...
}
...
$soapMyClassType = $wsdl->getType('MyClass');
]]>Ajouter des infos sur les types complexesaddComplexType($type) est utilisée pour ajouter des types
complexes (classes PHP) à un document WSDL.
C'est automatiquement utilisé par la méthode getType() pour
ajouter les types complexes des paramètres de méthodes ou des types
retournés.
Sa détection et son algorithme de construction est basé sur la détection de
stratégie des types complexes couramment active. Vous pouvez paramétrer la stratégie
de détection soit en spécifiant le nom de classe sous la forme d'une chaîne de
caractères ou une instance implémentant
Zend_Soap_Wsdl_Strategy_Interface en tant que troisième
paramètre du constructeur ou en utilisant la fonction
setComplexTypeStrategy($strategy) de
Zend_Soap_Wsdl. Les stratégies de détection suivantes
existent couramment :
la classe
Zend_Soap_Wsdl_Strategy_DefaultComplexType : activé
par défaut (quand aucun troisième paramètre n'est fourni). Itère parmi les
attributs publics d'un type de classe et les enregistre en tant que
sous-types d'un type d'objet complexe.
la classe Zend_Soap_Wsdl_Strategy_AnyType :
caste tous les types complexes en un type XSD simple xsd:anyType. Attention
ce raccourci pour la détection des types complexes peut probablement
seulement être géré avec des langages faiblement typés comme le PHP.
la classe
Zend_Soap_Wsdl_Strategy_ArrayOfTypeSequence : cette
stratégie permet de spécifier les paramètres de retour de type :
int[] ou string[]. A partir de Zend Framework 1.9,
il peut gérer des types PHP simples comme int, string, boolean, float ainsi
que des objets ou des tableaux d'objets.
la classe
Zend_Soap_Wsdl_Strategy_ArrayOfTypeComplex : cette
stratégie permet de détecter des tableaux complexes d'objets. Les types
d'objets sont détectés sur la base de
Zend_Soap_Wsdl_Strategy_DefaultComplexType et un
tableau enveloppe cette définition.
la classe Zend_Soap_Wsdl_Strategy_Composite :
cette stratégie peut combiner toutes les stratégies en connectant les types
complexes PHP (nom de classe) à la stratégie désirée grâce à la méthode
connectTypeToStrategy($type, $strategy). Une carte de
correspondance complète de types peut être fourni au constructeur sous la
forme d'un tableau de paires $type ->
$strategy. Le second paramètre spécifie la stratégie par défaut
si un type inconnu est ajouté. La valeur par défaut de ce paramètre est la
stratégie
Zend_Soap_Wsdl_Strategy_DefaultComplexType.
la méthode addComplexType() crée un élément
"/definitions/types/xsd:schema/xsd:complexType" pour chaque type
complexe décrit avec le nom d'une classe PHP spécifiée.
Les propriétés des classes doivent posséder un bloc de
documentation avec le type PHP en question, afin que la propriété soit incluse dans
la description WSDL.
addComplexType() vérifie sur le type est déjà décrit dans la
section des types du document WSDL.
Ceci évite les duplications et récursions si cette méthode est appelée plus
d'une fois.
Voyez pour plus de
détails.
addDocumentation()addDocumentation($input_node, $documentation) ajoute de la
documentation lisible ("human readable") grâce à l'élément optionnel
"wsdl:document".
L'élément "/definitions/binding/soap:binding" est utilisé pour dire que la
correspondance est liée au format du protocole SOAP.
Voyez pour les
détails.
Récupérer un document WSDL finalisétoXML(), toDomDocument() et dump($filename =
false) peuvent être utilisées pour récupérer un document WSDL sous forme de XML,
de structure DOM, ou de fichier.