Unit-5

Technologies for SOA:

1
 Unit-5: Technologies for SOA
• XML: Namespaces, schemas, processing/passing models
• SOAP: messages, elements, attributes and processing
model, message exchange types ,HTTP binding
• WSDL: containment structure, elements of abstract
description, elements of the implementation part,
logical relationships, SOAP binding
• UDDI Registry: Basic data model, tmodel, categorization
and identification schemes, binding template, use of
WSDL in the UDDI registry

2
 XML
• XML is probably the most important pillar of Web
Services.
• a means for passing information between the
service provider and service consumer.
• XML also forms the basis for
– WSDL
– SOAP
– UDDI (Universal Description, Discovery, and
Integration), which is used to publish and discover a
Web Service, is also based on XML.

3
4
 XML
• Overview of the XML language.
• Concept of namespaces
• Schemas
• Various models you can use for parsing, processing,
creating, and editing an XML document.

5
 XML
• XML uses tags (Similar to HTML).

• HTML tags indicate how the data should be

presented or displayed

• XML tags are used to describe what the data is

• HTML has fixed set of tags

• XML is extensible (new tags can be defined)

6
 XML
 Open tags Example: <name>

 Close tags Example: </name>

 Elements Example: <name>Blue Device</name>

 Attributes Example: <price currency="US">

<product>
<name>Blue Device</name>
<price currency="US">99.99</price>
</product>
7
8
 XML contd.
 This figure shows that a basic XML document consists of a top
element. This top element may consist of data (the payload),
an attribute, any number of other elements in a recursive
manner.

 A sample portion of a simple XML document

1 <address country=“USA”>
2 <name>John Smith</name>
3 <street>43 Walcut St</street>
4 <city>Dublin</city>
5 <state>Ohio</state>
6 <postal-code>45561</postal-code>
7 </address>
9
 XML contd.
The XML contains a top element named address
has a single attribute -- country.
has four child elements
 name of the person, street address, the city, and the postal
code.
Each of these child elements has data

10
 XML contd.
Grammar of an XML document
DTD
XMLSchema
 NameSpace is used to
 avoid the tag name collisions
extend the use of vocabulary defined in one specific
domain to other

11
 Namespaces
XML Namespaces increase reuse across multiple WSDL
documents and across the enterprise and beyond

An XML namespace comprises a collection of

element type names
attribute names

A namespace is identified by a URI reference.

As an example, consider the three different

namespaces shown in Figure 11.3.
12
Namespace examples

13
 Namespaces
The element's name and the address of the namespace
(http://myCompnny.com/hr/employees) refer to the names and addresses of
the employee' of the company (myCompany).

The identical element type name of the namespace

http://mCompany.com/sales/orders holds the name for the supplier for
myCompany

myCompany's tennis club management also decides to store their member data
in XML format with the element types of name and address.

A namespace is declared through the reserved namespace attribute xmlns or

through an attribute that is prefixed with "xmlns:" and followed by a name
without a colon.

The namespace attribute can be provided in any element of an XML document.

14
 Namespaces
An example of a namespace prefix declaration is shown here: <address
xmlns:myC=“http://myCompany.com/hr/employees”>

we can use the prefix to qualify any name of the element.

<myC:address xmlns:myC=“http://myCompany.com/hr/employees”>
<myC:name>John Smith</myC:name>
<myC:street>43 Walcut St</myC:street>
<myC:city>Dublin</myC:city>
<myC:state>Ohio</myC:state>
<myC:postal-code>45561</myC:postal-code>
</myC:address>

15
Namespaces

16
 Namespaces
another way to declare and use a namespace without a prefix.
It is called a default namespace. Example
<address xmlns= "http//myCompany.com/hr/employees" >
All subordinate elements are assumed to belong to the default
namespace, provided they are not prefixed

<address xmlns= “http://myCompany.com/hr/employees” >

<name>John Smith</name>
<street>45 Walcut St</street>
<city>Dublin</city>
<state>Ohio</state>
<postal-code>45565</postal-code>
</address> 17
 XML Schema
An XML schema
defines the grammar
and structure of XML
instance documents of
a particular type.
An XML schema is
itself an XML instance.
The top element of a
schema is named
"schema."
Its namehttp://www.w3.org/2001/XMLSchema
space is: 18
 XML Schema
The sub elements of the top element schema are:
element
 This sub-element declares an element used in an XML
instance. A declaration includes the name and type.
attribute
This subelement declares an attribute used in an XML
instance. A declaration includes the name and type.
SimpleType
This subelement defines a simple type. A simple type in
an XMIL schema is a built-in type, a list of simple types, a
union of simple types, or a restriction of a simple type.
19
 XML Schema
Other sub elements of the top element schema are:
ComplexType
subelement defines a complex type.
typically contains XML elements and attributes. The elements and
Attributes appearing or referenced within the type definition are
declared within the type definition.
include
This subelement is used to import an element definition defined in
another schema. The other schema must belong to the same XML
namespace.
import
This subelement is used to import an element definition defined in
another schema that belongs to a different namespace. Through the
use of include and import, reuse is possible with XML schema
20
definitions.
 XML Schema
The complexType can have any
number of attributes but can
have only one of the following:
 sequence, all, choice, or
group.
Under sequence, we can have
any number of elements, but
these elements must appear in
the specific order.
In case of all, we can have any
number of elements. All these
elements must appear, but the
order is not important.
In case of choice, only one of
the allowed elements can
21
appear in an XML instance.
 XML Schema example
Listing 11.5: An example of a complexType .
<xsd:complexType name="nameType">
<xsd:sequence>
<xsd:element name="title" type="xsd: string">
<xsd:element name="firstName" type="xsd:string">
<xsd:element name="middleName" type="xsd:string">
<xsd:element name="lastName" type="xsd:string ">
</xsd:sequence>
</xsd:complexType>

22
XML Schema example

23
XML confirms to Schema

24
<?xml version="1.0" encoding="UTF-8"?>

<shiporder  orderid="889923"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="shiporder.xsd">
  
<orderperson>John Smith</orderperson>
   <shipto>
     <name>Ola Nordmann</name>
     <address>Langgt 23</address>
     <city>4000 Stavanger</city>
     <country>Norway</country>
   </shipto>
   <item>
     <title>Empire Burlesque</title>
     <note>Special Edition</note>
     <quantity>1</quantity>
     <price>10.90</price>
   </item>
   <item>
     <title>Hide your heart</title>
     <quantity>1</quantity>
     <price>9.90</price>
   </item>
</shiporder>

25
<?xml version="1.0" encoding="UTF-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="shiporder">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="orderperson" type="xs:string"/>
      <xs:element name="shipto">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="name" type="xs:string"/>
            <xs:element name="address" type="xs:string"/>
            <xs:element name="city" type="xs:string"/>
            <xs:element name="country" type="xs:string"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
26
      
      <xs:element name="item" maxOccurs="unbounded">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="title" type="xs:string"/>
            <xs:element name="note" type="xs:string" minOccurs="0"/>
            <xs:element name="quantity" type="xs:positiveInteger"/>
            <xs:element name="price" type="xs:decimal"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
    <xs:attribute name="orderid" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

</xs:schema>

27
 XML Processing and Parsing Models
the service provider and service consumer application
exchange data through XML instance documents.
Five choices for XML processing models:
SAX The Simple API for XML is an event-driven parsing
/programming model.
StAX The Streaming API for XML provides a pull, event-
based parsing /programming model.
DOM The Document Object Model provides an in-memory
tree transversal programming model.
XML data-binding Provides an in-memory Java content
class-bound programming model.
XSLT Extensible Stylesheet Language Transformation
provides a template-based programming model. 28
 XML Processing and Parsing Models
SAX, DOM more common. StAX catching up.
JAXP APIs (Java APIs for XML Processing) – SAX, DOM, StAX
JAXB technology - XML data binding
The processing includes
Parsing the XML document for processing
Making changes
Creating a new XML document
Deserialization or Unmarshalling Parsing an XML document into an
equivalent data structure
Serialization or Marshalling writing a data structure to an XML
Document
DOM supports both Deserialization and Serialization
SAX supports only Deserialization
29
 SAX Processing Model
There are two ways of applying business logic when
using SAX parsing:
First Approach:
The business logic is invoked as soon as the information is
extracted or after minimal aggregation. This approach is
referred to as stream processing
The document can be processed in one step.
Second Approach:
invokes the business logic after complete parsing and
consolidating the extracted information.
Needs two steps to complete the processing of an XML
document.
31
 SAX Processing Model
SAX first approach (stream processing) advantage:
it lets an application immediately start processing the content of the
source document.
application does not even have to wait for the entire document to be
retrieved.
Useful when - retrieving document from an earlier processing stage
(pipeline) or from the network
disadvantages :
a document may appear to be well and has unexpected errors at the
end
notices these problems only when it comes across erroneous tokens or
when it cannot resolve an entity reference.
the input stream from which it is reading the document unexpectedly
closes
Use stream processing model within the context of a transaction
32
 SAX Processing Model
With the second approach,
parsing the document and applying business logic are
performed in two steps
first ensures that the document and the information
extracted from the document are valid
Once the document data is validated, the application
invokes the business logic
Disadvantages of the SAX model
No facility to modify or produce XML documents.
still possible to generate an XML document by writing
custom serialization handler
33
 SAX Processing Model
SAX processing model well suited when
 the XML document is very large and needs more memory
Your applications do not make any structural modifications
and no need to generate XML documents.
the document needs only be processed once
 you want to implement stream process very large documents
extract and process only part of the XML document
 the XML document structure and the order of information
map well to the domain-specific objects
familiar with event-based programming
no need to generate/write XML documents
SAX processing follows a push model
34
SAX Processing Model

35
 StAX Processing Model
StAX (Streaming API for XML) is a new API that is becoming
most common processing model for JAVA applications
Like SAX, it is based on streaming
Streaming
a programming model in which XML infosets (sections of XML
document) are transmitted and parsed serially at application
runtime, often in real time, and often from dynamic sources
stream-based parsers can start generating output immediately
infoset elements can be discarded and garbage collected
immediately after they are used.
stream processing provides a smaller memory footprint,
reduced processor requirements
36
 StAX Processing Model
Limited to cardboard tube
view of is document
need to know what
processing you want to do
before reading the XML
StAX follows pull streaming
model (a client application
calls methods on an XML
parsing library)

37
 StAX Processing Model
Pull model has several advantages over push model:
the client controls the application thread (in pull)
vs the parser controls the application thread
Pull parsing libraries can be much smaller, and the
client code is simpler than with push libraries
Pull clients can read multiple documents at one
time with a single thread.
A StAX pull parser can filter XML documents such
that elements unnecessary to the client can be
ignored
StAX provides marshalling (creating XML docs)
38
 StAX Processing Model
Use the StAX processing model when :
You are dealing with very large documents and
memory usage is an issue
You are familiar with event-based programming
The document must be processed only once
There is need for marshalling and unmarshalling
XML documents
You want high performance

39
 DOM Processing Model
processing the XML input data involves two
steps:

 The DOM parser generates a tree-like data

structure that models the XML source
document. This structure is called a DOM
tree.

 The application searches for the relevant

information in the tree and extracts,
consolidates, and processes it further.

 Then the application can create domain-

specific objects from the consolidated data.
40
 DOM Processing Model
Limitations:
The DOM model designed to be a platform-and language-independent interface. (does
not use the java.util.Collection API )

Advantages:
it is slightly easier to use than the SAX model.

Allow both marshalling and unmarshalling of the XML document

XSLT identity transformation can be used to achieve serialization back to the XML
document

use of XPath with the DOM processing model simplifies many tasks

 XPath allows to specify path patterns to locate element content, attribute values, and subtrees,
may eliminate tree-transversal code.

XPath expressions are strings, they can be easily parameterized and externalized in a
41
configuration file
 DOM Processing Model
DOM processing model should be used when

You want to process or generate XML documents

You want to process the XML document more than once

The document is not very large and memory usage is not an issue

You want to manipulate an XML document and need fine-grained control over
the document structure that you want to create or edit

You want random access to parts of the document. For example, you want to go
back and forth within the document.

You want to benefit from the flexibility of XPath and apply XPath expressions on
the DOM tree.

You want to implement data binding but you cannot use JAXB technology 42
because the document either has no schema or it conforms to a DTD
 XML Data-Binding Processing Model
Allows the processing a XML document without being
concerned with XML representation

binding compiler is used to generate Java content classes

from a source schema

JAXB binds XML namespace to a Java package.

43
 XML Data-Binding Processing Model
JAXB binds XML namespace to a Java package.

XSD schema instance (XML document) can be unmarshaled into

a tree of Java objects

The Java Objects created are the instances of the Java classes
generated by the binding compiler using the XSD schema.

44
 XML Data-Binding Processing Model
Application can access the source document using Java Bean—style getter and setter
methods.

You can create or edit in-memory content tree and then marshal the tree into an XML
document instance.

Validations can be performed to ensure that the document created satisfies the
constraints expressed in the XSD schema.

Steps to use JAXB:

Set up the JAXB context (JAXBContext) with the list of derived packages that are used
to unmarshal the document.

Unmarshal an XML document into a content tree. Also, perform validation of the
document

Directly apply the business logic to the content tree or consolidate information from
45
the content tree and then apply business logic on the consolidated information
 XML Data-Binding Processing Model
 This processing model also supports serialization to XML

Steps to marshal a content tree:

 Modify the existing content tree /generate new tree, from the
application’s business logic
 Validate content tree against the source schema
 Marshal the content tree into an XML document
46
Difficult to use JAXB if there is no schema
Use JAXB when

You are creating or consuming XML documents

 want to deal with Java Objects and are not concerned with XML representation

do not need to maintain certain as aspects of an XML document (comments and
entity references)

Process the content tree multiple times

You need random access to parts of the document

Memory usage: JAXB implementation creates a Java representation of the content

of a document is much more compact than the equivalent DOM tree

You previously used DOM, and an XSD schema is now available. 47

 XSLT Processing Model
XSLT is a higher level processing model than the SAX, StAX, DOM, and XML

XSLT complements to these models, and should be used along with these other models

XSLT requires writing of rules and templates that are applied when specified patterns
are encountered in the source document.

The application of the rules adds new fragments or copies fragments from the source
tree to a result tree (XPATH is used to locate and extract information from the source
document)

When using XSLT, one typically writes style sheets, which are themselves XML
documents.

XSLT processing provides the flexibility that comes with scripting.

The XSLT API available with JAXP provides an abstract for the source and result of a
transformation, allowing the developer not only the ability to chain transformations but
also to interface with other processing models, such as SAX and DOM. 48
XSLT Processing Model

49
 XSLT Processing Model
XSLT should be used when

You want to change the structure or insert, remove, or filter the content of an XML
document.

You need to perform complex transformations. Because XSLT is a functional

declarative model, it is easier to design complex transformations by coding
individual rules or templates than by hard-coding procedures.

You want the ability to be flexible and allow future changes in the schemas of
documents you are processing.

You need to minimize performance overhead for large documents that contain a
significant amount of data

You potentially have more than one transformation for the same document—
because of the scripting nature of the style sheets—are better performed using XSLT
transformations 50
52