A Guide to Creating C++ Web Services - WHITE PAPER - Atomki
←
→
Page content transcription
If your browser does not render page correctly, please read the page content below
A Guide to Creating C++ Web Services
WHITE PAPER
Abstract
This whitepaper provides an introduction to creating C++ Web services and focuses on:
» Challenges involved in integrating C++ applications with Web services
» Benefits of using C++ Web services
» An example showing step by step how to create and implement a C++ Web service
» Advanced Web services features
Introduction
This paper describes how to develop and host high performance C++ Web services, including using advanced
XML, SOAP, and WSDL productivity tools for transforming new and existing C++ applications for use in
Service Oriented Architectures (SOA).
The focus is on HydraExpress, part of the Rogue Wave® Hydra Suite, which also includes the HydraSDO™
data components that implement the Service Data Object (SDO) specification, and HydraSCA, the first product
available for deploying high-performance SOA applications based on the Service Component Architecture
(SCA) specification. The SDO and SCA specifications are multi-language industry SOA specifications available
in both Java and C++.
Challenges of Integrating C++ with Web Services
Over the years, many organizations have made significant investments in C++ and now need to leverage
the business logic locked in these applications. However, web service technologies are focused in Java and
Microsoft .NET, making it difficult to address systems created outside of these environments.
Integrating C++ applications using Web services is a formidable challenge because:
» Web services require foundation pieces not supplied by C++ platform/libraries, including critical protocol
implementations such as HTTP requests and responses.
» Since C++ is a “compile time” language it is difficult to map it with dynamic systems like Web services.
» C++ is a very high-performance language, but writing scalable, threaded infrastructure code can be very
complicated.
Often, new “message bus” middleware is purchased to address this challenge. Message bus products provide
a C++ API and may require significant changes to the existing application. The middleware then uses costly
“bridges” to communicate with the rest of the enterprise, thereby providing access to the C++ application. The
WHITE PAPER PAGE 2
use of middleware creates a tightly coupled system by tying the C++ application to only that message bus and
its ability to provide compatibility with the rest of the enterprise. This is not only time consuming and error
prone, but reduces flexibility compared to Web services which, once exposed from the C++ application, can be
easily linked to the rest of the enterprise.
Building C++ Web Services
Using a lightweight framework such as HydraExpress provides an alternative to heavyweight middleware like
CORBA. By providing an intuitive and powerful framework based on standards such as HTTP, SOAP, WSDL,
and XML, development costs are reduced and it is possible to rapidly modify applications as business needs
change. Developers can quickly transform a monolithic application into C++ Web Services that can natively
interact with all other parts of the technology infrastructure.
Code generation technology provides a customized, service-specific programmatic interface built upon a robust
framework for communicating with other processes. The high-level interface generated by HydraExpress
interacts with the underlying framework, which in turn handles the details of various networking, XML, and
Web Services standards. This approach separates the business logic code from the underlying communication
framework, ensuring long-term flexibility and compatibility.
Web services fabrication products like HydraExpress support the SOA approach by making it easy to create
Web services from both new and existing business processes. Once exposed through a Web service, these
processes can interact with other WebsServices anywhere on the network, regardless of the technology that
underlies these services.
Message formats in HydraExpress are based on the SOAP protocol, a widely accepted, easy-to-use mechanism
for transferring messages over a network. As shown below, to use HydraExpress, developers supply a standard
Web Services Description Language (WSDL) file. HydraExpress automatically generates a skeleton service that
handles the details of protocols, standards and networking to ensure interoperability. Developers then drop in
new or existing C++ business logic to create a ready-to-deploy service that can be used in many types of SOA
applications.
SOA Application
HydraSCA
OYS TO
s s C++ DEP
L
WSDL x pre Service/
raE
FEEDS INTO PRODUCES
d Web Service D
Hy EPL
OYS
TO
SOA Application
Custom or 3rd
party
WHITE PAPER PAGE 3
Accelerating C++ Web Services Development
There are several advantages to using a framework to develop C++ Web services. These include:
» Application quality. The reliable technology of a well-established framework such as HydraExpress
delivers proven scalability and performance, freeing you to focus on your business logic rather than the
infrastructure of your service-oriented application.
» Efficient evolution. The modular design of HydraExpress enables you to quickly adapt the application as
your business needs change, allowing you to modify only the areas that require adjustment.
» Faster time-to-market. HydraExpress improves developer productivity so you can deliver effective
service-oriented applications on schedule and on budget.
» Cost savings. With HydraExpress, you can achieve the flexibility of service-oriented applications while
leveraging your existing investments where it makes sense, drastically reducing the need to rewrite, test
and optimize proven application logic.
HydraExpress features:
» A high-performance XML parser
» A robust container for hosting C++ Web Services and Servlet servers
» Automatic generation of C++ server skeletons built to run inside the HydraExpress container
» Automatic generation of Web service clients from WSDL files
» Easy-to-use XML-to-C++ data binding utility
» Extensive native-code cross-platform networking foundation
» Pluggable transport that supports Websphere® MQ and Tibco Rendezvous™
» Seamless upgrade to HydraSCA
A Simple Step-by-Step Example
This example takes you through the process of creating a C++ Web service, a WSDL file that defines the Web
service, and a SOAP-based client.
The basic steps involved in creating and deploying a C++ Web service and client are as follows:
1. Install the HydraExpress software
WHITE PAPER PAGE 42. Set up the environment
3. Invoke the generator by passing it the WSDL file
4. Implement the service and client
5. Compile the service and client
6. Deploy the service
7. Run the service and client
The WSDL file used in the example describes a Greeting Service that has a single operation (sayHello) which
takes a string as input and returns a string as output. The WSDL file can be found in the HelloWorld tutorial that
is available with the HydraExpress evaluation.
Now to look at the steps in more detail:
1. Install the HydraExpress evaluation.
Download the HydraExpress evaluation for Windows or Linux from
http://www.roguewave.com/download-center/ and follow the setup instructions.
2. Set up the environment
i. Ensure that your C++ compiler is set up in your environment and available in the PATH
environment variable
ii. Set the JAVA_HOME environment variable to your JDK installation
iii. On UNIX/Linux set the RWSF_HOME environment variable to the HydraExpress root directory
iv. Run the script rwsfvars located in the HydraExpress root directory
Further information on configuring the environment is available in Section 2.3 of the HydraExpress User’s
Guide which is provided with the HydraExpress evaluation.
3. Invoke the HydraExpress code generator by passing it the WSDL file
i. Using a command prompt setup as described above, invoke rwsfgen passing it the name of the
project to be created and the WSDL file name:
WHITE PAPER PAGE 5Figure1
Alternatively you can save the project settings in an xml project file, and pass this as the sole argument to
rwsfgen. A sample project file is provided with the HelloWorld tutorial.
Figure2
WHITE PAPER PAGE 64. Implement the service and client
a) Implement the service
Open the file HelloWorldExample\app\server\GreetingPortTypeImp.cpp.
Edit the sayHello method so that it returns “Hello” + the string passed from the client.
std::string
GreetingPortTypeImp::sayHello(rwsf::CallInfo& callInfo, const std::string& hellorequest_in)
{
return std::string(“Hello “ + hellorequest_in);
}
b) Implement the client
Open the file HelloWorldExample\app\client\GreetingPortClient.cpp.
Edit the invoke_sayHello method so that it calls the proxy’s sayHello method with a fixed input string of
“World !”
void invoke_sayHello(GreetingBindingProxy& proxy)
{
std::string hellorequest_in(“World!”);
std::string return_ret;
rwsf::CallInfo callInfo;
try {
return_ret = proxy.sayHello(callInfo, hellorequest_in);
std::cout7. Run the service and the client
a) Start the HydraExpress agent using rwsfserver start
Figure3
A new command window appears showing the helloworld service has been loaded and is running (Loading
context: /helloworld/)
Figure 4
WHITE PAPER PAGE 8b) Start the client GreetingPortClient from the HelloWorldExample\bin directory. The server responds.
Figure 5
More Advanced Examples
This paper provides a very simple example involving creating a C++ Web service, a WSDL file that defines the
Web Service, and a SOAP-based client.
The evaluation version of HydraExpress available for download (http://www.roguewave.com/download-
center/) contains a wide range of tutorials that cover advanced functionality such as asynchronous Web services,
WSDL defined fault handling, one-way and notification message patterns, message handlers for processing
SOAP messages, the use of SOAP headers, MIME attachments, and XML binding for complex types.
Advanced C++ Web Services Features
The example shown in this whitepaper is intentionally basic in terms of functionality in order to easily
demonstrate the underlying concepts without adding unnecessary complexity. HydraExpress has many features
that allow developers to create enterprise ready Web Services. Some of these advanced features are summarized
below:
Support for message patterns. HydraExpress supports the four basic message patterns defined in the WSDL
specification: request-response, the pattern most often used by Web services, one-way, notification, and solicit-
response. The message patterns can be combined to create anything from applications based on well-defined
models such as publish/subscribe to arbitrarily complex, choreographed SOA applications.
WHITE PAPER PAGE 9Asynchronous messages. Any message pattern can be used either synchronously or asynchronously. This
choice can be made at runtime by selecting either the synchronous or asynchronous service operation method.
Support for sessions and other state-dependent processes. HydraExpress has built-in support for session
management. In addition, the generalized support for metadata in headers can be adapted to support sessions,
transactions, and other processes that depend on state.
Support for XML binding. The HydraExpress code generator automatically compiles XML Schemas into C++
datatypes, whether the schema is embedded in the WSDL file, or the WSDL references an outside schema.
Support for SOAP attachments. HydraExpress creates code to support MIME bindings that are defined in
WSDL.
Support for WSDL-defined faults. HydraExpress generates classes that encapsulate fault messages defined in
the WSDL, and server code for capturing and returning fault messages to the client.
An HTTPS transport. Accessible from the command line or built into the client, this transport provides for a
secure client that uses HTTPS.
Generated documentation. The code generator creates full, detailed documentation for all generated datatypes.
Evolution: From Web Services to SOA
Building C++ Web Services is the first and most fundamental step toward moving C++ applications toward
a SOA. The next and larger challenge is to deliver SOA applications that are technologically agnostic and
language independent. To forward this effort, the OASIS Open CSA finalized the first full version of the SCA
specification in C++ and Java in 2007, with the support of dozens of application development tool vendors
including Rogue Wave Software, IBM, BEA Systems, Sun Microsystems Inc., SAP, and Oracle.
The key elements of the SCA specification offer the possibility of creating composite SOA applications using
reusable SOA components in any technology:
» Decoupling of application logic from the details of its invoked service calls
» Multiple language support, including C++ and Java, as well as related programming standards such as
BPEL, XLST
» Support for One-Way, Asynchronous, Call-Return, and Notification communications
» Binding services via SOAP-based Web Services, EJB, JMS, JCA, RMI, and more
» Data defined via Service Data Objects (SDO). The SDO API is available in both C++ and Java
WHITE PAPER PAGE 10For more information, visit http://www.oasis-opencsa.org/committees.
Summary
This paper details the benefits of C++ Web Services development and takes the reader step by step through a
simple example. It also highlights the challenges faced when developing Web Services in C++ generally and
illustrates how developers can save considerable development time and effort, while producing code that is
robust and easily maintainable. Lastly, some advanced C++ Web Services features are discussed.
WHITE PAPER PAGE 11
USA 1-800-487-3217 FRANCE +33 (0)1 30 09 78 78 GERMANY +49 (0)6103 59340 UK +44 (0)118 9360710
www.roguewave.com
Copyright © 2008, Rogue Wave Software, Inc. All Rights Reserved. Rogue Wave is a registered trademark of Rogue Wave Software, Inc. All other
trademarks are the property of their respective owners.You can also read
