Ruby-Web-Services-Anwendungen - SOAP4R

Was ist SOAP?

Simple Object Access Protocol (SOAP, die alle für das Simple Object Access Protocol geschrieben) ist ein Protokoll-Spezifikation für den Datenaustausch.

SOAP ist ein einfaches XML-basiertes Protokoll, das Anwendungen Informationen über HTTP austauschen.

Simple Object Access Protocol ist ein Protokoll-Spezifikation für den Austausch von Daten, eine ist leicht, einfach, basiert auf XML (eine Teilmenge der Standard Generalized Markup Language unter) Protokoll, das auf dem Internet austauschen strukturiert ausgebildet ist und Heilung von Informationen.

Bitte lesen Sie mehr SOAP Tutorial: http://www.w3cschool.cc/soap/soap-tutorial.html .

SOAP4R Installation

SOAP4R Hiroshi Nakamura durch die Implementierung von SOAP für Ruby-Anwendungen entwickelt.

SOAP4R Download: http://raa.ruby-lang.org/project/soap4r/ .

Hinweis: Ihr rubin Umgebung , um die Komponente bereits installiert werden.

Unter Linux können Sie die Komponente mit dem Edelstein, den folgenden Befehl installieren:

$ gem install soap4r --include-dependencies

Wenn Sie unter dem Fenster Entwicklungsumgebung sind, müssen Sie die Zip-Datei herunterladen und installieren von install.rb ausführt.

SOAP4R-Service

SOAP4R unterstützt zwei verschiedene Arten von Diensten:

• Basierend auf CGI / FastCGI-Services (SOAP :: RPC :: CGIStub)
• Unabhängige Service (SOAP :: RPC: StandaloneServer)

Dieses Tutorial zeigt Ihnen, wie eine unabhängige SOAP-Dienste zu bauen. Gehen Sie wie folgt vor:

Schritt 1 - Vererbung SOAP :: RPC :: StandaloneServer

Um ihre eigenen separaten Server zu erreichen, müssen Sie eine neue Klasse zu schreiben, die SOAP ist :: RPC :: StandaloneServer Unterkategorien:

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

Hinweis: Wenn Sie eine serverbasierte FastCGI schreiben wollen, dann müssen Sie SOAP erweitern :: RPC :: CGIStub Klasse, wird der Rest des Programms bleiben unverändert.

Schritt zwei - Verarbeitungsverfahren definieren

wir Web Services-Ansatz Als nächstes definieren wir die folgenden zwei Methoden definieren, ist eine die Summe von zwei Zahlen, eine durch die Nummer zwei geteilt:

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

   # 处理方法
   def add(a, b)
      return a + b
   end
   def div(a, b) 
      return a / b 
   end
end

Der dritte Schritt - Veröffentlichung Verarbeitungsverfahren

Als nächstes fügen wir auf dem Server definierten Methoden, initialisieren Verfahren für externe Verbindungen offenbart:

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

Hier ist eine Beschreibung der einzelnen Parameter:

inoutundout- Parameter, die folgenden Service - Methoden zu verstehen, müssen Sie zwei Parameter eingeben: InParam und inOutParam, gibt die Funktion drei Werte nach dem Abschluss der Umsetzung: retVal, inOutParam, outParam:

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

Veröffentlichung der Aufruf wie folgt:

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

Der vierte Schritt - offener Dienst

Schließlich instanziiert wir die abgeleitete Klasse, und die Startmethode aufrufen, den Dienst zu starten:

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

myServer.start

Es folgt eine Beschreibung des Anforderungsparameter:

Beispiele

Als nächstes Durch wir die obigen Schritte, um eine Stand-alone-Dienst zu erstellen:

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

Nachdem das obige Programm ausgeführt wird, wird ein Listener auf Port 8080 der lokalen Dienste zu starten, und stellt zwei Methoden: add und div.

Sie können dann den Hintergrund dieser Leistungen zu erbringen:

$ ruby MyServer.rb&

SOAP4R Client

Rubin SOAP verwenden :: RPC :: Treiberklasse Entwicklung SOAP-Client. Als nächstes schauen wir uns im Detail unter Verwendung von SOAP :: RPC :: Treiberklasse.

Rufen Sie SOAP-Dienst erfordert die folgenden Informationen:

• SOAP-Service-URL-Adresse (SOAP Endpoint URL)
• Namespace (Methode Namespace URI) Service-Methode
• Service-Methodennamen und Parameterinformationen

Als nächstes nehmen wir einen Schritt einen SOAP-Client zu erstellen, die über SOAP-Methode aufzurufen: add, div:

Erster Schritt - Erstellen Instanz SOAP-Treiber

Wir können sie eine neue Methode aufrufen, um SOAP-instanziiert :: RPC :: Treiberklasse, wie folgt:

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

Nachfolgend finden Sie eine Beschreibung der Parameter:

Schritt zwei - fügen Sie Service-Methode

SOAP :: RPC :: Driver auf SOAP-Service-Methode hinzugefügt haben, können wir die folgende Methode beispielhaft SOAP-Aufruf :: RPC :: Driver:

driver.add_method(name, *paramArg)

Nachfolgend finden Sie eine Beschreibung der Parameter:

Der dritte Schritt - Aufruf SOAP-Dienste

Schließlich können wir SOAP :: RPC :: Treiber-Instanz verwenden, um SOAP-Dienste aufzurufen:

result = driver.serviceMethod(paramArg...)

Die eigentliche Methode Name serviceMethod SOAP-Dienste, paramArg für die Parameterliste der Methode.

Beispiele

Basierend auf den obigen Schritten können wir folgende SOAP-Client schreiben:

#!/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

Oben haben wir einfach Ruby Web Services einzuführen. Wenn Sie mehr wissen wollen , können Sie das offizielle Dokument anzuzeigen: die Ruby - von Web Services