Follow Us on Twitter
Home › Kenniscentrum › Whitebooks

WSIF, webservice-a-lize uw applicaties

Gepubliceerd in
0
0 reactie(s)

September 2004 – Een service oriented architecture (SOA) bestaat uit services die door ontwikkelaars worden gebouwd binnen een servicelaag. Deze services hebben een standaard manier van aanroepen; de interface. Al deze interfaces ondersteunen een specifiek domein: een witgoedhandel levert services voor het bekijken van actuele voorraadposities, een geldverstrekker heeft misschien services voor het direct opvragen van offertes. SOA’s worden geïmplementeerd met dit soort (web) services. 

Bedrijven die volgens het SOA principe ontwikkelen merken direct een aantal voordelen op. Een aantal van de meest voor de hand liggende voordelen zijn:

Kosten en baten

Het ontwikkelen binnen een service georiënteerde applicatieomgeving is erg kosteneffectief. Basisfunctionaliteiten van de applicatie worden modulair als services ontwikkeld en ingezet. Door het ontkoppelen van veelgebruikte of op zich staande functionaliteit is de kans erg groot dat de levensduur van een specifieke service veel langer is dan die van de applicatie als geheel. Een voorbeeld hiervan is bijvoorbeeld een creditcard verificatie service. Andere applicaties kunnen gecreëerd worden en aangepast worden in de loop van de tijd en kunnen gebruik maken van de "stabiele" creditcard verificatie service.

Herbruikbaarheid

Door de modulariteit van services is het erg gemakkelijk om functionaliteit te delen tussen meerdere applicaties, of zelfs met (applicaties van) externe partijen.

Code mobiliteit

Omdat onderdelen van de applicatie als op zichzelf staande services worden geïmplementeerd, maakt de fysieke en/of logische plaats van deze services niet uit. Dit biedt veel voordelen voor de schaalbaarheid en stabiliteit van de applicatie als geheel. Indien bepaalde services erg veel resources van de betreffende server gebruiken, kunnen deze eenvoudig worden verplaatst naar andere hardware. Er kan zelf voor gekozen worden om services te hosten bij een externe partij. Zo kan de bedrijfsapplicatie meegroeien met het bedrijf.

Beveiliging

Door het scheiden van de functionaliteit worden applicaties gescheiden in min of meer autonome onderdelen; de services. Iedere service is als zodanig op diverse manieren te beveiligen, zowel binnen de service logica, als op infrastructuur niveau.

In de praktijk blijkt dat het ontwikkelen van een SOA beperkingen kent: vooral in het kader van code mobiliteit lopen programmeurs tegen problemen op. Wat doen we bijvoorbeeld met code die een service gebuikt, waarvan later besloten wordt dat deze service een ander protocol gaat gebruiken? In de praktijk betekend dit vaak dat code moet worden herschreven. Met WSIF hoeft dit niet meer.

Wat is WSIF?

Het webservice invocation framework (WSIF) is een open source Java functiebibliotheek, beschikbaar gesteld door IBM en gedoneerd aan de Apache Foundation (http://www.apache.org). De WSIF bibliotheken maken het mogelijk om via een simpele API webservices aan te roepen. Het grote voordeel van het gebruik van deze API is dat de feitelijke implementatie van de geconsumeerde webservice verborgen blijft voor de programmeur. De programmeur werkt alleen met een abstracte implementatie van de webservice gebaseerd op de WSDL (webservice definition language) beschrijving van de service. Dit in tegenstelling tot bijvoorbeeld het gebruik van de Simple Object Access Protocol (SOAP) API’s, die over het algemeen veel gebruikt worden voor het communiceren met webservices.

Met WSIF worden webservices volledig dynamisch aangesproken. Dit gebeurd op basis van de beschrijving ervan in de WSDL. Daarnaast is het met WSIF mogelijk om voor een webservice verschillende beschikbare implementaties te definiëren. Vervolgens kan er runtime gekozen worden welke implementatie gebruikt wordt. De WSIF metadata heeft uitbreidingen op WSDL en maakt het op die manier mogelijk om iedere service die te definiëren is in WSDL te benaderen als service. Met WSIF is het bijvoorbeeld mogelijk om een simpele Java klasse of een EJB als een web service te benaderen.

Voordelen van WSIF

Omdat WSIF het gebruik en de implementatie van een webservice van elkaar scheidt, wordt het mogelijk om programmatuur te schrijven die niet meer aangepast hoeft te worden als de implementatie of locatie van de gebruikte webservice wijzigt. Bij het gebruik van bijvoorbeeld de SOAP API’s zou code moeten worden herschreven op het moment dat de aanbieders van de webservice besluiten het gebruikte protocol van de webservice te wijzigen. Daarnaast wordt het door de scheiding van gebruik en implementatie makkelijker om te testen, of parallel te ontwikkelen. Er zou bijvoorbeeld gekozen kunnen worden om een te bouwen web service eerst snel en simpel te bouwen als simpele Java classes. Door clients met deze (virtuele) webservice te laten communiceren via WSIF kunnen de Java classes op een later tijdstip eenvoudig worden vervangen door, of uitgebouwd naar, de echte webservice op een applicatie server. De cliënt code hoeft hiervoor dan niet meer worden aangepast; het aanpassen van de WSDL die de service beschrijft is voldoende. Het concept van WSIF past volledig binnen de SOA applicatie architectuur.

Architectuur

De architectuur van WSIF is redelijk eenvoudig en modulair. De feitelijke logica zit in de WSIF kernel die benaderbaar is voor de programmeur via de WSIF API. De programmeur stuurt WSIF niet alleen via de API, maar ook met de WSDL beschrijving van de service. Binnen WSIF zijn er voor het benaderen van services providers gedefinieerd. Een provider is het stukje binnen WSIF wat de feitelijke aanroep van de service via een specifiek protocol uitvoert. Naast de (op dit moment) zes standaard providers, heeft de programmeur altijd de mogelijkheid om een eigen provider te schrijven voor een specifiek protocol. Zo zou het zelfs mogelijk zijn om een (virtuele) service te definiëren die werkt via bijvoorbeeld LDAP. Deze kan dan aangesproken worden via WSIF door een eigen LDAP provider te maken. De architectuur van WSIF is te vergelijken met de architectuur van de Oracle InterConnect adapters.

Voorbeeld

Stel we hebben de WSDL beschrijving van een simpele stockquote webservice, die de actuele koers van een aandeel kan teruggeven:

<?xml version="1.0" ?> 
  <definitions
      targetNamespace="http://tst/namespace/wsif/samples/stockquote-interface"
      xmlns:tns="http://tst/namespace/wsif/samples/stockquote-interface"  
      xmlns:xsd="http://www.w3.org/1999/XMLSchema"
      xmlns="http://schemas.xmlsoap.org/wsdl/">
  <message name="GetQuoteInput">     
        <part name="symbol" type="xsd:string"/>    
     </message>    
     <message name="GetQuoteOutput">
         <part name="quote" type="xsd:float"/>    
       </message>
      <portType name="StockquotePT">
         <operation name="getQuote">
           <input message="tns:GetQuoteInput"/>
           <output message="tns:GetQuoteOutput"/>
         </operation>
       </portType>
  </definitions>

In deze WSDL is te zien dat het gaat om een simpele service met één methode, aangeboden via één poorttype; methode getQuote, via poorttype StockQuotePT. Deze methode moet worden aangeroepen via een bericht GetQuoteInput, dat bestaat uit één argument symbol, een string waarin het symbool van het aandeel staat. De methode antwoord met een bericht GetQuoteOutput, dat bestaat uit een actuele koers quote van het type float, dat de actuele koers van het aandeel bevat.

Om deze webservice aan te kunnen spreken via het SOAP protocol is een document nodig dat de binding en het zogenaamde service eindpunt beschrijft. Dit is de SOAP binding:

<?xml version="1.0" ?>
     <definitions targetNamespace="http://tst/namespace/wsif/samples/stockquote"
         xmlns:tns="http://tst/namespace/wsif/samples/stockquote"
         xmlns:tns-int="http://tst/namespace/wsif/samples/stockquote-interface"
         xmlns:xsd="http://www.w3.org/1999/XMLSchema"
         xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
         xmlns:java="http://schemas.xmlsoap.org/wsdl/java/"
         xmlns="http://schemas.xmlsoap.org/wsdl/">   
       <import namespace="http://tst/namespace/wsif/samples/stockquote-interface" 
           location="stockquote-interface.wsdl"/>   
       <binding name="SOAPBinding" type="tns-int:StockquotePT">
         <soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http"/>
         <operation name="getQuote">
           <soap:operation soapAction="http://example.com/GetTradePrice"/>
           <input>
             <soap:body use="encoded" namespace="urn:xmltoday-delayed-quotes"
                 encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
           </input>
           <output>
             <soap:body use="encoded" namespace="urn:xmltoday-delayed-quotes" 
                 encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
           </output>
         </operation>
       </binding>
       <service name="StockquoteService">
         <documentation>Stock quote service</documentation>
         <port name="SOAPPort" binding="tns:SOAPBinding">
           <soap:address location="http://localhost:8080/soap/servlet/rpcrouter"/>
         </port>   
       </service>
     </definitions>

Deze SOAP binding definieert het te gebruiken protocol (HTTP) en een url (de poort) waarop de service aangesproken kan worden.

Om de service aan te spreken via het SOAP protocol in Java, zouden we de volgende code, gebaseerd op de Apache SOAP API’s, kunnen gebruiken:

// Identificeren van de service
 Call call = new Call();
 call.setTargetObjectURI("urn:xmltoday-delayed-quotes");

 // Identificeren van de aan te roepen methode
 call.setMethodName("getQuote");
 call.setEncodingStyleURI(encodingStyleURI);

 // Definieren van de parameters voor het aanroepen van de methode  
 Vector params = new Vector();  
 params.addElement(new Parameter("symbol", String.class, symbol, null)); 
 call.setParams(params);   

 // Voor de aanroep naar de service uit 
 Response resp = call.invoke(url, "http://example.com/GetTradePrice");

 // Extraheer het resultaat van de aanroep
 if(resp.generatedFault()) {    
   Fault fault = resp.getFault();    
   System.out.println("Er is een fout opgetreden: ");    
   System.out.println("Foutcode = " + fault.getFaultCode());    
   System.out.println("Omschrijving = " + fault.getFaultString());    
   throw new SOAPException("Fout tijdens service aanroep: " + fault);
 } else {   
   Parameter result = resp.getReturnValue();   
   return ((Float) result.getValue()).floatValue();
 }

Hier is duidelijk zichtbaar dat de code gebruik maakt van de SOAP binding definitie. Alhoewel het programmeren tegen de SOAP API redelijk eenvoudig is, is het gebruik van de WSIF API veel intuïtiever, en verbergt de specifieke binding van de webservice:

// Identificeer de service
 Definition def = WSIFUtils.readWSDL(null,wsdlLocation);

// Identificeer de methode (ophalen van de poorten)
 WSIFDynamicPortFactory portFactory = new  WSIFDynamicPortFactory(def, null, null); 

 // Haal de standaard poort op 
 WSIFPort port = portFactory.getPort(); 

 // Er kan ook een specifieke poort geselecteerdworden:
 // WSIFPort port =  portFactory.getPort("SOAPPort"); 

// Identificeer de parameters, en bereid het bericht om op te sturen voor
 WSIFMessage input = port.createInputMessage(); 
 input.setPart("symbol", new WSIFJavaPart(String.class, symbol));

 // Zet alvast een variabele klaar om een bericht van de service terug teontvangen 
 WSIFMessage output = port.createOutputMessage(); 

 // Roep de methode aan 
 port.executeRequestResponseOperation("getQuote", input, output, null);

 // Extraheer het resultaat van de service aanroep 
 WSIFPart part = output.getPart("quote"); 

 return ((Float)part.getJavaValue()).floatValue();

In dit voorbeeld is duidelijk te zien dat de WSIF API meer gebaseerd is op de WSDL van services, in plaats van de bindings. Indien de in dit voorbeeld beschreven service van implementatie zou wisselen, voldoet de aanroep van de service volgens de SOAP API niet meer. De code zou herschreven moeten worden. In het geval van de WSIF API hoeft alleen het WSDL document aangepast te worden.

Relevante Links

Waardering:
 
Tags:
Print versiePrint versiePDF versiePDF versie

Reacties

Nieuwe reactie inzenden

De inhoud van dit veld is privé en zal niet openbaar worden gemaakt.

Meer informatie over formaatmogelijkheden

CAPTCHA
Deze vraag is om te testen of u een persoon bent en om spam te voorkomen
Image CAPTCHA
Enter the characters shown in the image.
Kenniscentrum
Whitebooks
Evenementen		   Blog
Expertises

 
Carrières

Werken bij ons
Arbeidsvoorwaarden
Afstudeerders

   Solliciteren
Vacatures
Wij zoeken
 
Over Whitehorses
Profiel
Nieuws
Team		   infoForms
Diensten
Expertises