156

Designing XML Based Applications

uments. (See  Receiving Requests  on page 89 and  Formulating Responses  

on page 98.) Moreover, when the processing layer of a Web service imple 

ments an object centric processing model, the interaction layer may be re 

quired to map XML documents to or from domain specific objects before 

delegating to the processing layer by using one of the three approaches for 

mapping XML schemas to the application data model presented in  Mapping 

Schemas to the Application Data Model  on page 143.

  In the processing layer of a Web service when implementing a document 

centric processing model. (See  Handling XML Documents in a Web Service  

on page 105.) In such a case, the processing layer may use techniques such as 

flexible mapping or XML componentization. See  Flexible Mapping  on 

page 148 and  XML Componentization  on page 149.

With the object centric processing model when XML document content is

mapped to domain specific objects the application applies its business logic on

the domain specific objects rather than the documents. In this case, only the inter 

action logic may handle documents. However, in the document centric model, the

application business logic itself may directly have to handle the documents. In

other words, some aspects of the business model may be expressed in terms of the

documents to be handled.

There are drawbacks to expressing the business model in terms of the docu 

ments to be handled. Doing so may clutter the business logic with document pro 

cessing related logic, which should be hidden from application developers who

are more focused on the implementation of the business logic. It also introduces

strong dependencies between the document's schemas and the business logic, and

this may cause maintainability problems particularly when handling additional

schemas or supporting new versions of an original schema (even though those are

only internal schemas to which documents originally conforming to external

schemas have been converted). Additionally, since there are a variety of APIs that

support various XML processing models, such a design may lock the developer

into one particular XML processing API. It may make it difficult, and ineffective

from a performance perspective, to integrate components that use disparate pro 

cessing models or APIs.

The same concerns about maintainability in the face of evolution and the

variety of XML processing models or APIs apply to some extent for the logic of

the Web service interaction layer, which may be in charge of validating exchanged