Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Membre régulier
    Détermination des eléments de Contenu CHOICE des paramètres d'opération d'un service SOAP
    Bonjour,

    Je voudrais savoir les éléments que je doit choisir entre eux lors de l'invocation d'une opération d'un service web SOAP.

    Ci-joint l'élément input d'une opération. qui contient les paramètres d'invocation du l'opération "operationName".

    Code XML :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    <xs:complexType name="operationNameRequest">
                    <xs:sequence>
                         <xs:element name="aaaa" type="xs:string"/>
                        <xs:choice>
                            <xs:element name="id" type="xs:long"/>
                            <xs:element name="CityName" type="xs:string"/>
                            <xs:element name="contryName" type="xs:string"/>
                        </xs:choice>              
                        <xs:element name="validFromDate" type="xs:string"/>
                        <xs:element name="nbOccurences" type="xs:int" minOccurs="0"/>
                    </xs:sequence>
    </xs:complexType>

    Ainsi lors de l'invoquation du l'opération "operationName" je dois choisir un seul élement entre les trois elements "id", "CityName" et "ContryName".
    supposons que nous avons récuperé la définition globale de l'élement input de cette opération.
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    SchemaGlobalElement elm = operation.getOperation().getInterface()
    					.getWsdlContext().getSchemaTypeLoader()
    					.findElement(elementName);

    avec elementName c'est un Qname qui represente le nom qualifié de l'input du l'opération.

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    SchemaProperty[] sp = elm.getType().getProperties();
            for (int i = 0; i < sp.length; i++) {
                if (!sp[i].getType().isSimpleType()) {
                    if (sp[i].getType().getContentModel().getParticleType() == SchemaParticle.CHOICE) {
                        System.out.println(sp[i].getName().getLocalPart()
                                + " complex type,particle tree: CHOICE");
                    }
                } else {
                    System.out.println(sp[i].getName().getLocalPart()
                            + ": is simple ");
                }
            }

    Ainsi nous avons récuperé tous les élements qui répresentent les paramêtres du l'opération qu'on veut l'invoquer qui sont stockés dans un tableau de SchemaProperty. On parcourt cet tableau et on affiche le nom de chaque élement et s'il est de type complex, on détermine si son contenu est CHOICE.
    En fait le modèle du contenu d'un élément complexe est une arbre des particules. Chaque particule est soit CHOICE, soit ALL ou soit SEQUENCE.

    cette méthode de SchemaType
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    sp[i].getType().getContentModel()
    retourne un tableau de SchemaParticle qui représente l'arbre des particules.

    Le problème ici que le tableau schemaProperty contient six éléments qui sont tous de type simple.
    et on peut savoir que le contenu est CHOICE si l'élement est complexe. Donc comment je pourrais savoir s'il vous plaît qu'il ya un choix entre ces troies élements
    "id", "CityName" et "contryName".
    si l'exemple était comme ceci
    Code XML :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
     <xs:complexType name="operationNameRequest">
                    <xs:sequence>
                         <xs:element name="aaaa" type="xs:string"/>
                          <xs:element name="id" type="xs:long"/>
    					  <xs:element name="ContryService">
                            <xs:complexType>
    							<xs:choice>
    								<xs:element name="id" type="xs:long"/>
    								<xs:element name="CityName" type="xs:string"/>
    								<xs:element name="contryName" type="xs:string"/>
    							</xs:choice>   
    						</xs:complexType>							
                        <xs:element name="validFromDate" type="xs:string"/>
                        <xs:element name="nbOccurences" type="xs:int" minOccurs="0"/>
                    </xs:sequence>
    </xs:complexType>


    Je peux savoir facilement que je dois choisir un élément parmi les trois éléments "id", "cityName" et "contryName" car le contenu de "ContryService" est CHOICE donc je stocke ses enfants et après je dois choisir un de ses enfants. Mais l'exemple précédent n'est pas le cas.

    Merciii.

  2. #2
    Membre émérite
    Pour traverser ce xs:complexType ou xs:simpleType pareillement, on peut faire partir avec ce SchemaType de ce elm et saisir son Content Model (elm.getType().getContentModel(), au lieu de ...getProperties() qui a une vue plus spéciale et restrictive que Content Model).

    Or, le Content Model qui est une sous classe de SchemaParticle. A partir de cette instance de SchemaParticle, on obtiendrait ses enfants SchemaParticle[] via .getSchemaParticleChildren() de type SchemaParticule encore de divers ParticleType via getParticleType() qui peut être xs:all, xs:choice, xs:sequence, xs:element principalement...

    Pour chacun d'eux, on refait la même... A chaque niveau on découvre ce qu'il y a dedans.

    Par exemple, au niveau 1, on voit {xs:element, xs:choice, xs:element, xs:element}. Et puis, on arrive à travailler sur le deuxième élément dans ce tableau qui est xs:choice.

    Un niveau plus bas, et voilà on découvre les trois éléments embarqués...

    On travers ce arbre par une fonction récursive appelée à chaque niveau de SchemaParticle[] sortant de .getSchemaParticleChildren() ainsi de suite.

    Voilà ce quoi on peut arriver à saisir cette structure étalée. D'ailleurs, ce n'est pas la façon unique de faire ça, bien entendu.