Over the past decade computing power, network bandwidth, and software development tools have benefited from significant improvements. Yet, aspects of design, implementation, and maintenance of enterprise server applications remain the most risky, error-prone, and costly side of application development. Much of it stems from the need for continuous rediscovery and reinvention of core components. The good news is this is something that’s easily fixed.
The most customary response to date for addressing these deficiencies is software reuse. In practice, unfortunately, significant benefits from software reuse prove elusive. Efforts by most development groups result in small, reusable, “black-box” components. Given the marketplace demand for voice and data servers, as well as rich media, this is an excellent time to make additional progress at leveraging some existing object-oriented (OO) paradigms, such as component-oriented programming (COP) and service-oriented programming (SOP), another route to more cost-effective development is taking shape.
Services-Oriented Approach (SOA)
The services-oriented approach organizes solutions into a set of independent but cooperating subsystems or services. Such a framework isolates each service and exposes only the necessary declared interfaces to other services. Services are very much like components in that they expose an interface for invoking a set of related behaviors. A service takes this one step further, by also simplifying the interface, thus effectively encouraging reuse and reducing dependencies.
So how can this SOA save development team money and effort? The SOA encourages the incorporation of organizational best practices. Each service is designed and built for functional reuse across the enterprise, instead of being tied down to a single application. It is this removal of the application boundary (in terms of intent) along with good documentation practices, which produce and enhance reuse of components and objects in software development.
In practical application, for instance, if we extract services from an application that provides behavior common throughout all of my enterprise applications, we can achieve a much higher level of reuse of those services. Applications then can naturally iterate at a faster rate based upon changing customer requirements, without sacrificing the reuse of more stable services within an information processing system.
Java Services Framework (JSF)
The Java Services Framework (JSF) is designed from the ground up to facilitate capitalizing on the reuse of large components in system development (Java Specification Request 111). It is an open standards, component-based framework that facilitates the development of servers from a set of independent but cooperating components or services.
The framework defines the life cycle of these services as well as how they may locate and interact with each other. In addition, the framework supports the run-time configuration and management of these services. The JSF is the starting point for defining a Service-Oriented Approach (SOA) to application development.
In practice, a developer creates a service by implementing a service access point and one or more objects that implement the defined interfaces of that service. The framework then maps the service to the defined interfaces in the service registry. Once a service has been registered in the service registry, it can be accessed via its interfaces because they are defined attributes of the service binding. The associated service can be acquired using any configured interface, and its methods can be accessed by way of the associated interfaces.
Essential to the JSF is the technology that allows developers to create streamlined, compatible services. Toward this end, it provides:
- Well-defined contracts that ensure services are accessed and managed in a unified and consistent manner.
- Management software that allows developers to dynamically configure, maintain, and deploy services.
- Enterprise application support for business solutions, such as logging and security.
In addition, the JSF has an inherently open architecture, allowing its functionality to be leveraged by a variety of applications (for example, databases, application servers, and embeddable hardware programs).
Configurable Application Footprints
The SOA provides flexibility during deployment. One such way is through configurable application footprints. These footprints allow turning off unused services in situations where they go unused.
In an example, let’s say we needed a Web application server supporting servlets and JSPs, but didn’t require EJB or CORBA component support. In this case, we could turn off or remove the EJB container, the ORB service, the transaction manager, and so forth, to effectively create an optimal environment. An application server designed using a service-oriented approach would support this flexibility.
Service-Oriented Approach to Digital Content Management
The management of digital content, including voice and data, is a prime example of where the service-oriented approach can be effective. Management of digital content can be grouped into a process which includes planning, creating, publishing, collecting, distributing, and receiving. Planning involves defining the need and objectives for digital content creation or capture. Applications targeting this phase include project and requirements management.
The next step is creating and may include many types of content capture and creation vehicles as well as workflow, authoring, layout, access control, and copyright/trademark management. Publishing includes activities such as proofing, editing, rights management, watermarking, and assembling. Collecting is the aggregation and organization of separate pieces of content into groups relative and meaningful to users. Distribution includes all forms of deployment of content required to get content effectively to the proper customers. The final step in the process is the receiving of the content, which can take many forms and require multiple delivery applications.
We have mentioned many separate functions required to effectively process and manage digital content which, in the past, have been served up by separate applications and were generally managed manually. The service-oriented approach, however, could provide an integration platform for this digital value chain.
Services can be created that not only allow for the modular assembly and automation of these digital processes but also could facilitate swapping some of the components on the back end with little or no distruption on the client side. For example, accessing digital content can be achieved via a service interface that represents the WebDAV (Web Distributed Authroing and Versioning) protocol. Implementations of this interface then can provide access to multiple WebDAV-supporting content management systems. Similarly, services can be created to facilitate integration of other digital content applications such as digital rights management, content distribution, and so on. The flow of digital assets through the system would potentially be governed by a workflow service that interacts with the other services.
About the Author
Jonathan Maron is a Distinguished Engineer with Hewlett-Packard’s Middleware Division. He was the principle architect of the Bluestone EJB 1.1 Server and has been a member of the EJB and J2EE expert groups. He is currently serving as the Specification Lead for the Java Services Framework, a Java Community Process (JCP) Java Specification Request (JSR).