354
Int. J. Web Engineering and Technology, Vol. 2, No. 4, 2006
A CASE tool for modelling and automatically generating web service-enabled applications Marco Brambilla*, Stefano Ceri, Sara Comai and Piero Fraternali Politecnico di Milano Dip. Elettronica e Informazione Via Ponzio, 34/5 20133 Milano, Italy E-mail:
[email protected] E-mail:
[email protected] E-mail:
[email protected] E-mail:
[email protected] *Corresponding author Abstract: This paper presents a CASE tool for the high-level specification of web applications integrated with web services. The CASE tool is based on WebML, a conceptual modelling language used for the specification of the front end of web applications. WebML, extended with new primitives for modelling web services, allows one to specify complex interactions between a web application, driven by the user, and remote processes, represented by services. The CASE tool also allows the specification and deployment of application functionalities as web services and automatically generates the running code, including web pages, web services calls and the exposed web services. In this paper, we describe the primitives for web services modelling, the architecture of the CASE tool for designing the applications, and the runtime architecture of the generated applications. Finally, we give an overview of some industrial applications developed with the described approach. Keywords: web engineering; web service; CASE tools. Reference to this paper should be made as follows: Brambilla, M., Ceri, S., Comai, S. and Fraternali, P. (2006) ‘A CASE tool for modelling and automatically generating web service-enabled applications’, Int. J. Web Engineering and Technology, Vol. 2, No. 4, pp.354–372. Biographical notes: Marco Brambilla is an Assistant Professor at Politecnico di Milano. His research interests include web modelling methodologies, web design patterns, and conceptual design of data-intensive web applications. He has collaborated as an Application Analyst in several industrial projects with the WebRatio team. Stefano Ceri is Full Professor of Database Systems at Politecnico di Milano. His research interests are focused on extending database technology to incorporate data distribution, deductive and active rules, object-orientation, and semantic models and design methods for data-intensive websites. He was Associate Editor of ACM-TODS and is currently an Associate Editor of several international journals, including IEEE-TSE. He won the VLDB Ten Years Award in 2000.
Copyright © 2006 Inderscience Enterprises Ltd.
A CASE tool for modelling
355
Sara Comai has a PhD in Computer and Automation Engineering and is currently an Assistant Professor at Politecnico di Milano. Her main research interests include active databases, graphical languages for querying and restructuring semistructured data, and conceptual modelling of data-intensive web applications. Piero Fraternali is Full Professor at Politecnico di Milano. His research interests focus on active rules, object-orientation, design methods for data-intensive websites, CASE tools for automatic website production and multi-channel applications. He is coauthor of the books ‘Designing database applications with objects and rules: the IDEA methodology’ (Addison Wesley, 1997) and ‘Designing data-intensive web applications’ (Morgan-Kaufmann, 2002).
1
Introduction
The web has recently become the standard implementation platform for B2B applications supporting business processes, content management, document approval flows and valueadded services. This leads to the integration of several technologies, far beyond the simple implementation of web interfaces for content publishing. Web services are proving to be a good paradigm for communication and interoperability between applications; however, they are not meant as an interface for human users participating in business processes. Therefore, the need arises for engineering user-friendly, platform-independent, low-cost, efficient, and – perhaps most important – correct interfaces for humans, who enact complex application workflows communicating with web services. The navigational paradigm of web interfaces, whereby users interact by activating links and/or providing input, is becoming extremely popular also in the B2B scenario, thanks to its unprecedented user friendliness. For building web applications, several research groups advocate the use of declarative design languages (for a survey see Fraternali, 1999), to raise the focus of development from the source code to abstract and platform-independent models, enabling fast prototyping, automatic code and documentation generation, and model-level correctness checking. The industry is also embracing this approach, as witnessed in the increasing interest in the use of UML and other notations for web applications (Conallen, 2002). However, none of the proposals focusing on the development of web applications considers interaction with remote processes. Among recent proposals using services, the ActiveXML system (Abiteboul et al., 2003) manages XML applications and document composition, including calls to services, but does not consider web interfaces and user interaction. The well-known BEA Workshop1 tool allows developers to specify web applications and web services, but with a limited high-level view of the application, because it concentrates on the implementation tasks. The goal of this paper is to describe the implementation of new conceptual primitives for web services invoked within web applications or exposed by the application. The paper builds upon an existing web modelling language called WebML2 (Ceri et al., 2002), a graphical notation for the specification of web applications, close to conceptual methodologies like UWE (Koch and Kraus, 2002), W2000 (Baresi et al., 2000) and OO-HMETHOD (Gomez et al., 2001) (based on UML interaction diagrams). In Manolescu et al. (2005) WebML has been extended with a set of novel primitives that
356
M. Brambilla, S. Ceri, S. Comai and P. Fraternali
support various forms of interplay between web applications and web services. The resulting model can be used for designing web applications, mixing the use of traditional data sources (e.g., relational databases) and web services, as well as for specifying new web services, by composing existing services, local data sources and also user interaction. In this paper we show how the proposed approach has been implemented by the CASE tool WebRatio.3 The tool offers a uniform and coherent environment for visually specifying web interfaces for human users and web service interfaces for remote peers. The design environment is equipped with a code generator that deploys the specified application and web services in the J2EE platform, by automatically generating all the necessary pieces of code, including data extraction queries, web service calls, data mapping logics, page templates and WSDL service descriptors. The tool also supports information marshalling between the XML format (used by web services messages) and the relational format (usually used by most enterprise web applications). To facilitate the XML-ER data-mapping task, a visual model for the transformation has been studied and a simple XSL generator tool has been developed. The paper is structured as follows: Section 2 describes the running example that will be used throughout the paper to motivate the proposed approach. Section 3 gives an overview of the main characteristics of the WebML language. Section 4 introduces the basic concepts of the WSDL classes of web service operations. Sections 5 and 6 present the approach to web applications and web services integrated design and web service publishing supported by the CASE tool, while Section 7 addresses the problem of data marshalling. Section 8 describes the architecture of the modelling tool and of the generated web applications. Section 9 presents some industrial cases that have been addressed using our approach. Finally, Section 10 concludes the paper.
2
Running example
The running example consists of a Small-Medium Enterprise (SME) that needs to integrate its operations with its supply chain partners. This case is inspired by a suite of industrial applications that has been implemented for a set of SMEs in the mechanical field of a local district (see the MetalC project description in Section 9). The example assumes that interaction between different companies can be enacted only through web services, which are integrated in modern web application front-ends or wrap possible legacy systems. Each company is provided with a web portal, and we assume that all the companies are provided with the same portal structure. Each partner may ask services of other partners, and in turn offer them the same services, as shown in Figure 1. The web portal can be used by its employees, who can perform all the routine tasks without needing to switch to other websites or to other applications. In the portal, employees can find interfaces for asking other partners for quotations, and for submitting orders to other partners. This is implemented by means of hypertexts that include web service calls to services published by the provider, thus consuming remote services.
A CASE tool for modelling
357
The portal offers the dual set of services to remote peers (for instance, company customers) who can ask for a quotation, submit an order, and so on. The employees of the company are provided with an interface for managing the requests and providing the responses. Finally, an additional news service allows customers to subscribe to the newsletter of the company. Interaction between companies is hidden beneath the front-end interface of each portal and is implemented through web service exchanges. Figure 1
3
SME running example
Background on WebML
The specification of a WebML application consists of a data schema (represented as a standard Entity-Relationship (E-R) model) describing application data, and of one or more hypertexts (e.g., for different types of users or for different publishing devices), called site views, expressing the web interface used to publish this data. A site view is a graph of pages (possibly clustered into areas), consisting of connected units, representing at a conceptual level atomic pieces of homogeneous information to be published: the content that a unit displays is extracted from an entity, possibly filtered. Unit sites are normally connected by links carrying data from a unit to another, to allow the computation of the hypertext. WebML also allows specifying of update operations on the data underlying the site (e.g., the creation, modification and deletion of data instances) or operations performing arbitrary business actions (e.g., sending e-mails). We explain the main concepts of WebML in the running example. For further details about the language, the reader may refer to Ceri et al. (2002). Figure 2 shows the E-R schema describing the local database of a partner of the SME application. The schema also describes the users of the web applications, grouped into different classes (e.g., employees and customers). A different site view (hypertext) is associated with each group of users. Users can submit quotations for the products of the partner, and possibly issue an order for those products. Moreover, users can subscribe to a newsletter (represented by the NewsSubscription entity and its relationship with the User entity) for selected topics and periods of delivery; finally, the News entity models the news issued in connection with a specific subscription. For the sake of readability the model includes only the entities for offering services to the user. Dual entities and relationships are defined to invoke the same services provided by the other SME partners.
358
M. Brambilla, S. Ceri, S. Comai and P. Fraternali
Figure 3 shows a simple example of hypertext modelling published by the SME: employees can browse the quotation list and create new products. They can enter the SME web application using its Home page, which may contain static, unmodelled content; a link leads to the Quotations page, located in the Quotations area and containing an index of quotations; and the selection of a quotation from the index leads to the Quotation page, showing the quotation details and the index of the products it refers to. This is possible thanks to the mechanism of parameter passing, which is implemented by the link; indeed, besides providing navigation paths, links allow the transfer of information from a unit to another by means of parameters. The InsertProduct page contains the NewProduct entry unit, denoting a form for user input. NewProduct is connected to the CreateProduct operation unit. When the user submits the data by navigating the outgoing link of the entry unit, the data are passed to the create unit, which inserts a new product instance in the database. Subsequently, the user is led to the Product page, where the details of the newly created product are displayed. Figure 2
Data model of the SME portal running example
Figure 3
A fragment of the hypertext model of the SME portal running example
A CASE tool for modelling
4
359
Specification of web services
To describe web services interactions, WebML has been extended with web service units, implementing the WSDL classes of web service operations. We start by recalling some basic aspects of WSDL,4 providing the foundation of the proposed WebML extensions. A WSDL operation is the basic unit of interaction with a service, and is performed by exchanging messages; messages sent by the client to the service are called input messages, and messages sent by the service output messages. Two categories of operations are initiated by the client: 1
One-way operations consist of a message sent by the client to the service.
2
Request-response operations consist of one request message sent by the client and one response message built by the service and sent back to the client.
Two other operation categories are initiated by the service: 1
Notification operations consist of an output message sent to the client.
2
Solicit and response operations are devised for receiving a request message from the client and providing one output message as a response to the client.
The CASE tool supports both categories of operations. In particular, we interpret the operations initiated by the service as web services publishing operations. Therefore, we assume that these operations will not be used within the traditional hypertext schemas representing the website, but within appropriate Service views, which contain the definition of published services. The operations initiated by the client are instead integrated within the specification of the web application. In the following subsections, we will see how they can be specified in WebML and present some examples applied to the SME application.
5
Modelling web applications integrated with web services
The specification of web service invocation within a web application is achieved through the introduction of new operations, presented in the following paragraphs. One-way operation The simplest WebML primitive modelling interaction with a web service is the one-way operation, an example of which is seen in Figure 4. This operation is represented by the one-way unit, whose icon is labelled with the web service operation name and includes a single arrow that represents the message sent by the application to the web service. The one-way unit is triggered when the user navigates one of its input links; from the parameters transferred by these links, a message is composed, and then sent to a remote service as a request. In the example in Figure 4, from the Home page of the SME application, users can navigate through a link to the News Subscription page (carrying no parameters), where they can subscribe to the news delivery service offered by another SME web portal. To create such a subscription, the user must enter a topic and the period of interest in the fields of the Enter Data entry unit. The navigation on the output link of the entry unit
360
M. Brambilla, S. Ceri, S. Comai and P. Fraternali
triggers a chain of two operations: first, the new subscription is recorded in the local database of the SME application, and second, the Subscription operation of the SME web service (see Figure 1) is called to actually register the subscription at the service provider. After the one-way message is sent, the user is returned to the SME Home page. Figure 4
Example of usage of one-way operation
Request-response operation The WSDL request-response operation is modelled through the request-response unit, whose graphical notation is shown in Figure 5. This operation involves two messages: the input message sent to the service and the output message received from the service. Its icon is labelled with the web service operation name and includes two arrows that represent the input and output messages. Like the one-way operation, the request-response operation is triggered when the user navigates one of its input links; from the parameters transferred by these links, a message is composed, and then sent to a remote service as a request. The user waits until the arrival of the response message from the invoked service; she then can resume navigation from the page reached by the output link of the web service operation unit. Figure 5
Example of usage of request-response operation
A CASE tool for modelling
361
In the example in Figure 5, the employee can browse to the SupplySearch page, in which the SearchProducts entry unit permits the input of search criteria, such as the code of the product or a keyword. From this information, a request message is composed and sent to the RemoteSearch operation of the web service exposed by another SME company (see Figure 1). The user then waits for the response message containing a list of products satisfying the search criteria. From these options, a set of instances of the SearchedProduct entity are created, and displayed to the user by means of the Products index unit; the user may continue browsing, e.g., by choosing one of the displayed products and looking at its details. Notice that no action can be performed by the user between the two messages exchanged in the web service operation. In Brambilla et al. (2004) the concept of a request-response operation has been extended with the possibility of exchanging the two messages asynchronously, i.e., some action taken by the user may occur between the two messages exchanged in the web service operation. Currently, asynchronous operations are not supported by the CASE tool.
6
Modelling web services publishing
The tool also supports the publication of web services that can be invoked by third-party applications. From the application point of view, no user interaction is required in a published web service. The actions to be performed when the notification or the solicit-response operations are triggered are not specified through pages, but as a chain of operations (e.g., for storing or retrieving data, or for executing generic operations such as sending e-mails). Therefore the publishing of web services can be specified separately from the site view of a web application. We introduce the following concepts for the publishing of web services: •
Service view – it is a collection of ports which expose the functionality of a web service through operations.
•
Port – it represents the individual service, composed of a set of operations, each of them modelled through a solicit-response and/or notification operation.
An operation (in the WSDL sense) is described by a chain of WebML operations, which specify the actions to be performed as a consequence of the invocation of the service, and possibly to build the output message to be sent back to the invoker. Each WSDL operation starts with a special operation unit called solicit unit that triggers the service, and possibly ends with the response unit, which provides an output message. Notification operation The notification operation is modelled through a chain of operations starting with the solicit unit, whose graphical notation is shown in Figure 6. The hypertext represents the specification of the NewsManagementPort, consisting of a single chain of actions performed by the web application, upon the arrival of a new subscription from a partner. The port contains the solicit unit SolicitSubscription, representing the reception of a message containing data relative to a subscription. The solicit unit is linked to a chain of two operations. First, a create unit inserts the NewsSubscription instance into the local
362
M. Brambilla, S. Ceri, S. Comai and P. Fraternali
database; second, a connect operation associates the NewsSubscription instance with the user it refers to, extracted from the XML message of the notification operation. This schema is the dual specification of the NewsSubscription service invocation represented in the example in Figure 4. Figure 6
Example of usage of the notification operation
Solicit-response operation The solicit-response operation extends the notification operation by allowing the composition of the response message: this task is performed through the response unit, whose graphical notation is shown in Figure 7. This picture represents the RemoteSearch service implementation: some search criteria are received and the corresponding products are provided as output of the service. The WebML diagram is similar to the one in Figure 6: the interaction starts with the solicit unit SearchSolicit, which denotes the reception of the message. Upon the arrival of the message, an XML-out operation is executed, which extracts from the database the list of products that correspond to the specified conditions, and formats the result as an XML document. More details on the XML-out unit are provided in Section 7.2. In contrast with Figure 6, the operation chain now terminates with the SearchResponse unit, receiving as input the produced XML document, which can be used as a response message for the invoking web service. This schema is the dual specification of the RemoteSearch service invocation represented in the example in Figure 5. Figure 7
Example of usage of the solicit-response operation
A CASE tool for modelling
7
363
Modelling data marshalling and unmarshalling
Despite the current trends towards service-oriented architectures and semi-structured data models (e.g., XML), several enterprise applications still rely on relational databases. This aspect cannot be ignored, since web services are often used just to wrap existing information systems and databases. Thus, to represent the stored and managed data, applications usually rely on the E-R model, while WS messages follow the XML Schema standard. Invoking a web service within an application requires the ability to: •
construct an XML-structured message (e.g., a request message) by extracting E-R data from a relational database
•
decompose an XML-structured message (e.g., in a response message) into E-R data to be stored and then manipulated in the database.
7.1 The canonical XML format For facilitating the transformation of data from E-R to XML format and vice versa, we have defined a canonical XML format, which corresponds to the E-R model, with XML elements representing entities, relationships and their attributes. Figure 8 shows an example of the canonical XML representation of a piece of E-R diagram. Element includes, for each entity, the set of instances with respective attributes, while element includes all the instances of the E-R relationships, described by source and destination object identifiers. Figure 8
Canonical XML fragment
user1 Smith subscr1 New products subscr2 Events user1 subscr1 user1 subscr2
The benefits of the canonical XML format are twofold:
364
M. Brambilla, S. Ceri, S. Comai and P. Fraternali
1
It provides a standard format for describing relational data stored in the native format of the application.
2
It facilitates the construction and decoding of the input and output messages necessary to interact with web services.
An incoming XML message, which conforms to its own service-dependent XML Schema, needs only to be converted into the canonical XML format to be automatically inserted into the E-R data repository; in a dual manner, the E-R content of the data repository can be automatically extracted as a piece of canonical XML, which simplifies its translation into the XML Schema required by the web service. Using the XML canonical form, the XML-ER data-mapping (and the converse mapping) problem is reduced to defining the transformations between the generic web service XML message and the canonical XML representation (and vice versa). This can be achieved by means of ordinary XSLT transformations.
7.2 Additional WebML primitives for data marshalling and unmarshalling The transformation of E-R content into XML and vice versa is specified with the help of three additional WebML units, illustrated in Figure 9. Figure 9
XML-in, XML-out and adapter units
The XML-in unit takes as input a canonical XML fragment and stores in the underlying E-R repository the value of a specific property of the unit. From the physical viewpoint, the storage can be done either in main memory (in which case the lifespan of the stored information is the user session), or persistently in the database. The XML-out unit allows the selection of a set of objects belonging to an E-R subschema from the data repository and outputs their content as an XML fragment conforming to the canonical XML Schema. The Adapter unit takes in input n links carrying XML fragments, and emits along an output link another XML fragment with the desired schema and content. All the XML-XML transformations (including those involving the canonical XML format of the data) are currently expressed using XSLT, and are supported by a visual transformation tool, which is described next. The XML-in, XML-out and adapter units are necessary to express the data transformation tasks required by the exchange of messages with web services. In the previous examples we have omitted these units from the WebML diagrams for the sake of readability. You can see a complete specification example, including both the web service and the data transformation operations, in Figure 7: the XML-out unit is in charge of generating the XML canonical form of the subschema describing the Product list.
A CASE tool for modelling
365
7.3 Visual XSL generator tool In this section, we briefly examine the possible cases necessary for mapping generic XML data to the canonical XML structure, and a tool that has been developed for the visual design of such mappings. The converse mapping can be obtained in a symmetrical way. An XML element that is mapped to a database entity, and univocally identified through one of its elements or attributes (called Key), may be associated with other XML elements in three ways: 1
It may be associated with one of its nested elements.
2
It may be referenced by other elements in the XML document through its Key. In this case the association is called Reference by key.
3
It may be associated with any other XML element through an intermediate XML element called Bridge, which pairs off the Keys of the associated XML elements.
These three kinds of XML association can be used for building entities with attributes and with relationships in the E-R model. In particular, appropriate transformation rules may be used to indicate the creation of (a) a database entity and (b) a database relationship. Depending on the kind of association, different transformation rules apply. To facilitate the XML-ER data-mapping task, a visual XSL generator tool has been developed and integrated in the CASE tool GUI. The XSLT file used to transform XML fragments into a desired E-R structure (in particular, in the XML canonical form) is generated by the tool, without requiring any manual XSL programming. The tool accepts as input: •
an XML example message or a WSDL file, which can be selected by the user to automatically obtain the structure of the input or output web service message
•
an XML description (XML canonical form) of the relational schema of the database that is implemented at the relevant peer.
The GUI is divided into two parts: the left-hand side represents the structure of the XML message, while the right-hand side represents the structure of the canonical form of the underlying E-R schema (or a subpart of it, if only some entities/relationships are involved in the transformation). By connecting nodes in the two trees, the developer defines the transformations to be supported by the generated XSLT file. The connections are either direct edges between XML elements and entities/relationships, or more complex transformations denoted by means of ‘mapping boxes’. The available transformation box types are visible in the toolbar at the top of the interface and support some very basic transformation rules that have been recognised as the most widely used in marshalling XML messages to relational format. Figure 10 shows a very simple transformation from the SOAP message that contains the result of a RemoteSearch invocation (which provides a set of products of the supplier), and the local database storing the products. The Product XML element on the left is the source of the transformation and is mapped onto the Product entity on the right. Its sub-elements (code, name and price) are mapped onto the respective attributes of the Product entity.
366
M. Brambilla, S. Ceri, S. Comai and P. Fraternali
Figure 10
‘E IDREF’ mapping box for database entity creation
Once all the needed transformation edges and boxes have been specified, the necessary XSL files for the transformation can be automatically generated by the mapping tool. The generated transformation includes two steps: 1
The first step consists of inserting the needed key attributes (unique identifiers of tags) in the XML file to guarantee the unique properties of XML elements, which is fundamental for obtaining correct transformations.
2
The second step consists of the actual transformation rules represented in the visual diagram.
To define transformations from an E-R representation to an XML document, the XSL generator can be used in the symmetric way.
8
Architecture of the implementation
This section presents an overview of the CASE tool architecture for the specification of web applications and web services, the deployment architecture of the generated web applications, and a comparison with related products currently on the market.
8.1 WebRatio tool architecture WebRatio supports the WebML design process (Ceri et al., 2002), consisting of the two main phases of data design and hypertext design, and supports implementation by automating the production of the relational database and of the application page templates. More precisely, WebRatio focuses on five main aspects: 1
Data design – supports the design of Entity-Relationship data schemas, with a graphical user interface for drawing and specifying the properties of entities, relationships, attributes and generalisation hierarchies.
2
Hypertext design – assists the design of site views, providing functions for drawing and specifying the properties of areas, pages, units and links. The hypertext design also includes the integration of the web services primitives presented in Sections 5 and 7, and the specification of service views introduced in Section 6.
A CASE tool for modelling
367
3
Data mapping – permits declaring of the set of data sources to which the conceptual data schema has to be mapped, and automatically translates Entity-Relationship diagrams into relational databases and views.
4
Presentation design – offers functionalities for defining the presentation style of the application, allowing the designer to create XSL style sheets and associate them with pages, and organise page layout, by arranging the relative position of content units in the page.
5
Code generation – automatically translates site views into running web applications built on top of the Java2EE, Struts and .NET platforms.
The diagram of Figure 11 summarises the design flow of WebRatio, highlighting the design phases, together with their inputs and outputs, and also represents its architecture. The tool consists of two layers: a design layer, providing functions for the visual editing of specifications (supporting data, hypertext and presentation design and data mapping), and a runtime layer, implementing a Model View Controller (Buschmann et al., 1996) web application framework. These layers are connected by the WebRatio code generator, which exploits XML transformations to map the visual specifications edited in the design layer into application code executable at the runtime layer. Figure 11
WebRatio architecture
The design layer, code generator and runtime layer have a plug-in architecture: new components can be described using XML descriptors and made available to the design layer as custom WebML units. The code generator can be extended with additional XSL rules to produce code wrapping the plug-in components, and the components themselves can be deployed in the runtime application framework. Such plug-in architecture has been exploited to extend the WebRatio tool with the web services primitives. For supporting web services, the site design component has been extended with the concept of service view and the set of hypertext primitives that are needed for services modelling. The tool also supports further functionalities for:
368
M. Brambilla, S. Ceri, S. Comai and P. Fraternali
•
Correctness checking – one of the benefits of conceptual modelling is the possibility of automatically checking for errors already at the design level: in particular, it is possible to verify the correctness of the data and hypertext diagrams, to check if the elements of the data schema are correctly mapped to the data sources, and to check if each page is associated with all the information needed for generating the final template.
•
Automatic production of project documentation – project documentation can be generated in a format called WebMLDoc, inspired by the popular JavaDoc documentation layout.
•
Collaborative work and project version management.
•
Database direct and reverse engineering.
8.2 Deployment architecture of generated web applications Figure 11 represents the deployment architecture of the application generated by the tool, which is compliant to the Model-View-Controller (MVC2) architecture. According to this architecture, each WebML element maps into different components of the MVC2 architecture. For further details the reader may refer to Ceri et al. (2003). Deployment and publishing of web services required an extension of the WebRatio runtime framework. The tool must be able to accept SOAP requests; therefore the web front end is extended with a SOAP listener. We also extended the site generation algorithm to produce descriptors for each of the new web service publishing primitives. Figure 12
Runtime architecture of the web applications generated by WebRatio
8.3 Product comparison Other vendors are proposing tools oriented towards web development; however, most of them have only adapted to web environment from other fields. Among them, we can cite the following products:
A CASE tool for modelling
369
•
Oracle JDeveloper 10g5 is heavily oriented towards database design (Oracle), and provides UML-like data modelling and a very basic navigation model.
•
Code Charge Studio6 (Code Charge) provides a GUI for designing web applications based on a set of predefined ‘page types’, corresponding to database tables.
•
Borland Enterprise Studio for Java7 (Borland) is basically an advanced IDE tool, integrating some modelling features from TogetherJ and basic WYSIWYG interfaces.
•
Rational Rapid Developer8 (Rational) consists of a UML design tool, adapted to the web environment, where automatic code generation is provided just for the business logic layers (model), while JSP (or analogous) pages must be coded by hand.
All these tools work at a lower level with respect to WebRatio, providing a good development solution for the implementer, the web designer or the programmer, without considering the option of full-fledged high-level modelling of web applications.
9
Implemented applications
The concepts presented in this paper have proved valid on the field. Several case studies have been implemented, thus validating and refining the approach. The most relevant applications include MetalC, a complex application including a set of B2B portals, one for each business partner; Acer Business Portal, an application invoking and defining remote service calls for providing location and driving information to users, and supporting workflow-based interaction between Acer and its commercial partners; Tiscover Tourism Application, a tourism broker web application which leverages several third-party tourism sources through web services and in turn provides to its customers (travel agents and hotel managers) a set of integrated web services that responds to their specific needs.
9.1 The MetalC platform The purpose of the MetalC project is to allow business interactions between small Italian companies of the mechanical sector by means of their respective web portals, through web services calls. Complex web services interactions have been put in place, to grant reliable cooperation between the companies. For example, the purchasing process in a B2B scenario consists of a very complex set of interactions, since the buyer typically asks for a quote, the seller makes his offer, and the buyer then sends his order for the best offer. In this context, exceptions management becomes very critical and must be carefully addressed. In the implemented communication platform, this is implemented through a set of web portals, pertaining to each company, which interacts with the portals of other actors of the value chain by means of web services-based message exchanges.
370
M. Brambilla, S. Ceri, S. Comai and P. Fraternali
9.2 Acer-Euro Business Portal The Acer-Euro Business Portal is a multicountry, multilingual, multiuser-hosted web application connecting European subsidiaries and partners to the services embedded in the company’s enterprise applications (e.g., order tracking, technical information management and marketing information management). The ultimate goal of the business portal is to standardise the communication processes of the various channel operators, especially in the areas of inventory and sales management. One of the main requirements of the Acer portal is the retrieval of information from third-party remote services. To grant remote services interaction capabilities, WebML primitives, for supporting web services publishing and invocation and the data conversion operations, have been exploited. Acer also needs to provide web access to the repository of marketing materials, stored in a native XML repository. In the application, queries are modelled and implemented through calls to the web service interface exposed by a native XML database. The XML data retrieved through web service calls from the XML repository can be locally stored in the application database for subsequent reuse or in the session storage for temporary usage. Given that the involved XML trees have a limited depth, the XML structure is represented by using one table for the root element of the document, connected to further tables representing nested sub-elements.
9.3 Tiscover Tourism Services The Tiscover Tourism Services Application, developed by a leading international tourism broker, extends an existing tourism management system with feature-rich web services. The deployed web services are made available to travel agents and hotel managers, who can provide their customers with personalised and accurate access to a lot of tourism information, including data from heterogeneous sources (weather conditions, events, etc.). The main goal of Tiscover was the integration of different data sources and the presentation of contents within online documents, i.e., reports with up-to-date information from heterogeneous sources, to be added to specialised brochures built up on the basis of individual preferences, or for a peculiar client (such as a hotel manager or a tourist office). Generated reports are transmitted to clients (via both push and pull strategies) and can be transformed into a printer-friendly version to be used as offline media. The retrieval of the data and the communication with remote tourism and news services have been supported by web services.
10 Conclusions The proposal and CASE tool presented in this paper demonstrated the potential of combining declarative design of web applications and web services, typically used as communication interfaces for implementing complex processes. The CASE tool relies on WebML, a model (with associated graphical notation) for designing web applications and extended to support WSDL web service primitives and the management of XML messages. We have also discussed the architectural extensions necessary to support web services in a WebML-specified website.
A CASE tool for modelling
371
The implementation of the industrial applications described in Section 9 have proven good field experiments for evaluating the power of high level modelling of application integration. The developed applications demonstrated that high-level design, graphical notations and conceptual modelling are a good tool for designing complex applications and for integrating them. Enormous advantages have been recognised in various aspects: resource savings, time-to-market improvement, focalisation on key tasks of the development, and overall quality of the resulting applications.
Acknowledgements We wish to thank Ioana Manolescu and Christina Tziviskou for the useful comments and suggestions on the proposed approach. We are also grateful to the WebRatio team for interesting discussions about the implementation of the topics presented in this paper.
References Abiteboul, S., Bonifati, A., Cobéna, G., Manolescu, I. and Milo, T. (2003) ‘Dynamic {XML} documents with distribution and replication’, Proceedings of the 29th ACM SIGMOD International Conference on the Management of Data, San Diego, CA, USA: ACM, pp.527–538. Baresi, L., Garzotto, F. and Paolini, P. (2000) ‘From web sites to web applications: new issues for conceptual modeling’, Proceedings of the ER 2000 Workshops on Conceptual Modeling Approaches for E-Business and the World Wide Web and Conceptual Modeling, Salt Lake City, UT, USA: LNCS Springer, pp.89–100. Brambilla, M., Ceri, S., Passamani, M. and Riccio, A. (2004) Managing Asynchronous Web Services Interactions, ICWS, Vol. 2004, pp.80–87. Buschmann, F., Meunier, R., Rohnert, H., Sommerlad, P. and Stal, M. (1996) Pattern-Oriented Software Architecture, John Wiley and Sons. Ceri, S., Fraternali, P., Acerbis, R., Bongio, A., et al. (2003) Architectural Issues and Solutions in the Development of Data-Intensive Web Applications, CIDR2003, Asilomar. Ceri, S., Fraternali, P., Bongio, A., Brambilla, M., Comai, S. and Matera, M. (2002) Designing Data-Intensive Web Applications, Morgan-Kaufmann, December. Conallen, J. (2002) ‘Building web applications with UML’, Object Technology Series, 2nd ed., Addison Wesley. Fraternali, P. (1999) ‘Tools and approaches for developing data-intensive web applications: a survey’, ACM Comput. Surv., Vol. 31, No. 3, pp.227–263. Gomez, J., Cachero, C. and Pastor, O. (2001) ‘Conceptual modeling of device-independent web applications’, IEEE MultiMedia, Vol. 8, No. 2, pp.26–39. Koch, N. and Kraus, A. (2002) ‘The expressive power of UML-based engineering’, Second International Workshop on Web Oriented Software Techonlogy, CYTED, pp.105–119. Manolescu, I., Brambilla, M., Ceri, S., Comai, S. and Fraternali, P. (2005) ‘Model-driven design and deployment of service-enabled web applications’, TOIT, August, Vol. 5, No. 3.
372
M. Brambilla, S. Ceri, S. Comai and P. Fraternali
Notes 1 2 3 4 5 6 7 8
BEA Weblogic Workshop, http://www.bea.com/content/products/workshop/. www.webml.org www.webratio.com W3C, WSDL Web Service Description Language, https://www.w3.org/2002/ws/desc. Oracle JDeveloper 10g, http://www.oracle.com/tools. Code Charge Studio, http://www.codecharge.com/studio. Borland, Enterprise Studio for Java, http://www.borland.com/ estudiojava. Rational Rapid Developer, http://www.ibm.com/ software/awdtools/rapiddeveloper.
