Sams Teach Yourself XML in 21 Days

Recommended Book

Sams Teach Yourself XML in 21 Days, 3rd Edition

Learn More Buy

Recommended Book

Recommended Book 

Sams Teach Yourself XML in 21 Days, 3rd Edition

Learn More Buy

A SOAP Example in .NET

You'll start our look at SOAP examples with Microsoft's .NET. In particular, you'll use Microsoft's C# language in Windows. It's a little-known fact that you can get C# for free—to use the C# command-line compiler, csc, all you need to do is install the .NET Framework's Software Development Kit (SDK), which you can get for free at http://msdn.microsoft.com/downloads.

After you install this download, you can find the csc command-line compiler in the system's root directory; for example, in Windows 2000, that is C:\WINNT\Microsoft.NET\Framework\vxxxxxxxx\csc, where xxxxxxxx is the version of the .NET framework that you downloaded. You can either add csc to your computer's path so that you can type it directly at the command line or enter its full path (that is, C:\WINNT\Microsoft.NET\Framework\vxxxxxxxx\csc) each time you run it.

You need to know how to use C# for this example. Here, you'll create a SOAP server that will send a message to a client. In this case, you'll use SOAP to send information from the server to the client so that the client will know how to call a method named upper in the server, which the client will use to capitalize some text. To describe upper, you'll create a C# interface named IUpper, which is shown in Listing 18.1.

Example 18.1. A SOAP Server (ch18_01.cs)

public interface IUpper
{
    string upper(string text);
}

You can compile ch18_01.cs into its own DLL, ch18_01.dll, like this:

%csc /t:library ch18_01. cs

This creates ch18_01.dll, which gives you a consistent way of describing the upper method to both the client and the server.

Creating a SOAP Server

In the server, you'll implement the upper method so it can read the text the client sends you in a class named Capitalizer, capitalize that text by using the Java String class's ToUpper method, and send it back to the client. You do that like this:

using System;
using System.IO;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Serialization.Formatters.Soap;

public class Capitalizer : MarshalByRefObject, IUpper
{
    public string upper(string inText)

       {

           System.Console.WriteLine("Read this: \"{0}\"", inText);

           string outText = inText.ToUpper();

           System.Console.WriteLine("Sending this: \"{0}\"", outText);

           return outText;

       }
}

To actually send SOAP messages to the client, you'll use an object of the SoapFormatter class. In particular, you're going to let the client know how to access an object of your new Capitalizer class. Here's what that looks like in the server's main class:

public class ch18_02
{
    public static void Main()
    {
        HttpChannel channel = new HttpChannel(65111);

           ChannelServices.RegisterChannel(channel);


           Capitalizer capitalizer = new Capitalizer();


           ObjRef objref = RemotingServices.Marshal(capitalizer);


           FileStream filestream = new FileStream("soap.txt", FileMode.Create);


           SoapFormatter soapformatter = new SoapFormatter();


           soapformatter.Serialize(filestream, objref);

           filestream.Close();


           System.Console.WriteLine("soap.txt created. Press Enter to quit.");

           System.Console.ReadLine();
    }
}

In this case, you're writing a SOAP message that describes the upper method in a file, soap.txt, which the client will read and use. Listing 18.2 shows the full code for the server.

Example 18.2. A SOAP Server (ch18_02.cs)

using System;
using System.IO;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Serialization.Formatters.Soap;

public class Capitalizer : MarshalByRefObject, IUpper
{
    public string upper(string inText)
    {
        System.Console.WriteLine("Read this: \"{0}\"", inText);
        string outText = inText.ToUpper();
        System.Console.WriteLine("Sending this: \"{0}\"", outText);
        return outText;
    }
}

public class ch18_02
{
    public static void Main()
    {
        HttpChannel channel = new HttpChannel(65111);
        ChannelServices.RegisterChannel(channel);

        Capitalizer capitalizer = new Capitalizer();

        ObjRef objref = RemotingServices.Marshal(capitalizer);

        FileStream filestream = new FileStream("soap.txt", FileMode.Create);

        SoapFormatter soapformatter = new SoapFormatter();

        soapformatter.Serialize(filestream, objref);
        filestream.Close();

        System.Console.WriteLine("soap.txt created. Press Enter to quit.");
        System.Console.ReadLine();
    }
}

You can create the server, ch18_02.exe, by linking in the DLL file like this:

%csc /t:exe /r:ch18_01.dll ch18_02. cs

Creating a SOAP Client

In the client, you can read the SOAP message in soap.txt and use it to connect to the server. To do that, we'll need a SoapFormatter object, which we create and use to read in soap.txt like this:

using System;
using System.IO;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Serialization.Formatters.Soap;

public class ch18_03
{
    public static void Main()
    {
        HttpChannel channel = new HttpChannel();

           ChannelServices.RegisterChannel(channel);


           FileStream filestream = new FileStream ("soap.txt", FileMode.Open);

           SoapFormatter soapformatter = new SoapFormatter();
        .
        .
        .

Now use the SoapFormatter object to create an IUpper object named capper, and call the upper method of this object—which will call the upper method in the server remotely—to capitalize the text "Hello there.". Here's what it looks like in code:

using System;
using System.IO;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Serialization.Formatters.Soap;

public class ch18_03
{
    public static void Main()
    {
        HttpChannel channel = new HttpChannel();
        ChannelServices.RegisterChannel(channel);

        FileStream filestream = new FileStream ("soap.txt", FileMode.Open) ;
        SoapFormatter soapformatter = new SoapFormatter();

        try
        {
            IUpper capper = (IUpper)soapformatter.Deserialize(filestream);


               string outText = "Hello there.";

               System.Console.WriteLine("Sending this: \"{0}\"", outText);

               string inText = capper.upper(outText);
        .
        .
        .
    }
}

Now all you need to do is display what you got back from the upper method, as seen in the client application, ch18_03.cs, shown in Listing 18.3.

Example 18.3. A SOAP Client (ch18_03.cs)

using System;
using System.IO;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Serialization.Formatters.Soap;

public class ch18_03
{
    public static void Main()
    {
        HttpChannel channel = new HttpChannel();
        ChannelServices.RegisterChannel(channel);

        FileStream filestream = new FileStream ("soap.txt", FileMode.Open);
        SoapFormatter soapformatter = new SoapFormatter();

        try
        {
            IUpper capper = (IUpper)soapformatter.Deserialize(filestream);

            string outText = "Hello there.";
            System.Console.WriteLine("Sending this: \"{0}\"", outText) ;
            string inText = capper.upper(outText);
            System.Console.WriteLine("Read this: \"{0}\"", inText);

           }

           catch(System.Exception e)

           {

               System.Console.WriteLine(e.Message);

           }
    }
}

You can create the client, ch18_03.exe, like this:

%csc /t:exe /r:ch18_01.dll ch18_03. cs

Using the Server and Client

You're ready to use your two applications and let them communicate with a SOAP message. Start the server, ch18_02.exe, in one MS-DOS window, and it displays this text:

%ch18_02
soap.txt created. Press Enter to quit.

The SOAP message, which tells the client how to connect to the server and use the upper method, has now been written to the soap.txt file. To read that SOAP message, start the client application in another MS-DOS window. The client then sends the text "Hello there." to the server and gets that string back, capitalized:

%ch18_03
Sending this text: "Hello there."
Got this text back: "HELLO THERE."

The server also indicates what text it got and what text it sent back to the client:

%ch18_02
soap.txt created. Press Enter to quit.
Read this: "Hello there."

   Sending this: "HELLO THERE."

Here's the actual SOAP message that lets the server remotely connect to the upper method in the server:

<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas

      
   .microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org

      
   /soap/encoding/">
<SOAP-ENV:Body>
<a1:ObjRef id="ref-1"
xmlns:a1="http://schemas.microsoft.com/clr/ns/System.Runtime.Remoting">
<uri id="ref-2">/23186ad8_d9e2_4018_bcf1_
82cb2b4084c2/UgL21NCXPtdS5ON7digxzBfC_1.rem</uri>
<objrefFlags>0</objrefFlags>
<typeInfo href="#ref-3"/>
<envoyInfo xsi:null="1"/>
<channelInfo href="#ref-4"/>
</a1:ObjRef>
<a1:TypeInfo id="ref-3"
xmlns:a1="http://schemas.microsoft.com/clr/ns/System.Runtime.Remoting">
<serverType id="ref-5">Capitalizer, ch18_02,
Version=0.0.0.0, Culture=neutral, PublicKeyToken=null</serverType>
<serverHierarchy xsi:null="1"/>
<interfacesImplemented href="#ref-6"/>
</a1:TypeInfo>
<a1:ChannelInfo id="ref-4"
xmlns:a1="http://schemas.microsoft.com/clr/ns/System.Runtime.Remoting">
<channelData href="#ref-7"/>
</a1:ChannelInfo>
<SOAP-ENC:Array id="ref-6" SOAP-ENC:arrayType="xsd:string[1]">
<item id="ref-8">IUpper, ch18_01, Version=0.0.0.0,
Culture=neutral, PublicKeyToken=null</item>
</SOAP-ENC:Array>
<SOAP-ENC:Array id="ref-7" SOAP-ENC:arrayType="xsd:anyType[2]">
<item href="#ref-9"/>
<item href="#ref-10"/>
</SOAP-ENC:Array>
<a3:CrossAppDomainData id="ref-9"
xmlns:a3="http://schemas.microsoft.com/clr/ns/System.Runtime.
Remoting.Channels">
<_ContextID>1345320</_ContextID>
<_DomainID>1</_DomainID>
<_processGuid id="ref-11">f0a6d250_b75d_47be_8df4_5ed8e461af6b</_processGuid>
</a3:CrossAppDomainData>
<a3:ChannelDataStore id="ref-10"
xmlns:a3="http://schemas.microsoft.com/clr/ns/System.Runtime.
Remoting.Channels">
<_channelURIs href="#ref-12"/>
<_extraData xsi:null="1"/>
</a3:ChannelDataStore>
<SOAP-ENC:Array id="ref-12" SOAP-ENC:arrayType="xsd:string[1]">
<item id="ref-13">http://209.177.24.57:65432</item>
</SOAP-ENC:Array>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>

This example shows how C# and .NET use SOAP messages behind-the-scenes. Now let's take a look at a SOAP example in Java.