Ora che abbiamo capito a cosa serve <types> e siamo in grado di definire i nostri tipi possiamo dedicarci ai messaggi. Inviare l'id di un utente e ricevere le caratteristiche di quest'ultimo implica chiaramente due messaggi. Attraverso il primo (la richiesta dell'applicazione) sarà inviato l'id utente al Web service mentre con il secondo il Web service invierà di ritorno un tipo utente.
Vediamo allora con un esempio questi due messaggi implementati:
<message name="get_userRequest">
<part name="id" type="xs:integer" />
</message>
<message name="get_userResponse">
<part name="utente" type="tns:utente" />
</message>
Come avrete sicuramente notato ora che abbiamo definito i nostri tipi personalizzati tutto risulta molto semplice. Abbiamo definito due messaggi e ad ogni messaggio abbiamo dato un nome che utilizzeremo più avanti. Invece ogni parte (<part>) all'interno di un messaggio descrive da che cosa è composto ed ha a sua volta un nome che l'applicazione client userà per indicare i parametri che passa o riceve.
Ti faccio notare che non abbiamo seguito la strada più corta definendo i nostri tipi personali per questo esempio, ma del resto vogliamo capire bene e non fare le cose in fretta. Per completezza comunque, ed anche per farvi vedere che le parti possono essere più d'una creiamo una versione compatta della prima parte del nostro esempio WDSL.
<definitions ... >
<types></types>
<message name="get_userRequest">
<part name="id" type="xs:integer" />
</message>
<message name="get_userResponse">
<part name="nome" type="xs:string" />
<part name="cognome" type="xs:string" />
<!-- ....nick.... ...email... -->
</message>
.....
In questa versione ristretta potete vedere come abbiamo rinunciato a definire tipi personali per dichiarare tutto direttamente nel messaggio. Questo metodo è sicuramente più rapido quando avrete preso una certa confidenza con i servizi Web ma fino ad allora, e soprattutto per progetti di medio/alta complessità, vi sconsiglio di utilizzarlo. Definire dei tipi propri permette di riutilizzarli successivamente richiamandoli per nome.
Ora, per chiarire questo concetto, vediamo di aggiungere i messaggi indispensabili per un altra operazione che chiameremo salvaUtente e decidiamo di farlo con i nostri tipi personalizzati, visto che noi siamo li abbiamo in precedenza creati.
<message name="get_userRequest">
<part name="id" type="xs:integer" />
</message>
<message name="get_userResponse">
<part name="utente" type="tns:utente" />
</message>
<!-- nuovo messaggio -->
<message name="save_userRequest">
<part name="sendUser" type="tns:utente" />
</message>
Visto? È molto semplice. Abbiamo creato un nuovo messaggio che servirà all'applicazione per inviare al Web service l'utente da salvare ed è stato sufficiente specificare il tipo che avevamo creato in precedenza. Che cosa sarebbe successo se non avessimo usato i nostri tipi personalizzati? Sono sicuro che ti sei già dato una risposta; una volta definito il nostro tipo utente (o qualsiasi altro tipo) possiamo riutilizzarlo in più messaggi e l'utilità è indubbia se questo tipo ci serve in più occasioni. Usando il metodo "veloce" sarebbe stato necessario riscrivere una seconda volta il contenuto del messaggio visto che rimaneva uguale a quello di get_userResponse.