Using Service Oriented Architecture and Component Based Development to Build Web Service Applications
Building an enterprise-scale software system is a complex undertaking. Despite decades of technological advances, the demands imposed by today’s information systems frequently stretch to breaking point a company’s ability to design, construct, and evolve its mission-critical software solutions. In particular, few new systems are designed from the ground up. Rather, a software architect’s task is commonly that of extending the life of an existing solution by describing new business logic that manipulates an existing repository of data, presenting existing data and transactions through new channels such as an Internet browser or handheld devices, integrating previously disconnected systems supporting overlapping business activities, and so on. To assist software developers, commercial software infrastructure products are now available from vendors such as Microsoft and IBM. They form the centerpiece of the approaches to software development they advocate in their .NET and WebSphere product lines, respectively. Both approaches focus on assembly of hsystems from distributed services. However, is there anything new about building enterprise-scale solutions from services? How do the lessons of component-based systems apply to construction of servicebased architectures (SOA)? What are the best approaches for building high quality systems for deployment to this new generation of software infrastructure products? These important questions are the topic of this paper. In recent years, much of the attention in the software engineering community has focused on design approaches, processes, and tools supporting the concept that large software systems can be assembled from independent, reusable collections of functionality. Some of the functionality may already be available and implemented in-house or acquired from a third party, while the remaining functionality may need to be created. In these cases, the whole system must be conceived and designed to bring together all these elements into a single, coherent whole. Today this is exemplified in component-based development (CBD), a concept that is realized in technological approaches such as the Microsoft .NET platform and the Java 2 Enterprise Edition (J2EE) standards supported by products such as IBM’s WebSphere and Sun’s iPlanet.. An additional consideration is that operational systems will typically be distributed across many machines to improve performance, availability, and scalability. An enterprise solution has to coordinate functionality executing on a collection of hardware. One way to conceive of such a system is to consider it to be composed of a collection of interacting services. Each service provides access to a well-defined collection of functionality. The system as a whole is designed and implemented as a set of interactions among these services. Exposing functionality as services is the key to flexibility. This allows other pieces of functionality (perhaps themselves implemented as services) to make use of other services in a natural way regardless of their physical location. A system evolves through the addition of new services. The resulting service-oriented architecture (SOA) defines the services of which the system is composed, describes the interactions that occur among the services to realize certain behavior, and maps the services into one or more implementations in specific technologies.
While the services encapsulate the business functionality, some form of inter-service infrastructure is
required to facilitate service interactions and communication. Different forms of this infrastructure are
possible because services may be implemented on a single machine, distributed across a set of computers
on a local area network, or distributed more widely across several companies’ networks. A particularly
interesting case is when the services use the Internet as the communication mechanism. The resulting Web
services share the characteristics of more general services, but they require special consideration as a result
of using a public, insecure, low-fidelity mechanism for inter-service interactions.
Much of the software industry’s focus so far has been on the underlying technology for implementing Web
services and their interactions. However, additional concerns arise around the question of the most
appropriate way to design Web services for ease of assembly into enterprise-scale solutions. Conversely,
there has been a surprising lack of attention on appropriate practices and tools for architecting enterprisescale software solutions composed of Web services. As with the design of any complex structure, highquality solutions are the result of early architectural decisions supported by a number of well-understood
design techniques, structural patterns, and styles. These patterns address common service issues such as
scalability, reliability, and security.
This paper provides the context for a deeper understanding of services and service-oriented architectures
for enterprise-scale software solutions. In particular, it explores services in relationship to the more
established concept of software components, and it describes how current component-based development
practices provide a tried and tested foundation for the implementation of a service-oriented architecture.
Interface-based design is highlighted as the key to both service and component design, and it is argued that
the interfaces exposed by both have certain constraints and criteria that distinguish them. The Unified
Modeling Language (UML) is used as a tool to describe both logical and implementation designs, as
well as specific patterns for both component and service design.