The best Ruby Web Services Applications - SOAP4R Tutorial In 2024, In this tutorial you can learn What is SOAP?,SOAP4R installation,SOAP4R Service,SOAP4R client,
Simple Object Access Protocol (SOAP, all written for the Simple Object Access Protocol) is a protocol specification for exchanging data.
SOAP is a simple XML-based protocol that allows applications to exchange information over HTTP.
Simple Object Access Protocol, is a protocol specification for exchanging data, is a lightweight, simple, based on XML (a subset of the Standard Generalized Markup Language under) protocol, which is designed to exchange structured on the WEB and curing information.
Please see more SOAP Tutorial: /soap/soap-tutorial .
SOAP4R Hiroshi Nakamura developed by the implementation of SOAP for Ruby applications.
SOAP4R Download: http://raa.ruby-lang.org/project/soap4r/ .
Note: Your ruby environment may already installed the component.
Under Linux you can install the component using the gem, the following command:
$ gem install soap4r --include-dependencies
If you are under the window development environment, you need to download the zip file, and install by executing install.rb.
SOAP4R supports two different types of service:
This tutorial will show you how to build an independent SOAP services. Proceed as follows:
In order to achieve their own separate server, you need to write a new class that is SOAP :: RPC :: StandaloneServer sub-categories:
class MyServer < SOAP::RPC::StandaloneServer /en/en/en/en/en/en/en. end
Note: If you want to write a server-based FastCGI, then you need to extend SOAP :: RPC :: CGIStub class, the rest of the program will remain unchanged.
Next we define Web Services approach, we define the following two methods, one is the sum of two numbers, one is divided by the number two:
class MyServer < SOAP::RPC::StandaloneServer /en/en/en/en/en/en/en. # 处理方法 def add(a, b) return a + b end def div(a, b) return a / b end end
Next, we add methods defined on the server, initialize method is disclosed for external connections:
class MyServer < SOAP::RPC::StandaloneServer def initialize(*args) add_method(receiver, methodName, *paramArg) end end
Here is a description of each parameter:
parameter | description |
---|---|
receiver | Object that contains the method name of the method. If you define service method in the same class, the parameter isself. |
methodName | RPC method invocation request name. |
paramArg | Parameter name and parameter mode |
To understandinoutandoutparameters, consider the following service methods, you need to enter two parameters: inParam and inoutParam, the function returns three values after the completion of the implementation: retVal, inoutParam, outParam:
def aMeth(inParam, inoutParam) retVal = inParam + inoutParam outParam = inParam . inoutParam inoutParam = inParam * inoutParam return retVal, inoutParam, outParam end
Publication of call as follows:
add_method(self, 'aMeth', [ %w(in inParam), %w(inout inoutParam), %w(out outParam), %w(retval return) ])
Finally, we instantiate the derived class, and call the start method to start the service:
myServer = MyServer.new('ServerName', 'urn:ruby:ServiceName', hostname, port) myServer.start
The following is a description of the request parameter:
parameter | description |
---|---|
ServerName | Service name, you can take your favorite |
urn: ruby: ServiceName | Hereurn: ruby is fixed, but you can take a uniqueServiceNamefor your service |
hostname | Specify the host name |
port | web service port |
Next we Through the above steps to create a stand-alone service:
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
After executing the above program, start a listener on port 8080 of the local services, and exposes two methods: add and div.
You can then perform the background of these services:
$ ruby MyServer.rb&
ruby use SOAP :: RPC :: Driver class development SOAP client. Next we look in detail using SOAP :: RPC :: Driver class.
Call SOAP service requires the following information:
Next, we take a step to create a SOAP client to invoke the above SOAP method: add, div:
We can call it a new method to instantiate SOAP :: RPC :: Driver class, as follows:
SOAP::RPC::Driver.new(endPoint, nameSpace, soapAction)
The following is a description of the parameters:
parameter | description |
---|---|
endPoint | SOAP service connection URL address |
nameSpace | Namespace for SOAP :: RPC :: Driver object all RPC. |
soapAction | For SOAPAction HTTP header field values. If the string is "" the default isnil |
SOAP :: RPC :: Driver to add SOAP service method, we can call the following method by way of example SOAP :: RPC :: Driver:
driver.add_method(name, *paramArg)
The following is a description of the parameters:
parameter | description |
---|---|
name | The method name of the remote web services |
paramArg | Parameter to specify the remote program |
Finally, we can use SOAP :: RPC :: Driver instance to invoke SOAP services:
result = driver.serviceMethod(paramArg/en.)
The actual method name serviceMethod SOAP services, paramArg for the method's parameter list.
Based on the above steps, we can write the following SOAP client:
#!/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
Above we simply introduce Ruby's Web Services. If you want to know more you can view the official document: the Ruby of Web Services