Abstract

Web-based services can be invoked using Web technologies, and provide results in some format. Web-oriented services often provide HTML as the result format, which is not well suited for processing. Application-oriented service often provide XML as the result format, which is easier to process and can be structured specifically for the needs of a service. One of the key questions when designing and using XML-based services is the underlying data model of the XML, and in this lecture we will

Service Interfaces

• HTML is appropriate for pre-formatted content
  • works well if the content should be displayed
  • works well if the pre-formatting fits the service user's needs
• Service interfaces should be carefully designed
  • anticipating and supporting a wide variety of service usages
  • minimize the number of assumptions about service users
  • service users should be supported by documentation (about the relevant issues)
  • expect the service to change

What is a Service?

• Service is a very broad term
  • in a very abstract sense, it may be anything you can get somebody else to do
  • in a very narrow sense, it may be some interface which your application can use
  • getting from one to the other is difficult, error-prone, and uncharted terrain
• Service modeling goes through a number of stages
  1. for some reason, something is identified as being a candidate for becoming a service
  2. based on document engineering, a document-based interface is modeled
  3. the technical implementation of the interface (e.g., HTTP vs. SOAP) has to be decided
  4. the input and output data models have to be mapped to that interface technology
  5. a concrete interface has to be built based on the interface technology (e.g., URI query string vs. XML)
  6. the interface description should be compact and self-contained

Document Engineering

• Document engineering helps in analysis and design
  • the design support is limited to the abstract model
  • the lower level issues are not yet integrated
• Descriptive vs. Prescriptive
  • document engineering can be used to describe an existing landscape
  • the result is representation of document flows in an IT system
  • the existing landscape may not be well-designed
  • prescriptive methods help to identify and eliminate process problems

What is a Service? (2nd Try)

• Services often are part of a bigger picture
  • they are designed as reusable components in a service-oriented environment
  • making services as self-contained as possible can be difficult
  • making services self-contained turns the service landscape into components
• Proposed Definition: A service is an independently reusable unit of functionality
  • if a service cannot be used without other services, it is not a service
  • only true services can be outsourced without causing side-effects

System Models

• IT landscapes are complex systems with complex data models
  • services often are based on a subset of the complete data model
  • service interfaces should be limited to this subset
  • the documentation should be limited to this subset as well
• The subset is a model in itself, tailored for the service
  • it should contain all information relevant for the service
  • it may contain additional information about the bigger picture
  • additional services may support following loose ends
  • the service should be usable without having to rely on additional services

System and Exchange Models

Model Models

• System models in most cases are not XML-oriented
  • Unified Modeling Language (UML) is commonly used for modeling complex systems
  • UML is tailored for modeling and building software systems
• Exchange models often are XML-oriented
  • the syntax of the exchanged data is XML
  • the constraints (on a syntactic level) are expressed in an XML schema
  • the semantics are described by additional documentation
• Universal Business Language (UBL) is a library of exchange models
  • built around frequently used business document components
  • fosters cooperation by providing a common set of components
  • has a well-defined process for creating new components

XML as Data Model

• XML is just a syntax for trees
  • without an underlying model, XML is useless
  • the model must describe constraints and semantics
• Constraints are often described using declarative languages
  • declarative languages are portable and have well-defined semantics
  • constraints operate on a low level of semantics (validation-oriented)

<?xml version="1.0" encoding="UTF-8"?>
<文書 改訂日付="１９９９年３月１日">
 <題>サンプル</題>
 <段落>これはサンプル文書です。</段落>
 <!-- コメント -->
 <段落>会社名</段落>
 <図面 図面実体名="サンプル" />
</文書>

XML Semantics

• The meaning of XML content is not part of XML
  • XML provides the exchange format
  • parsing and validation check for interface-level conformance
  • model-level interpretation works with the data on the semantic level
  • integrating it into the local model fully exploits the data

Supporting Reuse

• Using services should be supported as good as possible
  • XML schema(s) help in validating the data
  • example instances help in knowing what to expect
  • documentation helps in understanding the data
• There are many different ways to use XML
  • organizations should have schema and instance design guidelines
  • non-institutional services should focus on a good service
  • generated mappings often are not the best way to go
• XML schemas can be created automatically
  • database tables can be easily mapped to XML trees
  • more complex structures can also be mapped generically
  • generic mappings often result in bad schemas
  • system internals should not be exposed in the interface
  • interfaces should be designed to survive a complete internal re-design

Good XML vs. Bad XML

• Relevant information should be structured by markup
• String-oriented structures are more brittle and harder to process
• Validation works much better on markup

  <topics>
   <topic name="rdf" weight="0.6"/>
   <topic name="shiq" weight="0.6"/>
   <topic name="owl" weight="0.8"/>
  </topics>

  <field type="bibtex:topic">rdf[0.6] shiq[0.6] owl[0.8]</field>

XML Modeling and Design

• XML started as a syntax with no model
  • models developed as required by processing requirements (Infoset, PSVI, XDM)
  • no conceptual model has been successful so far
• Designing XML vocabularies is more an art than a science
  • openness/extensibility for opening a service for unforeseen usages
  • versioning strategies for independent evolution
  • mapping non-trivial data models to XML structures
  • visualizing XML-oriented data models
  • documenting XML-oriented data models

XML Interfaces

• Interfaces are based on use case assumptions
  • HTML for displaying data in a browser
  • XML for platform-independent data structures
  • JSON for JavaScript-oriented applications (AJAX)
• XML is the wire format of many services
  • often, there is not even a schema (some sample interfaces)
  • if there is a schema, it may be generated from some model
  • if it is hand-written, it often is a very simple schema
  • XML Schema seems to be inappropriate to be adopted by XML users
• XML is much better than HTML
  • HTML often requires techniques similar to screen scraping
  • XML often provides the structures readily available for processing
  • what they mean and what is possible may still be hard to find out

PHP and XML

• XML support is becoming ubiquitous
  • PHP4 requires additional modules to be installed
  • PHP5 has built-in support for working with XML documents
• SimpleXML is the standard package for XML access in PHP
  • XPath can be used to select parts of the document
  • PHP-style access can be used for accessing parts of the document
  • the document can be updated by changing contents and structure
• XSLT is not yet part of the standard PHP
  • PHP extensions are available and can be compiled into PHP

SimpleXML vs. SDO

• Service Data Objects (SDO) provide an abstraction layer
• SDOs may be generated from database queries or XML
  • they may be used to hide the service interface implementation
• SDO provides a tree ob objects (a containment hierarchy)
  • objects may also have non-containment references

SimpleXML Basics

• SimpleXML introduces a new class of objects to PHP
  • XML objects provide different ways of accessing parts of the tree
  • XML objects are created by parsing XML markup
  • markup may be read from a string or from a file
• Parsing may produce errors (non-XML data)
  • robust applications have to include error handling

$snoopy->fetch("http://dret.net/lectures/services-fall06/a/4/query.php?format=xml&author=" . urlencode($formval_author));

$xml = new SimpleXMLElement($snoopy->results);

XML Path Language (XPath)

• XPath is one of the most convenient XML tools
  • used in different XML technologies
  • provides a compact and intuitive notation for selection XML nodes
  • supports many different ways of selecting XML nodes
• XPath provides the appropriate functionality for XML selection
  • traversing the tree can be done by other means
  • programming non-trivial XPaths without XPath can be a lot of work
• XPaths need to take the schema into account
  • XPaths always contain assumptions about the schema
  • //person/prename ≟ //person/prename[1] is undecidable without the schema
  • XPaths can be fixed more easily than code

SimpleXML XPath Support

• XPaths returning other things than node sets do not work
  • the current implementation of XPath seems to be buggy
  • if something does not work, it may very well be SimpleXML's fault

<ul>
<?php

include "Snoopy.class.php";
$snoopy = new Snoopy;

import_request_variables("g", "formval_") ;

$snoopy->fetch("http://dret.net/lectures/services-fall06/a/4/query.php?format=xml&author=" . urlencode($formval_author));

$xml = new SimpleXMLElement($snoopy->results);

foreach ($xml->xpath('//title[@type = "sharef:primaryTitle"]') as $title) {
   echo '<li>' , $title , '</li>'; }

?>
</ul>

SimpleXML Objects

• XPath is the most natural way to access XML documents
  • for non-XML experts, XPath may be too complicated
  • for simple selections, writing PHP code maybe acceptable
  • SimpleXML objects also provide tree-walking methods
• SimpleXML does only support very basic operations
  • children() returns the children of the given object
  • attributes() returns the attributes of the given object
  • output does not output the string value, it only prints the immediate text children
• Use SimpleXML access when XPath is not enough
  • XPath is useful but limited (XPath 2.0 changes this)
  • combining XPath and PHP → PHPish XSLT

Potential Problems

• SimpleXML has been designed with fixed schemas in mind
  • it assumes that elements occur in a predefined order
  • repeatable elements are ok, optional elements are very hard to handle
• SimpleXML's object model requires a lot of coding
  • generates a lot of code for non-trivial XML processing
  • the code quickly becomes hard to maintain
• Using SimpleXML's native access methods can be problematic
  • avoid using SimpleXML's native access methods whenever possible
  • very simple and rigid schemas may be an exception
  • in general, try to use as much XPath evaluation as possible

Adding Nodes

• Methods for simple tree manipulations
  • addChild() adds a child node to an element
  • addAttribute() adds an attribute node to an element
  • no control over where the added children go (very data-oriented approach)
• It is impossible to move or remove nodes
• SimpleXML is too simple to be of any practical use
  • SimpleXML should be used for read-only access
  • read-only access should be done by XPath whenever possible

XSLT for Updating XML

• XML can be updated using XSLT (updating is a transformation)
• XSLT provides useful features for manipulating XML
  • copying through XML unmodified is easy to do
  • additional templates can make alterations
  • PHP data can be passed to XSLT as stylesheet parameters
• XSLT is much slower than in-memory manipulation of XML objects

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 <xsl:template match="/ | node() | @*">
  <xsl:copy>
   <xsl:apply-templates select="@* | node()"/>
  </xsl:copy>
 </xsl:template>
</xsl:stylesheet>

PHP and XML

• PHP can be used as glue for Web-based Services
• SimpleXML enables easy access to XML in PHP
• SimpleXML is very simple and very new
• XML-oriented Web-based Services can extract XML data