Escolar Documentos
Profissional Documentos
Cultura Documentos
1 Introduction
Web services have already proven their strength in providing organizations with
access to remote services that are hosted in as well as outside these institutions. This
rather basic but powerful functionality provides a basis for more advanced techniques
like the composition of web services, which will allow for the provision of complex
services that are assembled from existing “atomic” services.
It becomes clear that for composition within a dynamic web service environment,
there is a need for more than the currently available, rather syntactic and static meta
information and design time composition. Web services in a heterogeneous
environment often become unavailable, change versions or are replaced by other
services. Therefore, the rapidly changing landscape of web services needs
descriptions which allow the run-time search and inspection of web services to reach
the goal of dynamic search and composition.
2 Related Work
To support these goals of dynamic search and composition, some technologies are
already available: WSDL [1] and UDDI [2] are standards that are widely used in this
context, but they contain rather no semantics, that are needed for intelligent
combination of services. OWL-S [3] instead is a quite new OWL [4] ontology,
containing structures for storing semantic information about a web service, that would
2 Doris Janssen, Alexandre Lins, Thomas Schlegel, Michael Kühner, Gerhard Wanner
help to classify a web service and get information about what a service does and how
it works.
We think that intelligent retrieval and automatic composition of web services can
only be done using the more powerful abilities of a semantic description for web
services, as offered by OWL-S. Yet, these languages are the first step towards more
intelligent systems. In order to do the second step of retrieval and dynamic
combination of web services, some active modules are needed:
• Retrieval: A web service retrieval mechanism (similar to an UDDI-Requester)
could match semantic descriptions of web services with the request and then
retrieve the appropriate web service. While already first steps in this direction have
been accomplished [5], a common approach to access these directories
semantically is still missing.
• Invocation: Web service invocation engines could support the invocation of
services, check security issues, take part in service level agreements, etc..
• Composition: Planners could compose processes from different service
components and execute them.
While the problem of dynamic web service invocation seems to be solved (using e.g.
WSIF [6]) and there is currently a lot of work done for the composition of web
services (e.g. BPEL4WS, also some parts of OWL-S), regarding the retrieval of web
services other functionalities yet only basically implemented exist. For the problem of
retrieving services there are prototypic solutions and suggestions like “Matchmaker”
[7] and “Semantic Discovery Systems” [8], and for planning there has been developed
the “Web Service Composition Via AI Planning module” within IBM’s ETTK [9].
These are first prototypes to show concepts, and they still bring disadvantages with
them, like being stand alone or lacking public availability and acceptance.
Within ETTK of IBM, the “pluggable discovery framework” allows easy
combination of different, underlying retrieval mechanisms, like UDDI or WSIL [10].
Yet, this framework concentrates on realization of discovery mechanisms, without
using methods for semantic discovery that would be necessary to improve current
discovery methods.
In this article, we therefore present a framework for development and operation of
web services on the Java platform, where the different modules can simply be
plugged in. We will especially focus on an API for discovery and retrieval of Web
Services that implements the connection with different service discovery engines, and
that provides operations for semantic discovery of web services described by OWL-S.
A framework that supports all activities needed to act with semantic java web
services, like shown in Figure 1, can help coping with the question of handling web
services semantically, even more when services are possibly described in different
languages. The SemanticServiceRegistryAPI (SSRA) is such a framework covering
retrieval and invocation as well as planning and dynamic combination of web
services.
A Framework for Semantic Web Service Retrieval 3
P lanner
Agent 1 1:Call (Web S ervice
4:S ugges tion Combination)
5:Call 2:Call
Invocation Interface R etrieval Interface
Invocation E ngine R etrieval E ngine
A web service can make use of a planner service in order to synthesize complex
processes, combined out of different web services as suggested by [5]. For retrieving
web services, a retrieval module is provided, as well as an invocation module for the
act of invoking and negotiating quality of service. All modules are built to be used
separately as well as together and can be accessed via a web service interface. In this
paper, we will especially focus on the retrieval module.
The service discovery framework addresses the web service retrieval. It defines a
set of interfaces and associated methods that enables the developer to access Semantic
Web Services registries. It is designed to be open and therefore it is able to work with
different implementations of registry technologies. Moreover, it provides a set of
methods to perform query and update operations on the registry using a Java
representation of the OWL-S ontology. The implementation of the framework should
be able to manage connection issues, handle client requests and forward them to the
registry, process the responses and return the results back to the client.
The Java API for XML Registries (JAXR) [11] provides a basic framework for
accessing XML registries, which can be used to build upon. JAXR is composed of a
set of interfaces and associated methods for manipulating registry data objects and
perform operations on the registry. Moreover, the API is open, meaning that one can
provide specific implementations to access registries based on different technologies,
such as UDDI and ebXML [12]. A lack of JAXR is that the design constructs used to
represent registry objects are not fit to represent OWL-S constructs, so enhancements
have to be made. The service discovery framework leverages off the JAXR API to
provide a tool that enables the creation and management of OWL-S service
descriptions from a Java application. On one hand, the API takes advantage of some
of the design constructs provided by the JAXR API specification. On the other hand,
it provides a tool that is based on OWL-S concepts and therefore is more intuitive for
the developer accessing a semantic-based registry.
4 Doris Janssen, Alexandre Lins, Thomas Schlegel, Michael Kühner, Gerhard Wanner
This paper focuses on the development of the service discovery framework. For such
a framework, different requirements exist:
• Object Model
For an integrated framework, a consistent object model (data types, etc.) is
important. It helps integrating the different modules and forms a common basis.
Within OWL-S, a XML data model for describing services semantically already
exists. This data model should therefore be used. So within the API an object
model has to be provided that represents the design constructs of OWL-S in Java
and allows the developer to manipulate these constructs.
• File Processing
Descriptions of services are usually stored in ordinary data files, for example in an
XML format. Therefore, the API has to provide functions regarding the processing
of the OWL files into the constructs defined in the object model and vice versa.
This includes design constructs that define methods for reading and writing
services, service profiles, service groundings and service models objects from and
to OWL files lying on the file system.
• Registry Operations
The main objective of the API is to provide the functionality to perform service
discovery and maintenance operations on remote registries. A requirement for the
API is therefore to provide design constructs and functions that allow the developer
to perform insertion, update, deletion and query operations on a remote registry.
The API must provide operations that are based on the object model to be defined
as part of the framework. An important point that must be mentioned regards the
granularity of the operations. A requirement here is that the API must provide
methods that allow the developer to perform insertion, update and deletion
operations for services, service profiles, service groundings and service models on
remote registries. Query operations that return collections of services, profiles,
groundings and models must also be provided by the API. The definition of
operations for these types of objects is important as they are the main design
constructs in OWL-S and in fact encapsulate the other constructs defined in the
ontology.
• Openness
As already discussed, a number of tools and technologies for the semantic web are
currently under research and development, including registries based on semantic
web technologies. For this reason, a requirement for the API is that it should be
open enough to provide implementations for the different types of OWL-S-based
registries that are to become available in the future. Openness is usually achieved
by the specification of interfaces that define a basic set of design constructs and
associated operations from which different implementations can be derived.
Openness also means to provide support for the configurability of the tool,
allowing the developer to use design constructs for configuring specific points of
the implementation without needing to change the program. As a result of this
requirement, the API will be able to support different technologies of registries.
A Framework for Semantic Web Service Retrieval 5
• Extensibility
The OWL-S specification defines a basic ontology for the semantic description of
services. A requirement for the API then is that it must be extensible enough to
provide support for these new types and relationships to be created in the future.
Extensibility can be achieved by the provision of general objects from which the
new types can be derived, and the specification of methods based on these objects
that can be overridden to support the new constructs that are to be created.
• Security
Security is an important issue regarding applications that interact with remote
parties. Remote registries should implement mechanisms that allow them to verify
the identity of a client application and the operations they are allowed to perform.
On the other side, the clients must be able to provide the authentication and
authorization information that the registries need to authorize the operations to be
performed. The API must define constructs that support the configuration and
processing of authentication and authorization information. An important
requirement, though, is that these design constructs should be extensible enough to
provide support to the different authentication mechanisms supported by the
registries.
• Other Issues
As the API provides functionality to perform operations on remote parties, two
other important aspects are performance and reliability. Performance plays an
important role on performing remote functions as the network lying between the
parties slows down the execution of the operation. Also reliability is an important
aspect on remote operations. In fact, it is important for the system to guarantee that
messages sent between client and server do not get lost in the network for the
operations to get completed. The API does not provide support in its design
constructs to deal with aspects regarding performance and reliability, though.
Instead, it is up to the API implementer to guarantee that these requirements are
met according to the quality of the services they wish to provide in their
implementation, e.g. through caching and message timeout mechanisms.
Figure 2 presents the general organization of the service discovery framework. The
component on the top is a Java application that uses the framework to access different
remote registries. The framework is composed of two main modules. The first module
is a set of interfaces that are used by the Java application to perform operations on the
registries. The other module contains a set of one or more implementations of these
interfaces, which are responsible for carrying out operations on the registries.
Client
API
API Implementation
Registry
The information model is composed of a set of interfaces that are used to represent
OWL-S constructs inside a Java application. The idea is to provide an easy way to
manipulate these elements through the program and, at the same time, act as an
abstraction layer to hide the details of the XML constructs from the developers. The
interfaces are organized in the package de.fhg.iao.ws.owls.infomodel. Figure 3 shows
the class diagram for the information model.
The Service interface is used to represent the Service class defined in the OWL-S
specification. It basically defines methods that provide access to the ServiceProfile,
ServiceModel and ServiceGrounding interfaces. On the other hand, the ServiceProfile
and Profile interfaces have been defined to represent the ServiceProfile and Profile
classes that are described in the specification.
The Profile interface provides a set of methods that allows the developer to access
the various attributes of a profile. These attributes are represented in the model by the
interfaces Actor, ParameterDescription, ServiceCategory, and ServiceParameter. In
addition, the information model defines the interfaces Actor, GeographicRadius and
A Framework for Semantic Web Service Retrieval 7
The framework defines constructs that allow developers to create service descriptions
using the interfaces defined in the information model described above. The first of
them is the ObjectFactory, an abstract class that defines factory methods the
developers can use to create the elements of a service description inside the Java
application. In addition to the more specific methods such as createService and
createServiceProfile, a generic method createObject is specified that allows for the
creation of other objects to be defined in the future. The code fragment below shows
how the factory is used.
ObjectFactory factory = ObjectFactory.newInstance();
Collection profiles =
fileProcessor.readServiceProfiles(profileFilename);
The term connection management is used to describe the tasks related to the
establishment of connections with remote parties. Connection establishment is an
important step because it allows partners to negotiate communication details such as
protocols, security issues, message format, and mode of communication. Based on the
constructs defined in the JAXR API, this framework defines a set of interfaces and
classes that abstracts the developer from connection management details, by
providing a set of specific methods that deal with the issues described above. Figure 4
shows the class diagram for the connection management model.
8 Doris Janssen, Alexandre Lins, Thomas Schlegel, Michael Kühner, Gerhard Wanner
Figure 4 shows the abstract class ConnectionFactory that is responsible for creating
connections. Moreover, the class provides methods to set and get general properties of
the connection, ensuring an easy configuration of the framework allowing for the
configurability of the framework. Connections are represented by the Connection
interface that defines methods for managing connection issues such as authentication
information and communication mode. Finally, a RegistryService interface is defined
that specifies methods that give access to registry operations. These operations are
actually defined on another set of interfaces to be discussed ahead. The code below
shows how to create a connection using the framework.
ConnectionFactory connectionFactory =
ConnectionFactory.newInstance();
properties.setProperty("registryUrl",
"http://localhost:8080/RegistryServer");
connectionFactory.setProperties(properties);
Connection connection =
connectionFactory.createConnection();
The connection management model itself provides a clear separation between
configuration, connection management and registry functionality issues. Furthermore,
it allows the framework to support different types of registry technologies. Most
important though, is that it abstracts the developer from implementation details. The
developer does not need to program and maintain these modules as they are already
A Framework for Semantic Web Service Retrieval 9
Life cycle operations are used for operations regarding the creation, update and
deletion of objects on a remote registry. The JAXR API defines a pair of interfaces
related to life cycle management that can be accessed through the RegistryService
interface. Following the JAXR model, the framework defines a set of interfaces
regarding life cycle operations, making adaptations whenever necessary. Figure 5
shows the class diagram for the life cycle management model.
BusinessLifeCycleManager lifeCycleManger =
registryService.getBusinessLifeCycleManager();
10 Doris Janssen, Alexandre Lins, Thomas Schlegel, Michael Kühner, Gerhard Wanner
BulkResponse response =
lifeCycleManger.saveServiceProfiles(profiles);
The framework must provide functionality for querying service descriptions. Figure 6
shows the class diagram for the query model for the framework.
BulkResponse response =
queryManager.findServices(profile, filters);
The proposed framework follows the response and exception model defined in the
JAXR API. This model specifies the BulkResponse interface that encapsulates
responses and exceptions returned by the registry. It defines methods that allow the
developer to access a collection of objects sent by the registry as response and a
collection of exceptions. The model also defines the RegistryResponse interface that
allows the developer to check the ID of the request that generated the response and
the status of the response. Figure 7 shows the class diagram for the response model.
The features defined in the RegistryResponse interface are important because they
provide support for asynchronous communication. This means that in the case of an
operation taking a lot of time to execute, the application does not need to block
waiting for the response. It can get the ID of the request provided by the
RegistryResponse and use it to check the response later on, using a method defined in
the RegistryService. The developer can use the status information or a specific
method to check if the response is already available. The code fragment below shows
how this can be done.
BulkResponse response =
lifeCycleManager.saveServiceProfiles(profiles);
...
BulkResponse response =
registryService.getBulkResponse(requestId);
5 Implementation
6 Conclusion
In this paper we have presented a Java framework for the discovery of Web Services
using registries based on OWL-S descriptions.
The overall idea behind this concept is to allow for semantic discovery and
retrieval of web-services using ontology standards and mechanisms that have been
and still are created by the semantic-web community. Such an integrative approach
forms a main step towards autarkic and self-organizing web-services, which compose
new services from existing ones worldwide by handling requests received from users
or other systems.
As a framework for such systems has to support different purposes and allow
interoperability and general interconnection, it should integrate semantic functionality
like OWL and OWL-S directory information and interpretation. For sure, a sole
OWL-S description for a web service in most cases will not suffice, additional
descriptions in other OWL dialects are necessary to describe a service fully. Our
approach is therefore, using JAXR as a standard, to provide an API that enables
developers to create and manipulate OWL-S service descriptions and perform
operations on remote registries. To accomplish this, the framework takes advantage of
A Framework for Semantic Web Service Retrieval 13
the basic design constructs of JAXR that provide support for connection, life cycle
and query management, thus expanding and adapting a standard interface for these
specific requirements.
This organization itself is a great advantage of the framework as it separates the
concepts of connection management, life cycle operations and query operations on
specific interfaces and abstracts the developer from implementation details. In
addition, the framework provides a set of interfaces and associated methods for
representing and manipulating OWL-S constructs inside a Java program, including
reading and writing service descriptions on the file system and other data sources and
sinks. As in practice domain specific OWL ontologies will be used in conjunction
with OWL-S descriptions, which makes necessary further research and
standardization activities concerning the question how to integrate these ontologies
without having to adapt the API each time new domains are introduced.
While UDDI has been chosen as the web service registry at the moment, the ability
to use UDDI semantically is very limited even though in version 2.0 and 3.0 some
improvements have been made. Taxonomies, which can be included in an UDDI
registry, offer some possibilities like inheritance retrieval, when the taxonomies used
are well-defined for that purpose. Further mechanisms are currently not available. As
soon as intelligent mechanisms like reasoning are needed, current specifications of
UDDI provide no more support. This leads to the suggestion of focusing on the
development of a semantic based registry standard in the near future. The
development and standardization of such a dedicated registry will be crucial for broad
access to the possibilities of semantic retrieval of web services.
7 Future Work
The next steps will be the improvement of the framework by reviewing and
improving the design constructs and fulfilling the need for including new methods for
accessing OWL-S registries. The specification and implementation are currently
being adapted to work with OWL-S version 1.0. Another important step is to provide
an implementation based upon a Matchmaker engine or an UDDI enhancement like
suggested by Akkiraju [5], as the current version is based on standard UDDI
registries. The ServiceModel and ServiceGrounding interfaces will be further
developed to provide a basis for invocation and composition modules. Finally, a
toolkit will derive from the combination of these modules and will allow the
developer to operate Semantic Web Services from a Java application.
The current results are available to the public as an open source project on
http://ssra.sourceforge.net.
Acknowledgements
This research has been conducted by the KOMPASS project, which is supported by
the German Ministry of Education and Research (BMBF).
14 Doris Janssen, Alexandre Lins, Thomas Schlegel, Michael Kühner, Gerhard Wanner
References
1. Christensen, E., Curbera, F., Meredith, G. and Weerawarana, S.: Web Services Definition
Language (WSDL) 1.1. Available at http://www.w3.org/TR/wsdl, 2001.
2. UDDI.org: The UDDI Technical White Paper. Available at
http://www.uddi.org/pubs/Iru_UDDI_Technical_White_Paper.pdf, 2000.
3. Martin, D., Burstein, M., Denker, G., Hobbs, J., Kagal, L., Lassila, O., McDermott, D.,
McIlraith, S., Narayanan, S., Paolucci, M., Parsia, B., Payne, T., Sirin, E., Srinivasan, N. and
Sycara K.: DAML-S and OWL-S 0.9 draft Release. Available at
http://www.daml.org/services/daml-s/0.9/, 2003.
4. Bechhofer, S., Harmelen, F., Hendler, J., Horrocks, I., McGuiness, D., Patel-Schneider, P.
and Stein, L.: OWL Web Ontology Language Reference. Available at
http://www.w3.org/TR/owl-ref/, 2003.
5. Akkiraju, R., Goodwin, R., Doshi, P. and Roeder, S.: A Method for Semantically Enhancing
the Service Discovery Capabilities of UDDI. Available at http://www.isi.edu/info-
agents/workshops/ijcai03/papers/Akkiraju-SemanticUDDI-IJCA%202003.pdf, 2003.
6. Duftler, M. J., Mukhi, N. K., Slominski, A. and Weerawarana, S.: Web Service Invocation
Framework (WSIF). Available at http://www.research.ibm.com/
people/b/bth/OOWS2001/duftler.pdf, 2001.
7. Kawamura, T., Paolucci, M., Payne, T. and Sycara K.: Semantic Matching of Web Services
Capabilities. In: Proceedings of the 1st International Semantic Web Conference (ISWC),
2002, pp. 333-347.
8. Mandell, D. and McIlraith, S.: Adapting BPEL4WS for the Semantic Web: The Bottom-Up
Approach to Web Service Interoperation. In: Proceedings of the Second International
Semantic Web Conference (ISWC2003), 2003, pp. 227--241.
9. Emerging Technologies Toolkit, IBM alpha Works Emerging Technologies, IBM
Corporation, Available at http://www.alphaworks. ibm.com/tech/ettk, 2004.
10.Ballinger, K., Brittenham, P., Malhotra, A., Nagy, W. A. and Pharies, S.: Web Services
Inspection Language (WS-Inspection) 1.0. Available at http://www-
106.ibm.com/developerworks/webservices/library/ws-wsilspec.html, 2001.
11.Najmi, F.: Java API for XML Registries (JAXR) version 1.0. Available at
http://java.sun.com/xml/downloads/jaxr.html, 2002.
12.ebXML: ebXML Technical Architecture Specification v1.0.4. Available at
http://www.ebxml.org/specs/ebTA.pdf, 2001.
13.Fikes, R., Hayes, P. and Horrocks, I.: DAML Query Language (DQL) Abstract
Specification. http://www.daml.org/2003/04/dql/dql, 2003.