Home > Articles

  • Print
  • + Share This

XML—Extensible Markup Language

XML provides the foundation for enabling inter-application communication between disparate software systems. XML is a general-purpose markup language which allows developers to structurally describe data independent of specific software applications. The ability to independently describe data facilitates information exchange across organizations by making software applications easier to design, build, deploy, and maintain. Since XML is self-describing, the applications that use it to communicate do not need to worry about specific formatting.

It is easy to learn how to create and read XML documents. They are similar in appearance to HTML and typically include standard English terminology instead of code language. Listing 3.1 shows an XML document that describes several pets found in a typical family household.

Listing 3.1  An XML Description of Household Pets

<household>
    <pets>
        <pet type="cat">
            <breed>Domestic Short Hair</breed>
            <name>Daisy</name>
            <color>Brown</color>
            <weight>16 pounds</weight>
        </pet>
        <pet type="cat">
            <breed>Domestic Short Hair</breed>
            <name>Hana</name>
            <color>BrownishBlack</color>
            <weight>6 pounds</weight>
        </pet>
        <pet type="dog">
            <breed>Australian Shepard</breed>
            <name>Nellie</name>
            <color>Blue Merle</color>
            <weight>24 pounds</weight>
        </pet>
    </pets>
</household>

The listing above shows that XML documents are comprised of elements and attributes to create a structured representation of data. This particular set of data describes three household pets, two cats and a dog, and contains four pieces of information for each pet. The <household> element is the root element and contains all other elements and attributes in the household pet document. The <pets> tag is a collection of individual <pet> tags, each describing an individual pet. The type attribute on the <pet> element allows us to further describe a pet using simple name-value pairs. Each XML tag can have zero or more name-value pairs to indicate the specific properties of the tag instance.

When authoring your own XML documents there are a few key guidelines to follow in order to create well-formed XML:

  • Each element must have an end tag.

  • Elements cannot overlap.

  • Attribute values must be enclosed in quotation marks.

  • Documents must have a unique root node.

By following these four simple rules you can create highly descriptive and well-formed documents that represent a variety of business data. Many companies have already published XML schemas for use in a specific industry or with specific types of data.

XML and HTML

As shown above, XML is used to describe the content of data. Contrast this to HTML, Hypertext Markup Language, which details how to display data in a web browser. Using HTML, we can tell a browser to display data using a particular font type and size, or act as a hyperlink for site navigation. Using XML together with HTML, we can extend the value of business data by separating content from presentation. This allows a single set of data to be reused in multiple presentations and a single presentation to display multiple sets of data.

One of the benefits of using a standard markup language such as XML to represent our data is that we can easily integrate data from different sources. For example, we can aggregate content from relational databases, spreadsheets, text files, or legacy corporate applications, into a single XML document. This document can then be merged with HTML for robust presentation in a web browser. Instead of displaying in a web browser, we could also deliver the XML to a software application in a different enterprise thus providing a link between the two standalone applications and producing a truly distributed software system.

As we shall see shortly, XML is the technology which provides the infrastructure for distributed software concepts like Simple Object Access Protocol (SOAP) and Web services.

NOTE

A complete discussion of XML is beyond the scope of this chapter, as entire books have been written about XML. Our intention isn't to create XML experts but instead merely to provide a basic introduction to XML. For those interested in learning more please visit the following web links for additional information on XML:

XSD Schema

One question we need to address is, "How do we define our own XML document and data structures?" The answer is via an XSD schema. The XML Schema Definition (XSD) is a language, based on XML, that allows us to define the structure and data types for XML documents. When we author an XSD schema we actually use a set of elements, attributes, and data types that conform to the World Wide Web Consortium (W3C) XSD Schema Definition language. This specification serves as the blueprint for authoring XSD schemas, and in turn, schemas serve as blueprints for XML document instances.

XSD schemas are a bit more difficult to create than simple XML documents, since XSD schemas serve as blueprints for XML documents. The relationship between XSD schemas and XML documents is similar to that between classes and objects. XML documents are instances of XSD schemas, just as objects are instances of classes in object oriented programming.

Since XSD schemas are defined using XML, all schemas must have a top-level node. The W3C specification states this node must be the <schema> element and its definition must include the www.w3.org/2001/XMLSchema namespace.

NOTE

According to the W3C standards body, "An XML namespace is a collection of names, identified by a URI reference, which are used in XML documents as element types and attribute names. XML namespaces differ from the `namespaces' conventionally used in computing disciplines in that the XML version has internal structure and is not, mathematically speaking, a set." See www.w3.org/TR/REC-xml-names/ for more information.

Since <schema> is the top-level node, all elements and attributes used to author a schema must appear between the begin and end <schema> tags. The specification also describes the exact elements and attributes authors may utilize to develop XSD schemas.

Let's work by example. Listing 3.2 shows the XSD schema that defines the household pet XML document that was studied earlier in the chapter.

Listing 3.2  Household Pets XSD Schema

<xsd:schema id="household" targetNamespace="" xmlns="" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-
microsoft-com:xml-msdata">
 <xsd:element name="household" msdata:IsDataSet="true">
   <xsd:complexType>
    <xsd:choice maxOccurs="unbounded">
     <xsd:element name="pets">
       <xsd:complexType>
        <xsd:sequence>
         <xsd:element name="pet" minOccurs="0" maxOccurs="unbounded">
           <xsd:complexType>
            <xsd:sequence>
             <xsd:element name="breed" type="xsd:string" minOccurs="0" 
msdata:Ordinal="0" />
             <xsd:element name="name" type="xsd:string" minOccurs="0" 
msdata:Ordinal="1" />
             <xsd:element name="color" type="xsd:string" minOccurs="0" 
msdata:Ordinal="2" />
             <xsd:element name="weight" type="xsd:string" minOccurs="0" 
msdata:Ordinal="3" />
            </xsd:sequence>
            <xsd:attribute name="type" type="xsd:string" />
            <xsd:attribute name="pets_Id" type="xsd:int" use="prohibited" />
           </xsd:complexType>
         </xsd:element>
        </xsd:sequence>
        <xsd:attribute name="pets_Id" msdata:AutoIncrement="true" 
type="xsd:int" msdata:AllowDBNull="false" use="prohibited" />
       </xsd:complexType>
     </xsd:element>
    </xsd:choice>
   </xsd:complexType>
   <xsd:unique name="Constraint1" msdata:PrimaryKey="true">
    <xsd:selector xpath=".//pets" />
    <xsd:field xpath="@pets_Id" />
   </xsd:unique>
   <xsd:keyref name="pets_pet" refer="Constraint1" msdata:IsNested="true">
    <xsd:selector xpath=".//pet" />
    <xsd:field xpath="@pets_Id" />
   </xsd:keyref>
 </xsd:element>
</xsd:schema>

As we can see, the schema (Listing 3.2) is more complex than its instance (Listing 3.1). Our household pet schema, like all schema, begins with the <schema> element. Looking through the listing we find <element> declarations for our household, pets, pet, breed, name, color, and weight elements, as well as an <attribute> element that defines the type attribute of the <pet> element. Properties such as MinOccurs and MaxOccurs define the minimum number of times a tag can occur. For instance, the <pet> tag has a MinOccurs value of 0 and an unbounded MaxOccurs value, indicating that for any household, there can be 0 or more pets.

NOTE

The XSD schema in Listing 3.2 was generated using the Microsoft .NET Framework XML schemas support utility (xsd.exe). This program allows solution developers to efficiently interoperate between schemas and .NET classes, and is available in the Microsoft .NET Framework SDK.

Up to this point we've discussed XML and studied a simple document instance. We've learned how the separation of content and presentation is important in bringing together data from different sources. We talked briefly about XSD Schema and looked at an example declaration for our household pet example. In the next section, we will discuss technologies that extend XML to create a new set of tools that facilitate inter-application communications.

  • + Share This
  • 🔖 Save To Your Account

Related Resources

There are currently no related titles. Please check back later.