Well, here we are at the third and
final article in this series. In the first
article, I talked about XML in general and explained the components that
make up an XML document. I placed a heavy emphasis on the fact that XML is
really a definition of tag semantics, not a definition of tags, like
HTML. The tags you use and what you populate the tags with is up to you. As long
as you follow the rigidity of XML, you'll be fine. The last sections of the
first article dealt with reading, manipulating, validating, and transforming
The second article discussed bringing XML to the next level, which is application-to-application (A2A), with Web Services being the enabler in this paradigm. While many XML standards provide security, message delivery, service advertisement, and subscription, there is no part of XML that actually does these things. And if you already have functionality such as encryption, why not just snap that into your XML infrastructure?
In this article, I'm going to get a little less scholastic and a little more hands-on. I'll show you a pseudo system and some of the code that could be used to support this system when it communicates with other systems. A good friend of mine, Steve Bos, who I have worked with for years, is an excellent programmer and has created the code in this article. He has several years of hands-on experience with XML, utilizing many of the technologies already discussed.
It's All in the Design
Let's start with a simple system. We are going to be
reviewing a hotel reservation portal. There are three external entities: the
customer, the hotel, and the credit card authorization firm. The portal provides
a nice interface for what can be a batch and/or interactive system. Its all in
The hotel may send pricing information to the portal either at a fixed interval (such as nightly or weekly) or when there are price changes. Availability information may also be sent in batch, or the portal can interactively query the hotel to see if there are rooms available when a user makes a request. While we will not code every possibility, it is important to look at different possibilities in the hopes that you come with some XML ideas on your own.
Tools Transform the Design
In the code examples that follow, Steve used Micosoft's C# (pronounced "C sharp") because of the vast array of utilities Microsoft has made available to quickly build XML/Web Service applications. Universal Description, Discovery, and Integration (UDDI) and Web Services Description Language (WSDL) definitions are created with the click of a button, which takes the complexity out of these services. Simple Object Access Protocol (SOAP) messages complement UDDI and WSDL by connecting to remote Web Services. I'll show you what a SOAP message should look like.
Let's take a look at a SOAP message. (The text was
formatted for readability. If this were real XML, you would not see any tabs or
carriage returns/line feeds.) This SOAP message sends a request to the hotel on
behalf of the user. It includes the hotel ID, client name, room options, and
some payment information.
Figure 1: This sample SOAP message requests hotel availability
Let's examine this code.
The standard first line indicates that we are using XML Version 1.0 and that the text encoding is UTF-8.
The next few lines set up some "run-time" properties of the document. A nice thing about XML is that you can follow the convention of anyone on the Internet in terms of naming your XML data elements. For our SOAP envelope, we will be using the standards from the Universal Resource Indicator (URI) http://www.w3.org/2001/XMLSchema-instance (name space xmlns). We will also be using the XML Schema Definition (xsd) from http://www.w3.org/2001/XMLSchema and the SOAP definition from http://schemas.xmlsoap.org/soap/envelope/.
The SOAP payload begins with
As with other XML standards we reviewed, all elements must be closed out. The last three lines of the SOAP message close out the Execute, SOAP:Body, and SOAP:Envelope elements.
The intended recipient of a SOAP message is a Web Service, which supplements a Web server. When a new SOAP message comes in, the Web Service automatically parses through the message and sends the parameters to an object that has the business logic programmed into it. This object could update database tables, check availability of a room, call out to external credit card authorization companies, or anything else that is programmatically possible. In our example, we are going to check the availability of the room and then confirm that the funds are available on the credit card. Once this is complete, we will return the following XML to the program that initially submitted the XML, which is waiting for a response.
Figure 2: This SOAP message is a response to the original
This response looks a little different from the request because we included the HTTP headers. HTTP/1.1 200 OK indicates that the document you were posting to was found and that the operation completed successfully. An HTTP/1.1 404 File Not Found would indicate that the Web Service you are trying to publish was not found. You would see this message if you went to a URL and the document you entered was not found on the server. The remaining lines of the HTTP headers indicate the text encoding type, which matches the UTF-8 that we had in our request, and the length of the response.
We start the XML portion the same way we started the request. The XML version and encoding format is indicated. The SOAP envelope element is opened with references made to the same URIs as the request.
The SOAP body element is opened as well, and it uses an interesting parameter. The ExecuteResponse element has the same URI as the Execute element in the request. This is because the same Web Service that is accepting the request is then creating the response.
First and foremost, WSDL defines a Web Service. In
order to define this Web Service, it needs to describe the "binding," or what
type of message to send and where (remember, a Web Service can operate from
email). It also defines the port and the message that will traverse the port. A
message is a series of parameters to be either received or sent, and the WSDL
defines the specific parameters in a message and the format of those parameters.
This sounds both somewhat difficult and easy at the same time. You can see the hierarchy from the definition I provided above, but coming up with the syntax may be tedious. This is why you would almost never define WSDL yourself. Many packages, including C#, provide the run-time engines that create the WSDL for you. Let's look at an example that would define the reservation service that our SOAP message would be sent to.
Figure 3: This code defines the reservation service that our SOAP message is sent to.
As in our SOAP requests, the first section relates to the version of XML we
are using and the encoding method. We then reference external naming schemas,
including one of our own located at http://192.168.1.1/ReservationPortal/.
In WSDL, the subcomponents are defined first and the Web Service itself is defined last. The first definition is a schema. The first schema we define is ReserveRoom, a series of variables required to reserve a room. Look back at the SOAP example, and you'll see that the variable names are slightly different, but the schema definition matches what we are sending via our SOAP request.
The minOccurs and maxOccurs tags in the schema allow you to define how many times an element is present. Setting both of these values to "1" mandates that this variable be present only once. We could complicate this WSDL by adding a GuestNames tag that could have one to 100 names, depending upon the size of the room. So your minOccurs would be "1" and your maxOccurs would be up to "100."
In this WSDL, we define a schema for both the input and the output. This allows us to "code it once, call it twice" as my COBOL instructor used to say.
Moving on down the example, we find the Message element, a simple element that indicates we are using the ReserveRoom schema for our ReserveRoomSoapIn message and the ReserveRoomResponse schema for our ReserveRoomSoapOut message. So now we have bound a schema to a message, but we're not done yet.
The next step in the WSDL is defining the ports that may be available for a Web Service. A complex Web Service would have many different ports. In our simple example, we kept the port to simply reserving a room, or ReserveRoom. As you can see from the example, the input message (SOAP in our case, as opposed to email) expects ReserveRoomSoapIn, and we will be outputting ReserveRoomSoapOut. You should recognize both of these from when we defined them as messages.
The binding area is complicated, as it defines what we expect and the order in which we expect it. Because you can have several SOAP messages that constitute a Web Service transaction, the binding indicates when and how to expect those message and in what format. It also describes what you should expect to be returned, which is important if there are several messages being sent to you.
Finally, we define the Web Service itself, including the address, and reference the binding that we just defined. I don't think there is any question as to why you would want an application to automatically generate the WSDL.
As explained in the last article, UDDI provides a
searchable directory of companies that upload their business classification
information. UDDI encompasses uploading the information as well as searching it.
We're going to step away from the hotel reservation and perform a simple query that looks for information on Microsoft. Here's the code:
UddiConnection CONNECTION = new UddiConnection (http://test.uddi.microsoft.com/inquire);
FindBusiness BUSINESS = new FindBusiness("Microsoft");
BUSINESS.CategoryBag.Add(CommonCanonical.NtisGovNaics1997,"51121","NAICS: Software Publisher");
BusinessList BUSINESSLIST = fbBUSINESS Send(CONNECTION);
This code excerpt is from C#, and as you can see, it is relatively easy to comprehend. The first line defines a new UDDI connection to the Microsoft Test server, which is specified by the URL. The second line of code stipulates the search criteria that we are looking for. In this example, we are looking for a business named Microsoft. The third line allows us to stipulate a series of qualifiers. We want to ensure that our search is case-sensitive and does not find "microSOFT." The fourth line hones in on the business classification standard (NtisGovNaics1997) and stipulates that we are looking for a software publisher. The final line initiates the connection and retrieves the information into the BusinessList object for your use.
Relatively simple, isn't it? Of course, the devil is in the details and what you do with that information once you have it. In our example, we know the company name that we are looking for. But what if we don't, and we are looking for a type of business? How can we discern the good from the bad and the ugly? And will we even be able to do this when we search for Hotel and receive hundreds of results?
The Future of XML
There will be many degrees of XML acceptance. At
present, I see the landscape of XML as a collection of islands linked by shallow
narrows that anyone can walk across at will. At each island is a different XML
technology that solves a different problem. How many islands you travel to
depends upon your ambitions and your specific business problems.
On the fringe of these islands, a super island will be established that has bridges and a hefty admission fee. These will come to you in the form of frameworks or add-ons to your business applications. They'll carry a significant cost but will be all-encompassing. Instead of studying standards and downloading SDKs and toolkits, you'll be able to go to the super island, which will provide full XML integration with all the functionality that the standards define.
There will also be an isolated island of third-party vendors. They will operate the Web Services, perform the UDDI registration and searching, define the WSDL to use your Web Services, and transport the SOAP messages to complete complex transactions. Aside from transaction and subscription fees, the process will be relatively painless, and you'll never have to leave your island.
Nonetheless, you will most likely have to get your feet wet with XML. It is a mutating technology that seems to be touching everything that is front and center right now. You now have a better understanding of XML and the superfluous technologies that extend it so that, when the time comes, you do not drown.
Since publishing the first article in this series, MC
Press Online has exploded with excellent in-depth articles on XML and its
surrounding technologies. In addition to these articles, author Steve Bos, whose
code has been introduced here, has a full-length book in the works. Expect to
see it available at the MC Press store
around May. This book
will provide more details on the technologies introduced here and apply them to