Webdienste mit Ruby - SOAP4R

Was ist Seife?

Das Simple Object Access Protocol (SOAP) ist ein plattformübergreifendes und sprachunabhängiges RPC-Protokoll, das auf XML und normalerweise (aber nicht unbedingt) HTTP basiert.

Es verwendet XML, um die Informationen zu codieren, die den Remoteprozeduraufruf ausführen, und HTTP, um diese Informationen über ein Netzwerk von Clients zu Servern und umgekehrt zu transportieren.

SOAP bietet gegenüber anderen Technologien wie COM, CORBA usw. mehrere Vorteile: Zum Beispiel die relativ günstigen Bereitstellungs- und Debugging-Kosten, die Erweiterbarkeit und Benutzerfreundlichkeit sowie das Vorhandensein mehrerer Implementierungen für verschiedene Sprachen und Plattformen.

Weitere Informationen finden Sie in unserem einfachen Tutorial SOAP .

Dieses Kapitel macht Sie mit der SOAP-Implementierung für Ruby (SOAP4R) vertraut. Dies ist ein grundlegendes Tutorial. Wenn Sie also ein detailliertes Detail benötigen, müssen Sie auf andere Ressourcen verweisen.

SOAP4R installieren

SOAP4R ist die von Hiroshi Nakamura entwickelte SOAP-Implementierung für Ruby und kann heruntergeladen werden von -

NOTE - Möglicherweise haben Sie diese Komponente bereits installiert.

Download SOAP

Wenn Sie sich dessen bewusst sind gem Dienstprogramm, dann können Sie den folgenden Befehl verwenden, um SOAP4R und verwandte Pakete zu installieren.

$ gem install soap4r --include-dependencies

Wenn Sie unter Windows arbeiten, müssen Sie eine komprimierte Datei vom oben genannten Speicherort herunterladen und mithilfe der Standardinstallationsmethode installieren, indem Sie ruby install.rb ausführen .

Schreiben von SOAP4R-Servern

SOAP4R unterstützt zwei verschiedene Servertypen -

CGI / FastCGI-basiert (SOAP :: RPC :: CGIStub)
Standalone (SOAP :: RPC: StandaloneServer)

Dieses Kapitel enthält Einzelheiten zum Schreiben eines eigenständigen Servers. Die folgenden Schritte sind beim Schreiben eines SOAP-Servers erforderlich.

Schritt 1 - SOAP :: RPC :: StandaloneServer-Klasse erben

Um Ihren eigenen eigenständigen Server zu implementieren, müssen Sie eine neue Klasse schreiben, die SOAP :: StandaloneServer wie folgt untergeordnet ist:

class MyServer < SOAP::RPC::StandaloneServer
  ...............
end

NOTE- Wenn Sie einen FastCGI-basierten Server schreiben möchten, müssen Sie SOAP :: RPC :: CGIStub als übergeordnete Klasse verwenden. Der Rest der Prozedur bleibt unverändert .

Schritt 2 - Handlermethoden definieren

Der zweite Schritt besteht darin, Ihre Web Services-Methoden zu schreiben, die Sie der Außenwelt zugänglich machen möchten.

Sie können als einfache Ruby-Methoden geschrieben werden. Schreiben wir zum Beispiel zwei Methoden, um zwei Zahlen hinzuzufügen und zwei Zahlen zu teilen -

class MyServer < SOAP::RPC::StandaloneServer
   ...............

   # Handler methods
   def add(a, b)
      return a + b
   end
   def div(a, b) 
      return a / b 
   end
end

Schritt 3 - Handlermethoden verfügbar machen

Der nächste Schritt besteht darin, unsere definierten Methoden zu unserem Server hinzuzufügen. Die Initialisierungsmethode wird verwendet, um Dienstmethoden mit einer der beiden folgenden Methoden verfügbar zu machen:

class MyServer < SOAP::RPC::StandaloneServer
   def initialize(*args)
      add_method(receiver, methodName, *paramArg)
   end
end

Hier ist die Beschreibung der Parameter -

Sr.Nr.	Parameter & Beschreibung
1	receiver Das Objekt, das die Methode methodName enthält. Sie definieren die Servicemethoden in derselben Klasse wie die methodDef-Methode. Dieser Parameter ist self .
2	methodName Der Name der Methode, die aufgrund einer RPC-Anforderung aufgerufen wird.
3	paramArg Gibt, wenn angegeben, die Parameternamen und Parametermodi an.

Um die Verwendung von Inout- oder Out- Parametern zu verstehen , betrachten Sie die folgende Dienstmethode, die zwei Parameter (inParam und inoutParam) verwendet, einen normalen Rückgabewert (retVal) und zwei weitere Parameter zurückgibt : inoutParam und outParam -

def aMeth(inParam, inoutParam)
   retVal = inParam + inoutParam
   outParam = inParam . inoutParam
   inoutParam = inParam * inoutParam
   return retVal, inoutParam, outParam
end

Jetzt können wir diese Methode wie folgt verfügbar machen:

add_method(self, 'aMeth', [
   %w(in inParam),
   %w(inout inoutParam),
   %w(out outParam),
   %w(retval return)
])

Schritt 4 - Starten Sie den Server

Der letzte Schritt besteht darin, Ihren Server zu starten, indem Sie eine Instanz der abgeleiteten Klasse instanziieren und aufrufen start Methode.

myServer = MyServer.new('ServerName', 'urn:ruby:ServiceName', hostname, port)

myServer.start

Hier ist die Beschreibung der erforderlichen Parameter -

Sr.Nr.	Parameter & Beschreibung
1	ServerName Mit einem Servernamen können Sie angeben, was Ihnen am besten gefällt.
2	urn:ruby:ServiceName Hier Urne: Ruby ist konstant, aber Sie können diesem Server einen eindeutigen ServiceName-Namen geben.
3	hostname Gibt den Hostnamen an, den dieser Server abhört.
4	port Eine verfügbare Portnummer, die für den Webdienst verwendet werden soll.

Beispiel

Lassen Sie uns nun mit den obigen Schritten einen eigenständigen Server schreiben -

require "soap/rpc/standaloneserver"

begin
   class MyServer < SOAP::RPC::StandaloneServer

      # Expose our services
      def initialize(*args)
         add_method(self, 'add', 'a', 'b')
         add_method(self, 'div', 'a', 'b')
      end

      # Handler methods
      def add(a, b)
         return a + b
      end
      def div(a, b) 
         return a / b 
      end
end
   server = MyServer.new("MyServer", 
            'urn:ruby:calculation', 'localhost', 8080)
   trap('INT){
      server.shutdown
   }
   server.start
rescue => err
   puts err.message
end

Bei der Ausführung startet diese Serveranwendung einen eigenständigen SOAP-Server auf localhost und wartet auf Anforderungen auf Port 8080. Sie macht eine Dienstmethode verfügbar, add und div , die zwei Parameter verwendet und das Ergebnis zurückgibt.

Jetzt können Sie diesen Server wie folgt im Hintergrund ausführen:

$ ruby MyServer.rb&

Schreiben von SOAP4R-Clients

Die SOAP :: RPC :: Driver- Klasse bietet Unterstützung für das Schreiben von SOAP-Clientanwendungen. Dieses Kapitel beschreibt diese Klasse und demonstriert ihre Verwendung anhand einer Anwendung.

Im Folgenden finden Sie die Mindestinformationen, die Sie zum Aufrufen eines SOAP-Dienstes benötigen würden:

Die URL des SOAP-Dienstes (SOAP-Endpunkt-URL).
Der Namespace der Dienstmethoden (Method Namespace URI).
Die Namen der Dienstmethoden und ihre Parameter.

Jetzt schreiben wir einen SOAP-Client, der die im obigen Beispiel definierten Dienstmethoden add und div aufruft .

Hier sind die wichtigsten Schritte zum Erstellen eines SOAP-Clients.

Schritt 1 - Erstellen Sie eine SOAP-Treiberinstanz

Wir erstellen eine Instanz von SOAP :: RPC :: Driver, indem wir die neue Methode wie folgt aufrufen:

SOAP::RPC::Driver.new(endPoint, nameSpace, soapAction)

Hier ist die Beschreibung der erforderlichen Parameter -

Sr.Nr.	Parameter & Beschreibung
1	endPoint URL des SOAP-Servers, mit dem eine Verbindung hergestellt werden soll.
2	nameSpace Der Namespace, der für alle RPCs verwendet werden soll, die mit diesem SOAP :: RPC :: Driver-Objekt erstellt wurden.
3	soapAction Ein Wert für das SOAPAction-Feld des HTTP-Headers. Wenn nil, wird standardmäßig die leere Zeichenfolge "" verwendet.

Schritt 2 - Hinzufügen von Servicemethoden

Um eine SOAP - Service - Methode zu einem hinzufügen SOAP :: RPC :: Treiber können wir rufen Sie das folgende Verfahren unter Verwendung von SOAP :: RPC :: Treiber - Instanz -

driver.add_method(name, *paramArg)

Hier ist die Beschreibung der Parameter -

Sr.Nr.	Parameter & Beschreibung
1	name Der Name der Remote-Webdienstmethode.
2	paramArg Gibt die Namen der Parameter der Remoteprozeduren an.

Schritt 3 - Rufen Sie den SOAP-Dienst auf

Der letzte Schritt besteht darin, den SOAP-Service mithilfe der SOAP :: RPC :: Driver- Instanz wie folgt in Rechnung zu stellen :

result = driver.serviceMethod(paramArg...)

Hier serviceMethod ist die eigentliche Web - Service - Methode und paramArg ... die Liste erforderlichen Parameter in der Service - Methode zu übergeben.

Example

Basierend auf den obigen Schritten schreiben wir einen SOAP-Client wie folgt:

#!/usr/bin/ruby -w

require 'soap/rpc/driver'

NAMESPACE = 'urn:ruby:calculation'
URL = 'http://localhost:8080/'

begin
   driver = SOAP::RPC::Driver.new(URL, NAMESPACE)
   
   # Add remote sevice methods
   driver.add_method('add', 'a', 'b')

   # Call remote service methods
   puts driver.add(20, 30)
rescue => err
   puts err.message
end

Weitere Lesungen

Ich habe Ihnen nur sehr grundlegende Konzepte von Web Services mit Ruby erklärt. Wenn Sie einen weiteren Drilldown durchführen möchten, finden Sie unter folgendem Link weitere Informationen zu Webdiensten mit Ruby .