A friend of mine said, when we discussed the RIA-SOA topic, that he was fully entitled to have a service that provided a merchant's price to his RIA. The price was assumed to be taken from a back-end data store. I agreed with him but thought that the interface should not be concerned with where the price value had come from until it was correct. Besides, would it make sense talking about the merchant's price in isolation from the presentation context? It was very likely that the merchant had to be represented on the RIA screen by its other characteristics provided by a sort of business service running behind the scenes. All these gave me the idea for the RIA-SOA collaboration pattern that I am going to discuss.

RIA-SOA Collaboration Design Pattern
Problem Summary:

• RIA requests mismatch the granularity of the SOA business service interfaces
• RIA and SOA requirements have no common points suitable for integration

Problem Explanation: See the discussion in the previous section

Solution:

• Use a conciliator module between RIA requests and SOA business service interfaces
• Conciliator module responsibilities:
  -Bridge business functionally provided by SOA business services and business user interface functionality
  -Convert data structures from the business service interface format into a user interface format for a particular RIA widget, and vice versa
  -Provide a way to optimize usage of the SOA business service as well as prompt and correct responses to the RIA requests

The most trivial optimization of business service usage is using it as designed - with a coarse-grained interface and related business data model. In addition, since some RIA/UI functionality may be dependent on the changes in the business environment, the SOA business service may be used in a "subscription" mode. That is, RIA can send a subscription request via the conciliator, and the business service starts monitoring for particular business events or business data changes and delivers the appropriate information to the conciliator. The latter can share this information between interested RIA requests. Figure 2 illustrates the RIA-SOA collaboration design pattern.

The RIA-SOA collaboration pattern has some similarities with the known J2EE front controller pattern: the conciliator, as a controller, deals with remote client (browser) requests and responses. However, this is where the similarity ends. A front controller pattern operates as a dispatcher, performing view/templating selections while the conciliator's major task is to make granularities, data formats, and invocation models conform. The conciliator can include a front controller pattern similar to how a proxy pattern can include a delegate pattern when needed.

Implementation Examples
Example 1 - Direct Cache Conciliator
An implementation of a conciliator is a web cache. If the conciliator does not find the information to respond to an RIA request in the cache, it invokes a related business service "on demand." The returned service results are accumulated in the cache. Analogous requests never go further than the cache. Each service result has a timeout and is subject to a refresh. The conciliator takes care of the refresh schedule while the service delivers results.

For RIA requests representing three types of UI requirements - information exchange, information representation/reports, and user operations against the systems - the conciliator acts accordingly, i.e., it only caches responses that might be reused. Among others, the conciliator provides a mechanism for data format transformation where necessary. That is, the conciliator caches service results after the transformation.

It would be an insufficient solution if we required SOA business services to return data in the format of an external UI because the service may have associations with many interfaces. In the service-oriented approach, the interface serves the business service, not vice versa; the business service is the driver, i.e., the "A" part of RIA drives its "R" part. The service defines which business functionality to expose via this or that interface, rich or not; the interface adds only the user experience capabilities.

This is why we need a bridge between presentational (RIA) and processing (business service) data formats. Moreover, the interface or client part of RIA isn't supposed to be aware of the data models and formats that the application operates on and that persist. So a statement like "my RIA (client) needs the merchant price stored in a particular field of a particular database" violates the principle of separation of concerns. Of course, the interface must have the price value but where it comes from is the service's "business" in service-oriented applications.

Example 2 - Presentation Services Conciliator
The conciliator may have a more complex implementation than just a Web cache. It may include fine-grained presentation services serving the remote actions and events of the RIA widgets while working against the Web cache. Presentation services run in the presentation tier and serve UI exclusively. They also add flexibility to the Web cache and can support the federation of distributed Web cache affinities. That is, the power of the distributed Web cache can be dynamically increased or decreased in accordance with the richness of RIA.

Presentation services can perform the data format transformation described in Example 1. They can also invoke infrastructure services like security, for example, for end-user authentication, simple business services like currency conversion that is fine-grained by definition as well as operation statistics services. However, what the presentation services must avoid are the same bad habits found in regular Web applications - for instance, the direct engagement of resource drivers, like database drivers, straight from the presentation tier. Straightforward retrieving and storing data in the persistent storage has nothing to do with service orientation and, if applied, should not be called business service actions. If somebody wants to couple a UI, even a rich UI, with a database, we're not talking SOA.

Since SOA is usually an enterprise, or a line of business, or business unit solution, it crosses several applications that might have shared data stores. SOA assumes the use of a Data Access Layer (DAL) in between the business services and data stores. Data access services working in DAL don't replace store drivers but provide RWE via accumulating, aggregating, and composing business data from the sources, according to the preliminary defined business rules. Still, data access services are considered infrastructural services because they might depend on specific data stores or legacy applications.

• Direct RIA + Google App Engine = Simplicity + Scalability