Service abstraction

From Wikipedia, the free encyclopedia
Jump to: navigation, search

Service abstraction is a design principle that is applied within the service-orientation design paradigm so that the information published in a service contract is limited to what is required to effectively utilize the service[1] The service contract should not contain any superfluous information that is not required for its invocation. Also that the information should be limited to the serviced contract (technical contract and the SLA) only, no other document or medium should be made available to the service consumers other than the service contract that contains additional service related information.

Purpose[edit]

A service contract that contains details about what is encapsulates e.g. the logic, implementation and the technology used to build the service, may end up being used in a particular manner as now the service consumer has more knowledge about the working of the service. Under normal circumstances, the more knowledge we have, the better it is but in case of service-orientation, there is a chance that the additional information could impede the reusability of the service as the service consumer designer may streamline his design based on this knowledge, however, this would affect the evolution of the service contract as now the service consumer is indirectly coupled to the service implementation, which may need to be replaced in the future. In a way, this increases the consumer-to-contract type of coupling, which although is a positive type of coupling but having too much dependence can negatively impact the evolution of both the service provider and the service consumer.

Information hiding remains one of the key principles within object-oriented paradigm that promotes abstracting away the inner workings of a software program. A classic example would be the use of abstract classes to hide the actual method logic. The same concept is applied by the service abstraction principle in order to hide the unnecessary details about the working of the service with a view to ease the evolution of the service.[2]

Application[edit]

The application of this design principle requires looking into four different types of abstractions that could be applied to a service.

Functional abstraction[edit]

This form of abstraction is dependent upon how much of the service logic is exposed as service capabilities. An example would be of a class whereby some of its methods are private while others are public. A class would only expose those methods as public that it deems to be important to its objects, any helper methods that are not relevant to the objects are kept hidden.

A service contract which has not been subjected to this principle could be termed as a 'detailed contract' that reveals much of business rules and the validation logic. Once this principle has been applied to a fair degree, the contract could be termed as a ‘concise contract’. Further application of this design principle would result in a 'optimized contract' that maximizes the reuse potential of the service.

Technology information abstraction[edit]

Any information about the underlying technology used within the service would result in a low technology information abstraction as the service contract explicitly tells the service consumers how the service logic and its implementation are designed. This extra information might result in service consumers being designed in a way that specifically targets that particular implementation, thereby developing consumer-to-implementation coupling.

Logic abstraction[edit]

The programmatic details about the service logic need to be abstracted[3] as knowledge about how the service actually performs its functionality can result in service consumers that factor in this information and are consequently designed under these assumptions. This can seriously hamper service logic refactoring efforts and can be considered as an anti-pattern towards the application of the service refactoring design pattern.

Quality abstraction[edit]

Quality abstraction relates to the details provided within the service’s accompanying SLA. It’s important to concentrate only on that kind of information that would actually help in determining the reliability and availability of the service, no other information should be included that exposes unnecessary details e.g. details about how does a service sits within the overall business process and which other services it uses for fulfilling its functionality.

The level of access control applied to a service would decide how much of technology, logic and Quality of service (QoS) abstractions are in place. An 'open access' would provide free access to everyone that is interested in finding out the design specifications of a service. In a 'controlled access', only authorized people are granted access and a 'no access' policy would totally deny any access to the design documents.

Considerations[edit]

Although information hiding is considered a healthy practice, however, too much of information hiding could be counter productive as it can limit the re-usability level of the service. This can also result in redundant services as service designers don’t have enough information about the capabilities of the service. For this, each service contract needs to be designed in a concise yet comprehensive manner so that the service’s capabilities can be effectively discovered and interpreted as dictated by the service discoverability principle.

The kind of information exposed in the service contract can lead to some security related concerns as well. For example, a service that propagates the details about the database in use as result of an internal error can fall a victim to an attack where the attacker makes use of the reported error details and attempts to connect to the database. This could be addressed by the application of the message screening[4] and Exception Shielding[5] design patterns.

References[edit]

  1. ^ Service
  2. ^ Dennis Wisnosky.Principles and Patterns at the U.S. Department of Defense[Online].Date accessed: 13 April 2010.
  3. ^ Kjell-Sverre Jerijærvi.SOA Contract Maturity Model[Online].Date accessed: 13 April 2010.
  4. ^ Message Screening
  5. ^ Exception Shielding

Further reading[edit]

External links[edit]