Serveis web SOAP amb Java EE 7

Veurem els conceptes referents a la definició de serveis web SOAP amb Java EE 7 desenvolupant un servei web SOAP que permeti les següents operacions:

• Proporcionar una llistat de concerts i el nombre de places lliures a cada un d’ells.
• Fer la reserva d’una entrada per a un d’aquests concerts.
• Cancel·lar una reserva d’una entrada.

Farem servir una aplicació web ja desenvolupada que segueixi una arquitectura per capes i hi afegireu una capa de serveis on creareu i publicareu el servei web de gestió de reserves com a servei web SOAP.

Per a aquest exemple farem servir una aproximació bottom-up; crearem primer el codi Java que implementarà el servei web i, a partir d’aquest, es generarà automàticament el document WSDL que el descriurà.

L’aplicació de la qual partirem s’anomena “Resentioc” i ens servirà per veure com podem exposar algunes funcionalitats de la capa de serveis d’una aplicació mitjançant serveis web SOAP. Es tracta d’un projecte Spring MVC senzill que segueix una arquitectura típica per capes per tal d’aconseguir una alta reusabilitat, un baix acoblament i una alta cohesió a l’aplicació.

El projecte constarà de quatre capes:

• Capa de presentació
• Capa de domini
• Capa de serveis
• Capa de persistència

A l’exemple no farem servir la capa de presentació, ja que l’objectiu no és proporcionar una interfície d’usuari a l’aplicació, sinó publicar els mètodes de negoci com a serveis web.

El model de domini ja el teniu implementat i és molt senzill, només hi ha una entitat Show que teniu en la figura i que representa els concerts que s’estan oferint amb el nombre d’entrades disponibles.

La capa de serveis serà la que treballarem i haurà de proporcionar un servei web SOAP que permeti als clients fer les següents operacions:

• Llistat de concerts amb el nombre d’entrades disponibles per a cada un d’ells.
• Reservar una entrada.
• Anul·lar una reserva.

La capa de persistència també la teniu implementada i conté l’objecte repositori que permet mapar les dades de la font de dades amb l’objecte de domini. En el nostre cas, per simplificar, farem servir un repositori in memory que tindrà una llista precarregada de concerts.

L’objectiu d’aquest apartat és crear un servei web SOAP, seguint l’especificació JAX-WS, amb les tres operacions que corresponen a les tres funcionalitats que volem publicar:

• Llistat de concerts amb el nombre d’entrades disponibles per cada un d’ells.
• Reservar una entrada.
• Anul·lar una reserva.

Els serveis web SOAP amb Java EE 7 es poden implementar de dues maneres: amb una classe Java normal que s’executa en un contenidor de servlets o bé com un EJB de sessió sense estat o singleton que s’executa en un contenidor d’EJB. Veurem com s’implementa el servei web amb una classe Java normal.

Creeu una interfície que exposarà les tres operacions que volem; anomenarem la interfície TicketServiceEndpoint i la crearem al paquet cat.xtec.ioc.service.

A la interfície hi creeu els tres mètodes que volem exposar com a endpoints del servei web i els anoteu amb l’anotació javax.jws.WebMethod:

package cat.xtec.ioc.service;
 
import cat.xtec.ioc.domain.Show;
import java.util.ArrayList;
import javax.jws.WebMethod;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
 
@WebService
@SOAPBinding(style = SOAPBinding.Style.DOCUMENT)
public interface TicketServiceEndpoint {
     @WebMethod ArrayList<Show> getAllShows();
     @WebMethod Show makeReservation(String showId);
     @WebMethod Show cancelReservation(String showId);
}

Fixeu-vos que:

• Hem anotat la interfície amb l’anotació @WebService per indicar que la interfície correspondrà a un servei web.
• Hem anotat la interfície amb l’anotació @SOAPBindig per tal d’especificar l’estil de servei que volem crear. Per l’exemple, utilitzarem l’estil Document, que és l’opció per defecte.
• Tots els mètodes que volem exposar cal que els anoteu amb l’anotació @WebMethod.

Un cop fet això cal que creeu la implementació del servei web; per fer-ho, creeu una nova classe anomenada TicketServiceEndpointImpl al paquet cat.xtec.ioc.service.impl. En aquesta classe cal que hi implementeu els tres mètodes que volem exposar com a endpoints del servei web:

package cat.xtec.ioc.service.impl;
 
import cat.xtec.ioc.domain.Show;
import cat.xtec.ioc.domain.repository.ShowRepository;
import cat.xtec.ioc.domain.repository.impl.InMemoryShowRepository;
import javax.jws.WebService;
import cat.xtec.ioc.service.TicketServiceEndpoint;
import java.util.ArrayList;
 
 
@WebService(serviceName = "TicketService",
        endpointInterface = "cat.xtec.ioc.service.TicketServiceEndpoint")
public class TicketServiceEndpointImpl implements TicketServiceEndpoint {
 
    private final ShowRepository showRepository = new InMemoryShowRepository();
 
    @Override
    public ArrayList<Show> getAllShows() {
        return new ArrayList<Show>(this.showRepository.getAllShows());
    }        
 
    @Override
    public Show makeReservation(String showId) {
        return this.showRepository.makeReservation(showId);
    }
 
    @Override
    public Show cancelReservation(String showId) {
        return this.showRepository.cancelReservation(showId);
    }
}

Hem anotat la classe amb l’anotació @WebService i li hem indicat amb l’atribut name que els clients faran referència al servei web amb el nom TicketService. També li hem indicat quina és la interfície que implementa el servei web amb la ruta completa de la interfície TicketServiceEndpoint:

@WebService(serviceName = "TicketService",
        endpointInterface = "cat.xtec.ioc.service.TicketServiceEndpoint")
public class TicketServiceEndpointImpl implements TicketServiceEndpoint {

La classe implementa la interfície que defineix el servei web i proporciona una implementació per a cada un dels tres mètodes que implementaran les operacions que publica el servei web cridant mètodes existents del repositori de concerts. A aquests mètodes no cal afegir-hi cap anotació especial; el fet d’implementar una interfície amb mètodes anotats amb @WebMethod ja indica quins mètodes de la classe corresponen als endpoints del servei web.

I aquesta és tota la feina que ens cal fer per implementar el servei web de reserva d’entrades, ara tan sols ens manca fer-ne el desplegament al servidor d’aplicacions i provar-lo.

Un cop creat el servei web cal que el desplegueu per tal de fer-lo accessible als clients. El procés de desplegament del servei web engega un conjunt de processos definits a JAX-WS per tal de generar el document WSDL de descripció del servei i publicar els endpoints del servei web.

El desplegament del servei web es pot fer de diverses maneres, entre elles:

• Desplegant l’aplicació Java EE que el conté mitjançant els mecanismes normals de desplegament de qualsevol aplicació Java EE.
• Creant una aplicació Java que s’encarregui de publicar el servei web a un URL determinat.

El desplegament del servei web com a part de l’aplicació Java EE que el conté és molt senzill, simplement cal que feu Run a NetBeans (vegeu la figura) i es farà el desplegament al servidor d’aplicacions que tingueu configurat per al projecte:

En fer el desplegament, la implementació de JAX-WS que té el servidor d’aplicacions ja genera automàticament el document WSDL de definició del servei i publica els endpoints que heu definit amb el nom de servei que li heu donat (en el cas que ens ocupa l’hem anomenat TicketService). La figura mostra la sortida de la consola de NetBeans amb el desplegament del servei web:

Podeu provar que el desplegament des de NetBeans ha anat bé consultant el document WSDL generat en el següent enllaç: localhost:8080/resentioc/TicketService?wsdl.

El desplegament mitjançant una aplicació Java que s’encarregui de publicar el servei web és una mica més complexa, i ens caldrà crear una classe Java que tingui un mètode main que cridi el mètode publish de l’objecte javax.xml.ws.Endpoint. Per fer-ho creem una classe TicketServicePublisher al paquet cat.xtec.ioc.publisher amb el següent codi:

package cat.xtec.ioc.publisher;
 
import cat.xtec.ioc.service.impl.TicketServiceEndpointImpl;
import javax.xml.ws.Endpoint;
 
public class TicketServicePublisher {
 
    public static void main(String[] args) {
        Endpoint.publish("http://localhost:9999/publisher/TicketService", new TicketServiceEndpointImpl());
    }
}

Fixeu-vos que al mètode publish de l’objecte javax.xml.Endpoint cal que li passeu l’URL on voleu publicar el servei web i una instància de la classe que implementa el servei web.

Amb això ja podeu publicar el servei web de reserva d’entrades executant aquesta aplicació Java; per fer-ho, poseu-vos damunt de la classe a NetBeans i feu Run File (vegeu la figura).

Si ho feu, veureu el següent error a la consola de NetBeans:

Exception in thread "main" com.sun.xml.ws.model.RuntimeModelerException: 
runtime modeler error: Wrapper class cat.xtec.ioc.service.jaxws.GetAllShows is not found. Have you run APT to generate them?

El problema és que ens cal executar una utilitat del JDK anomenada wsgen que generarà tots els artefactes portables que necessita el servei web per ser publicat i consumit.

Per fer-ho obriu un command-prompt, situeu-vos al directori \target\classes\ on tingueu el projecte “Resentioc” i executeu la següent línia (cal que tingueu el directori <JDK_HOME>/bin al classpath per tal que us trobi l’executable wsgen):

Amb Windows:

wsgen -verbose  -keep -cp . -s ..\..\src\main\java cat.xtec.ioc.service.impl.TicketServiceEndpointImpl

Amb Linux:

wsgen -verbose  -keep -cp . -s ../../src/main/java cat.xtec.ioc.service.impl.TicketServiceEndpointImpl

Aquesta instrucció us generarà un conjunt de fitxers .java amb tots els artefactes portables necessaris per fer la publicació des de l’aplicació Java i els col·locarà al paquet cat.xtec.ioc.service.jaxws del projecte “Resentioc”.

Ara sí que podeu publicar el servei web de reserva d’entrades executant el Publisher; si tot va bé, veureu que a la part inferior esquerra de NetBeans (vegeu la figura) us apareix una finestra indicant que el servei web està corrent a l’URL que heu especificat.

Podeu provar que el desplegament des de l’aplicació Java ha anat bé consultant el document WSDL generat en el següent enllaç: localhost:9999/publisher/TicketService?wsdl.

Si tot ha anat bé ja teniu el servei web desplegat i a punt per provar-lo. Però com ho fem? Com el provem? Fixeu-vos que fins al moment no hem codificat cap client que faci peticions al servei web desenvolupat; com podem, doncs, provar-lo?

Per tal de provar el servei web que heu desenvolupat, desplegueu l’aplicació al servidor d’aplicacions Glassfish i accediu al següent URL: localhost:8080/resentioc/TicketService?Tester, on veureu una pàgina (vegeu la figura) amb un botó per a cada una de les operacions que conté el servei web i un enllaç al fitxer WSDL de definició de servei que s’ha generat:

Quan es desplega un servei web SOAP es genera un fitxer WSDL de definició del servei web. El fitxer WSDL està forma per elements XML que descriuen completament el servei web i com s’ha de consumir. El podeu consultar en el següent URL: localhost:8080/resentioc/TicketService?WSDL.

<definitions targetNamespace="http://impl.service.ioc.xtec.cat/" name="TicketService">
    <import namespace="http://service.ioc.xtec.cat/" location="http://localhost:8080/resentioc/TicketService?wsdl=1"/>
    <binding name="TicketServiceEndpointImplPortBinding" type="ns1:TicketServiceEndpoint"></binding>
    <service name="TicketService">
        <port name="TicketServiceEndpointImplPort" binding="tns:TicketServiceEndpointImplPortBinding">
            <soap:address location="http://localhost:8080/resentioc/TicketService"/>
        </port>
    </service>
</definitions>

El fitxer WSDL és un document XML que té una secció abstracta per definir els ports, els missatges i els tipus de dades de les operacions i una part concreta que defineix la instància concreta on hi ha aquestes operacions (vegeu la figura). Aquesta estructura permet reutilitzar la part abstracta del document.

A la part abstracta hi tenim els següents elements:

• types
• message
• portType

Els tipus de dades, tant d’entrada com de sortida, de les operacions es defineixen amb XSD a l’etiqueta <types>. En el nostre cas veiem que ho tenim definit amb un import de localhost:8080/resentioc/TicketService?wsdl=1; si accediu a aquest fitxer veureu que referencia un document d’esquema definit amb XSD:

<definitions targetNamespace="http://service.ioc.xtec.cat/">
    <types>
        <xsd:schema>
            <xsd:import namespace="http://service.ioc.xtec.cat/" schemaLocation="http://localhost:8080/resentioc/TicketService?xsd=1"/>
        </xsd:schema>
    </types>
    <message name="makeReservation"></message>
    <message name="makeReservationResponse"></message>
    <message name="getAllShows"></message>
    <message name="getAllShowsResponse"></message>
    <message name="cancelReservation"></message>
    <message name="cancelReservationResponse"></message>
    <portType name="TicketServiceEndpoint"></portType>
</definitions>

I en aquest document XSD localhost:8080/resentioc/TicketService?xsd=1 és on trobem la definició de les operacions i els tipus de dades, tant d’entrada com de sortida, que fan servir les operacions:

<xs:schema version="1.0" targetNamespace="http://service.ioc.xtec.cat/">
    <xs:element name="cancelReservation" type="tns:cancelReservation"/>
    <xs:element name="cancelReservationResponse" type="tns:cancelReservationResponse"/>
    <xs:element name="getAllShows" type="tns:getAllShows"/>
    <xs:element name="getAllShowsResponse" type="tns:getAllShowsResponse"/>
    <xs:element name="makeReservation" type="tns:makeReservation"/>
    <xs:element name="makeReservationResponse" type="tns:makeReservationResponse"/>
    <xs:complexType name="cancelReservation">
        <xs:sequence>
            <xs:element name="arg0" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="cancelReservationResponse">
        <xs:sequence>
            <xs:element name="return" type="tns:show" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="show">
        <xs:sequence>
            <xs:element name="availableTickets" type="xs:int" minOccurs="0"/>
            <xs:element name="id" type="xs:string" minOccurs="0"/>
            <xs:element name="location" type="xs:string" minOccurs="0"/>
            <xs:element name="name" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="makeReservation">
        <xs:sequence>
            <xs:element name="arg0" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="makeReservationResponse">
        <xs:sequence>
            <xs:element name="return" type="tns:show" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="getAllShows">
        <xs:sequence/>
    </xs:complexType>
    <xs:complexType name="getAllShowsResponse">
        <xs:sequence>
            <xs:element name="return" type="tns:show" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>
</xs:schema>

Per exemple, si us hi fixeu, defineix que les peticions a l’operació cancelReservation reben un paràmetre de tipus string i a les respostes es torna un tipus de dades complex anomenat show que està format per un int i tres string (availableTickets, id, location i name)

Després de la definició dels tipus de dades trobem els elements <message> amb la definició dels missatges que es poden intercanviar les operacions del servei web, amb una entrada per a la petició i una altra per a la resposta:

<definitions targetNamespace="http://service.ioc.xtec.cat/">
    <types></types>
    <message name="makeReservation"></message>
    <message name="makeReservationResponse"></message>
    <message name="getAllShows"></message>
    <message name="getAllShowsResponse"></message>
    <message name="cancelReservation"></message>
    <message name="cancelReservationResponse"></message>
    <portType name="TicketServiceEndpoint"></portType>
</definitions>

I després, els elements <portType> ens defineixen les operacions que es poden fer al servei web i els seus paràmetres:

<definitions targetNamespace="http://service.ioc.xtec.cat/">
    <types></types>
    <message name="makeReservation"></message>
    <message name="makeReservationResponse"></message>
    <message name="getAllShows"></message>
    <message name="getAllShowsResponse"></message>
    <message name="cancelReservation"></message>
    <message name="cancelReservationResponse"></message>
    <portType name="TicketServiceEndpoint">
        <operation name="makeReservation">
            <input ns1:Action="http://service.ioc.xtec.cat/TicketServiceEndpoint/makeReservationRequest" message="tns:makeReservation"/>
            <output ns2:Action="http://service.ioc.xtec.cat/TicketServiceEndpoint/makeReservationResponse" message="tns:makeReservationResponse"/>
        </operation>
        <operation name="getAllShows">
            <input ns3:Action="http://service.ioc.xtec.cat/TicketServiceEndpoint/getAllShowsRequest" message="tns:getAllShows"/>
            <output ns4:Action="http://service.ioc.xtec.cat/TicketServiceEndpoint/getAllShowsResponse" message="tns:getAllShowsResponse"/>
        </operation>
        <operation name="cancelReservation">
            <input ns5:Action="http://service.ioc.xtec.cat/TicketServiceEndpoint/cancelReservationRequest" message="tns:cancelReservation"/>
            <output ns6:Action="http://service.ioc.xtec.cat/TicketServiceEndpoint/cancelReservationResponse" message="tns:cancelReservationResponse"/>
        </operation>
    </portType>
</definitions>

Vegem, per exemple, que l’operació cancelReservation rep com a paràmetre d’entrada un tns:cancelReservation i que retorna un tns:cancelReservationResponse. Aquests tipus de dades han estat definides completament en el document XSD (vegeu la figura).

A la part concreta hi tenim els següents elements:

• binding
• service

L’element <binding> (vegeu la figura) defineix el protocol i el format en què es poden fer les operacions; en el nostre cas, es faran per HTTP i amb un estil de Document.

L’element <service> (vegeu la figura), per la seva part, defineix el lloc físic on hi ha el servei web (adreça URL) mitjançant una col·lecció de punts de connexió <binding>. En el nostre cas, el servei web es cridarà amb el nom TicketService i està desplegat a l’adreça localhost:8080/resentioc/TicketService.

Si voleu provar alguna de les operacions que proporciona el servei web, per exemple, getAllShows, polseu el botó corresponent (vegeu la figura) i es fa una petició a l’operació del servei web que torna la llista de tots els concerts amb les entrades disponibles.

Aquesta petició genera aquest missatge SOAP de petició:

<?xml version="1.0" encoding="UTF-8"?><S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
    <SOAP-ENV:Header/>
    <S:Body>
        <ns2:getAllShows xmlns:ns2="http://service.ioc.xtec.cat/"/>
    </S:Body>
</S:Envelope>

I aquest missatge SOAP de resposta:

<?xml version="1.0" encoding="UTF-8"?><S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
    <SOAP-ENV:Header/>
    <S:Body>
        <ns2:getAllShowsResponse xmlns:ns2="http://service.ioc.xtec.cat/">
            <return>
                <availableTickets>5</availableTickets>
                <id>1</id>
                <location>Palau Sant Jordi</location>
                <name>U2 360 Tour</name>
            </return>
            <return>
                <availableTickets>3</availableTickets>
                <id>2</id>
                <location>Palau de la musica</location>
                <name>Carmina Burana</name>
            </return>
        </ns2:getAllShowsResponse>
    </S:Body>
</S:Envelope>

Hi ha dues maneres de cridar serveis web des de Java amb l’API JAX-WS:

• Creant un stub estàtic.
• Fent servir una interfície d’invocació dinàmica.

Anem a crear una aplicació Java stand-alone que consumeixi el servei web de gestió de reserves de places a concerts, i ho farem desenvolupant un client Java stand-alone que accedirà al servei web amb JAX-WS utilitzant stubs estàtics.

Els passos generals per fer un client que faci servir stubs estàtics són els següents:

1. Codificar la classe que farà de client.
2. Generar els artefactes necessaris per poder consumir el servei web des d’aquest client amb la utilitat wsimport.
3. Compilar i executar el client.

Creeu la classe Java que farà de client al paquet cat.xtec.ioc.client i l’anomeneu TicketServiceClient.

Genereu els artefactes per tal de poder consumir el servei web amb la utilitat wsimport. A wsimport cal especificar l’URL del document WSDL de descripció del servei web de gestió de reserves i on voleu que us generi els artefactes. Per fer-ho, obriu un command-prompt, situeu-vos al directori \target\classes\ on tingueu el projecte “Resentclientioc” i executeu la següent línia (cal que tingueu el directori <JDK_HOME>/bin al classpath per tal que us trobi l’executable wsimport i que hagueu fet Clean and Build del projecte):

Amb Windows:

wsimport -s ..\..\src\main\java -p cat.xtec.ioc.service.client.jaxws http://localhost:8080/resentioc/TicketService?wsdl

Amb Linux:

wsimport -s ../../src/main\java -p cat.xtec.ioc.service.client.jaxws http://localhost:8080/resentioc/TicketService?wsdl

Això us generarà un conjunt de fitxers .java amb tots els artefactes portables necessaris per cridar el servei web des de l’aplicació Java i els col·locarà al paquet cat.xtec.ioc.service.client.jaxws del projecte “Resentclientioc”.

Ara ja podem codificar la classe Java TicketServiceClient creada utilitzant els artefactes generats per wsimport. A les classes Java generades n’hi haurà una que s’anomenarà TicketService i que heretarà de Service; cal que instancieu aquesta classe i, a partir d’ella, obtingueu l’stub que us permetrà cridar les operacions del servei web.

El codi de la classe TicketServiceClient amb una crida a l’operació que mostra tots els concerts amb el nombre d’entrades disponibles és el següent:

package cat.xtec.ioc.client;
 
import cat.xtec.ioc.service.client.jaxws.Show;
import cat.xtec.ioc.service.client.jaxws.TicketService;
import cat.xtec.ioc.service.client.jaxws.TicketServiceEndpoint;
import java.util.List;
 
public class TicketServiceClient {
 
    public static void main(String[] args) {
        TicketService service = new TicketService();
        TicketServiceEndpoint port = service.getTicketServiceEndpointImplPort();
        List<Show> list = port.getAllShows();
        printAllShows(list);
    }
 
    public static void printAllShows(List<Show> shows) {
        shows.stream().forEach((show) -> {
            System.out.println("Show [id=" + show.getId() + ", name=" + show.getName() + ", available tickets=" + show.getAvailableTickets() + "]");
        });
    }
}

Ara ja podem executar el client; per fer-ho, poseu-vos damunt de la classe TicketServiceClient i feu Run File a NetBeans (vegeu la figura).

I obtindreu per consola un llistat dels concerts i de les entrades disponibles per a cada un d’ells:

Show [id=1, name=U2 360 Tour, available tickets=5]
Show [id=2, name=Carmina Burana, available tickets=3]

Anem a crear una aplicació web que consumeixi el servei web de gestió de reserves de places a concerts.

Per fer-ho crearem una aplicació web molt senzilla que farà servir el servei web SOAP de gestió de reserva de places a concerts.

Desplegueu el servei web com a part de l’aplicació Java EE que el conté fent Clean and Build i després Run a NetBeans.

El primer que cal fer és desplegar el servei web de gestió de reserva de places a concerts al servidor.

Comproveu que el servei web està desplegat correctament accedint a l’URL localhost:8080/resentioc/TicketService?WSDL amb un navegador.

Un cop desplegat el servei web ens cal un altre projecte, que serà l’aplicació web que accedirà com a client al servei web.

No entrarem en detalls, però el projecte que tenim com a punt de partida és una senzilla aplicació web Spring MVC que ha de mostrar un llistat dels concerts disponibles i, per a cada concert, ha de proporcionar una acció que permeti reservar una entrada i una acció que permeti cancel·lar una reserva. Per simplicitat, a l’exemple no seguirem estrictament una arquitectura per capes on els serveis es cridin des de la capa de serveis. Si ho féssim així crearíem un servei propi en aquesta capa i aquest servei seria l’encarregat de cridar el servei web SOAP de reserva de places a concerts.

L’aplicació web utilitzarà el servei web SOAP de gestió de reserva de places a concerts per proporcionar aquestes funcionalitats.

Un cop tingueu el projecte “Resentwebclientioc” carregat a NetBeans, el primer que farem serà llistar tots els concerts disponibles. Per fer-ho heu d’accedir a la classe ShowController del paquet cat.xtec.ioc.controller que fa de controlador i crear la referència al servei web SOAP que ens permetrà obtenir la llista de concerts:

private final TicketService showsWebService=new TicketService();

Si ho feu, veureu que NetBeans indica que la classe no compila. Això és degut al fet que ens falta generar els artefactes de client per tal de poder consumir el servei web amb la utilitat wsimport. A wsimport cal especificar l’URL del document WSDL de descripció del servei web de gestió de reserves i on voleu que us generi els artefactes.

Per fer-ho, obriu un command-prompt, situeu-vos al directori \target\classes\ on tingueu el projecte “Resentwebclientioc” i executeu la següent línia (cal que tingueu el directori <JDK_HOME>/bin al classpath per tal que us trobi l’executable wsimport i que hagueu fet Clean and Build del projecte):

Amb Windows:

wsimport -s ..\..\src\main\java -p cat.xtec.ioc.service.client.jaxws http://localhost:8080/resentioc/TicketService?wsdl

Amb Linux:

wsimport -s ../../src/main\java -p cat.xtec.ioc.service.client.jaxws http://localhost:8080/resentioc/TicketService?wsdl

Això us generarà un conjunt de fitxers .java amb tots els artefactes portables necessaris per cridar el servei web des de l’aplicació i els col·locarà al paquet cat.xtec.ioc.service.client.jaxws del projecte “Resentwebclientioc”. Un cop fet això, i l’import corresponent al controlador, la classe ja us compilarà.

A l’exemple hem vist que sempre ens cal generar els artefactes de client per poder cridar el servei web SOAP, i hem vist com fer-ho amb la utilitat del JDK wsimport. Si feu servir Maven al projecte també ho podeu fer amb un plugin per a JAX-WS que configura un goal de Maven anomenat wsimport i que s’executa a la fase generate-sources de generació del codi font.

Ja tenim la referència al servei web SOAP; ara crearem l’acció MVC que torni la llista de concerts. Per fer-ho, creeu un mètode anomenat shows amb el següent codi:

@RequestMapping(value = "/shows", method = RequestMethod.GET)
    public ModelAndView shows(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        ModelAndView modelview = new ModelAndView("shows");
        modelview.getModelMap().addAttribute("shows", showsWebService.getTicketServiceEndpointImplPort().getAllShows());
        return modelview;
    }

La part important d’aquest mètode és la crida al servei web SOAP:

showsWebService.getTicketServiceEndpointImplPort().getAllShows();

Obtenim una referència al servei web i invoquem el mètode getAllShows, que ens tornarà la llista de concerts.

Per provar-ho cal desplegar l’aplicació “Resentwebclientioc” a Glassfish. Per fer-ho, feu Run a NetBeans i es farà el desplegament al servidor d’aplicacions que tingueu configurat per al projecte (vegeu la figura).

Si tot ha anat bé i accediu a l’URL localhost:8080/resentwebclientioc/shows veureu la pàgina que mostra el llistat de concerts disponibles (vegeu la figura).

El procés per crear la funcionalitat que permeti fer una reserva i cancel·lar-la és el mateix: us cal crear l’acció corresponent al controlador i fer ús dels mètodes que proporciona el servei web SOAP de gestió de reserva de places a concerts per implementar-la.

El codi per a aquestes dues accions és el següent:

@RequestMapping("/makeReservation")
public ModelAndView makeReservation(@RequestParam("id") String id, HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    showsWebService.getTicketServiceEndpointImplPort().makeReservation(id);
    ModelAndView modelview = new ModelAndView("shows");
    modelview.getModelMap().addAttribute("shows", showsWebService.getTicketServiceEndpointImplPort().getAllShows());
    return modelview;
}
 
@RequestMapping("/cancelReservation")
public ModelAndView cancelReservation(@RequestParam("id") String id, HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    showsWebService.getTicketServiceEndpointImplPort().cancelReservation(id);
    ModelAndView modelview = new ModelAndView("shows");
    modelview.getModelMap().addAttribute("shows", showsWebService.getTicketServiceEndpointImplPort().getAllShows());
    return modelview;
}

Si desplegueu la nova versió de l’aplicació fent Run a NetBeans ja podreu provar les funcionalitat que permeten fer una reserva i cancel·lar-la.

Si ho proveu i aneu fent reserves per al concert del grup U2 veureu que, quan ja no quedin entrades disponibles, el servidor torna un error HTTP 500 (vegeu la figura).

Això és degut al fet que des del codi del servei web, quan volem fer una reserva per a un concert que no té localitats disponibles, s’està llençant una excepció:

public void makeTicketReservation() {
    if(this.availableTickets > 0) {
        this.availableTickets--;
    } else {
        throw new IllegalArgumentException("No more tickets available!");
    }        
}

Si mirem el log del servidor Glassfish veurem aquesta excepció:

Grave:   No more tickets available!
java.lang.IllegalArgumentException: No more tickets available!
  at cat.xtec.ioc.domain.Show.makeTicketReservation(Show.java:64)
	at cat.xtec.ioc.domain.repository.impl.InMemoryShowRepository.makeReservation(InMemoryShowRepository.java:33)
	at cat.xtec.ioc.service.impl.TicketServiceEndpointImpl.makeReservation(TicketServiceEndpointImpl.java:24)

JAX-WS converteix automàticament les excepcions de Java en una SOAPFault en format XML que viatjarà al missatge SOAP de resposta.

Heu vist les bases per al desenvolupament dels serveis web SOAP amb Java EE 7 i les heu treballat de forma pràctica mitjançant exemples.

Concretament, heu après:

• Les nocions bàsiques dels serveis web SOAP amb Java EE.
• A desenvolupar, desplegar i provar un servei web SOAP amb Java EE.
• A desenvolupar i provar un client Java que consulti un servei web SOAP.
• A desenvolupar i provar una aplicació web que consulti un servei web SOAP.

Per aprofundir en aquests conceptes i veure com us pot ajudar NetBeans en la creació i el consum de serveis web SOAP us recomanem que feu les activitats associades a aquest apartat.