Rubino Web Services Applicazioni - SOAP4R

Qual è il sapone?

Simple Object Access Protocol (SOAP, tutti scritti per il Simple Object Access Protocol) è un protocollo specifica per lo scambio di dati.

SOAP è un semplice protocollo basato su XML che permette alle applicazioni di scambiare informazioni su HTTP.

Simple Object Access Protocol, è una specifica protocollo per lo scambio di dati, è un peso leggero, semplice, basato su XML (un sottoinsieme del Standard Generalized Markup Language sotto), il protocollo, che è stato progettato per lo scambio strutturato sul WEB e curare le informazioni.

Si prega di vedere di più SOAP Tutorial: http://www.w3cschool.cc/soap/soap-tutorial.html .

installazione SOAP4R

SOAP4R Hiroshi Nakamura sviluppato dalla implementazione di SOAP per le applicazioni Ruby.

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

Nota: L'ambiente rubino potrebbe essere già installato il componente.

Sotto Linux è possibile installare il componente con la gemma, il seguente comando:

$ gem install soap4r --include-dependencies

Se siete sotto l'ambiente di sviluppo della finestra, è necessario scaricare il file zip, e installarlo eseguendo install.rb.

Servizio SOAP4R

SOAP4R supporta due diversi tipi di servizio:

• Sulla base di CGI / servizi FastCGI (SOAP RPC :: :: CGIStub)
• Servizio indipendente (SOAP :: RPC: StandaloneServer)

Questo tutorial vi mostrerà come costruire un servizi SOAP indipendenti. Procedere come segue:

Fase 1 - Trasmissione SOAP RPC :: :: StandaloneServer

Al fine di raggiungere il proprio server separato, è necessario scrivere una nuova classe che è SOAP RPC :: :: StandaloneServer sub-categorie:

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

Nota: Se si vuole scrivere un FastCGI basata su server, quindi è necessario estendere SOAP RPC :: :: classe CGIStub, il resto del programma rimarrà invariato.

Fase due - definire i metodi di lavorazione

Poi definiamo approccio servizi Web, si definiscono i seguenti due metodi, uno è la somma di due numeri, uno è diviso per il numero due:

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

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

La terza fase - metodo di lavorazione pubblicazione

Poi, aggiungiamo metodi definiti sul server, inizializzare il metodo è indicato per le connessioni esterne:

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

Ecco una descrizione di ogni parametro:

Per capireinoutefuoriparametri, considerare i seguenti metodi di servizio, è necessario immettere due parametri: InParam e inoutParam, la funzione restituisce tre valori dopo il completamento della realizzazione: retVal, inoutParam, outParam:

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

Pubblicazione di chiamata come segue:

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

Il quarto passo - servizio aperto

Infine, creare un'istanza della classe derivata, e chiamare il metodo start per avviare il servizio:

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

myServer.start

Quanto segue è una descrizione del parametro di richiesta:

Esempi

Poi abbiamo Attraverso i passaggi precedenti per creare un servizio stand-alone:

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

Dopo l'esecuzione del programma di cui sopra, avviare un ascoltatore sulla porta 8080 dei servizi locali, ed espone due metodi: aggiungi e div.

È quindi possibile eseguire lo sfondo di questi servizi:

$ ruby MyServer.rb&

cliente SOAP4R

rubino utilizzare SOAP RPC :: :: cliente classe del driver di sviluppo SOAP. Prossimo guardiamo in dettaglio utilizzando SOAP RPC :: :: classe del driver.

servizio SOAP chiamata richiede le seguenti informazioni:

• SOAP Servizio indirizzo URL (SOAP endpoint URL)
• Namespace metodo di servizio (metodo namespace URI)
• Nome metodo di servizio e sui parametri

Quindi, facciamo un passo per creare un client SOAP per richiamare il metodo SOAP sopra: aggiungere, div:

FASE UNO - Creare esempio SOAP driver

Siamo in grado di chiamare un nuovo metodo per istanziare SOAP RPC :: :: classe del driver, come segue:

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

Quanto segue è una descrizione dei parametri:

Fase due - aggiungere metodo di servizio

SOAP RPC :: :: driver per aggiungere metodo di servizio SOAP, si può chiamare il seguente metodo a titolo di esempio SOAP RPC :: :: guida:

driver.add_method(name, *paramArg)

Quanto segue è una descrizione dei parametri:

Il terzo passo - chiamando servizi SOAP

Infine, possiamo usare SOAP RPC :: :: esempio driver per invocare servizi SOAP:

result = driver.serviceMethod(paramArg...)

L'attuale servizi SOAP nome del metodo serviceMethod, paramArg per elenco di parametri del metodo.

Esempi

Sulla base dei punti di cui sopra, possiamo scrivere il seguente client SOAP:

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

Sopra abbiamo semplicemente introdurre servizi Web di Ruby. Se volete saperne di più è possibile visualizzare il documento ufficiale: il Rubino di Web Services