Esercizi di messa in opera di servizi Web con Tomcat e Axis

Dovreste avere Tomcat installato altrimenti guardate qui.
Scaricate l'ultima versione di Axis in /usr/local/axis
Definite le variabili ambiente:
```
setenv AXIS_HOME /usr/local/axis
```
Date il seguent comando:
```
 cp -pr $AXIS_HOME/webapps/axis $CATALINA_HOME/webapps
```
Copiate file log4j.properties(serve per il trattamento dei messaggi di errore) con:
```
cp log4j.properties $CATALINA_HOME/webapps/axis/WEB-INF/
```
Su $AXIS_HOME/axis.log verranno registrati i vari messaggi di errore.
Ora Axis dovrebbe essere accessibile come applicazione Tomcat su http://localhost:8080/axis .
Controllate l'installazione caricando ognuno dei "Needed Components" che dovesse mancare. La stessa pagina da' istruzioni su dove reperire i jar .
Axis lavora con SOAP1.1 nel quale la richiesta dei servizi e' fatta via http POST, ma per fare dei test, risponde anche a dei Get http col seguente formato http://localhost:8080/axis/services/Version?method=getVersion. Abbiamo cosi' fatto un test dell'endpoint version cioe' del server di uno dei sevizi installati.
Possiamo allo stesso modo vedere se i files .jws funzionano richiamando la loro url: http://localhost:8080/axis/EchoHeaders.jws?method=list. Un servizio realizzato con un file .jws richiede per la sua messa in opera solo il file suddetto e viene trasformato automaticamente in servizio Web quando e' copiato in una qualsiasi delle cartelle di axis (escluso il sottoalbero WEB-INF).
Per tutti i servizi e' possibile vedere il WDSL usando lo stesso url prima visto con WDSL dopo il "?": ad esempio ecco il WSDL del servizio EchoHeaders:http://localhost:8080/axis/EchoHeaders.jws?wsdl
Assieme ad Axis e alla documentazione vengono scaricati molti esempi di servizi con istruzioni per la loro messa in opera nella cartella samples.
Ora implementiamo il nostro primo servizio Web : il mitico CiaoATutti Scriviamo in un file "CiaoATutti.java" la seguente classe Java:
```
public class CiaoATutti {

    public String ciao() {
         String results = "Ciao a tutti";
      return results;
    }
```
Ora copiamo il file su axis cambiando il nome in CiaoATutti.jws con:
```
cp CiaoATutti.java $CATALINA_HOME/webapps/axis/CiaoATutti.jws
```
Il servizio e' immediatamente accessibile a: http://localhost:8080/axis/CiaoATutti.jws?method=ciao con relativo wdsl. Notate come axis implementi tutti i metodi pubblici definiti nella classe Java.

Per creare un client, disponetevi in $AXIS_HOME e create la seguente classe in un file CiaoClient.java:

import org.apache.axis.client.Service;
   import org.apache.axis.encoding.XMLType;

   import javax.xml.rpc.ParameterMode;

   public class CiaoClient
   {
     public static void main(String [] args) throws Exception {
     String host = "http://localhost:8080";
     String servicepath = "/axis/CiaoATutti.jws";
     String endpoint = host   + servicepath;
     String method = "ciao" ;

     String ret = null;
     Service service = new Service();
     Call call = (Call) service.createCall();

     call.setTargetEndpointAddress(new java.net.URL (endpoint));
     call.setOperationName(method);

     ret = (String) call.invoke(( Object [] )null);
     System.out.println("Got result : " + ret);
      }
   }

Per poter compilare questa classe dovete un po' giostrare col CLASSPATH per avere tutte le librerie a disposizione:

 setenv CLASSPATH $JAVA_HOME/lib:.:$AXIS_HOME/lib/axis.jar:$AXIS_HOME/lib/commons-logging.jar:$AXIS_HOME/lib/jaxrpc.jar:$AXIS_HOME/lib/log4j-1.2.8.jar:$AXIS_HOME/lib/jaxrpc.jar:$AXIS_HOME/lib/commons-discovery.jar:$AXIS_HOME/lib/saaj.jar:$CATALINA_HOME/common/endorsed/xercesImpl.jar:$CATALINA_HOME/common/endorsed/xmlParserAPIs.jar:$AXIS_HOME/lib/wsdl4j.jar:$AXIS_HOME/lib/castor-0.9.5.3.jar

A questo punto javac CiaoClient.java dovrebbe compilare la classe e java CiaoClient mandarla in esecuzione ottenendo

Got result : Ciao a tutti

Ecco un esempio di servizio che fa la somma di 2 interi creato a partire da questa classe e consultabile con questo client scrivendo :
```
java SommaClient 3 8
```
Nelle cartelle copiate ci sono molti servizi pronti per essere messi in azione. Una lista dei servizi attivati la si ottiene col comando:
```
java org.apache.axis.client.AdminClient list
```
Lo stesso comando permette di attivare nuovi servizi. Per fare questo copiate il file di deployment del servizio in $AXIS_HOME e poi fate andare AdminClient : ad esempio per il servizio Math:
```
cd $AXIS_HOME
cp samples/Math/deploy.wsdd .
java org.apache.axis.client.AdminClient deploy.wsdd
```
Ora il servizio Math e' attivato a questo indirizzo. Analogamente e' disponibile un undeploy.wsdd per disattivare il servizio. In pratica AdminClient esegue operazioni di amministrazione indicate da un file di comandi .wsdd

Ora proviamo a mettere in opera il nostro primo servizio. Lavorando sempre nella cartella $AXIS_HOME partiamo dal solito Somma.java

package esempi.sommaservice;
public class Somma {
    public int somma(int a, int b) {
        return a+b;
    }
}

Notate l'aggiunta dell'istruzione package
Prepariamo un file di deployment deploy.wsdd

<deployment
     xmlns="http://xml.apache.org/axis/wsdd/"
     xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">

       <service name="Somma" provider="java:RPC">
         <parameter name="className" value="esempi.sommaservice.Somma"/>
         <parameter name="allowedMethods" value="*"/>
       </service>
   </deployment>

Ora diamo i seguenti comandi:

javac Somma.java
mkdir $CATALINA_HOME/webapps/axis/WEB-INF/classes/esempi/
mkdir $CATALINA_HOME/webapps/axis/WEB-INF/classes/esempi/sommaservice/
cp Somma.class $CATALINA_HOME/webapps/axis/WEB-INF/classes/esempi/sommaservice/
java org.apache.axis.client.AdminClient deploy.wsdd

Un nuovo servizio Somma e' stato attivato e puo' essere provato con un url come questo.Possiamo usare anche lo stesso Client visto prima solo che ora il servicepath va cambiato in /axis/services/Somma.

Il documento WSDL che descrive il servizio viene generato a volo da Axis se si aggiunge ?wsdl all'indirizzo del servizio. Ma possiamo salvare lo stesso in un file somma.wsdl richiamando il programma di utilita' Java2WSDL :

cd $CATALINA_HOME/webapps/axis/WEB-INF/classes
java org.apache.axis.wsdl.Java2WSDL -o somma.wsdl -l"http://localhost:8080/axis/services/Somma" -n "urn:Somma" -p"esempi.sommaservice" "urn:Somma" esempi.sommaservice.Somma

Ora proviamo a creare un servizio Web a partire dalla descrizione in formato wsdl. Il servizio e' di tipo document. Il comando dato in AXIS_HOME:
```
java org.apache.axis.wsdl.WSDL2Java -o persone -s "persone.wsdl"
```
crea una serie di files nelle sottocartelle persone_wsdl e persone_xsd di persone/com/example . Dobbiamo modificare il file PersoneSoapBindingImpl.java in modo da ritornare invece di null l'oggetto ListaResponse. Compiliamo il tutto con:
```
javac persone/com/example/*/*.java
```
Copiamo il file di deploy con:
```
cp persone/com/example/persone_wsdl/deploy.wsdd .
```
Copiamo tutti i files generati in webapps con:
```
 mv persone/com $CATALINA_HOME/webapps/axis/WEB-INF/classes/com
```
Procediamo ora al deployment con:
```
java org.apache.axis.client.AdminClient deploy.wsdd
```
Un nuovo servizioPersonePort e' ora disponibile col metodo getLista che ritorna una lista di persone.
Per fare delle modifiche al codice di un servizio gia' implementato per esempio in $CATALINA_HOME/webapps/axis/WEB-INF/classes/ba/persone/ procedere nella maniera seguente:
posizionatevi nella cartella classes concd $CATALINA_HOME/webapps/axis/WEB-INF/classes/. Ora modificate il codice Java e ricompilate con javac ba/persone/*/*.java. Quando la compilazione e' Ok procedete con
```
$CATALINA_HOME/bin/shutdown.sh
$CATALINA_HOME/bin/startup.sh
```
Ora per controllare eventuali errori conviene far andare:
```
 tail -f $CATALINA_HOME/logs/catalina.out
```
mentre provate il servizio modificato.
Per ricompilare axis dovete scaricarvi la versione source e unzipparla. Quindi andate nella cartella principale e date il comando ant. Axis viene ricompilato nella sottocartella build. Se ottenete messaggi di errore riguardanti pacchetti mancanti , dovete cercarli con locate e quindi procedere ad attaccarli al CLASSPATH.
Ora copiate le nuove jar generate in $AXIS_HOME/lib/ , $CATALINA_HOME/common/lib/ e $CATALINA_HOME/webapps/axis/WEB-INF/lib/. Fate shutdown e startup di Tomcat e poi rifate la validazione di axis .

Indietro a Xml ovvero trasformando tutta l'informazione online in un'unico database

Giuseppe Zito