Databases Reference
In-Depth Information
The simplest way to illustrate the
criticality
of this layer is to demonstrate the
potential impacts of trying to bypass it, which, during the pressure of a development
life cycle, can be easily done (and often is).
A typical scenario is where a developer or an architect will argue that it's only used
in one place, and it's unlikely to change for a long time anyway, or we need to do it
this way for performance reasons, and so on. And often, it is the case that the FIRST
time you use something, it is only being used in one place. The trouble is that
before long, you may find it being used in many places (and often you don't
always know where).
Then change happens. It may initially be a simple change, for example it may be
just moving the application to a bigger box (as the amount of requests it is now
processing has increased), or the actual application itself may be changing. Maybe
it's being upgraded to a new version, or maybe it's being replaced with a completely
new application.
Either way the WSDL for the service is likely to change, requiring every caller of
that service to be modified, tested, and redeployed, and of course, this needs to be
coordinated across all users of that service.
This becomes more complicated when you have multiple changes in the same time
frame. You could very quickly end up with hundreds or thousands of changes to
implement and coordinate. Suddenly, change becomes very complicated and our
systems far from agile.
As we mentioned earlier, the job of this layer is to provide a
virtual services
layer
to decouple consumers of services from the underlying application and thus
minimize the impact of change. It achieves this in two ways:
•
First, it provides a virtual endpoint for the client to call. Upon receipt of a
request, it then routes it to the underlying application service.
Secondly, it allows us to define an abstract description of the service, that
is, the operations provided by the service and its corresponding input and
output messages, so that these are no longer dictated by the underlying
application. This layer is then responsible for transforming an incoming
input message from the format of our service contract to the one expected
by the application service and vice versa for any response.
•
