Web Services Exposed

For a long time, there's been a lot of noise about web services and service
oriented architecture. These have been two buzzwords that just about every large
software vendor is talking about and promoting. Unfortunately, the number of
successful deployments of either of these is fairly limited in the country. This
is possibly because most people are still not very clear about the concepts
behind web services and service oriented architecture. Even if they understand
the technology, they face a roadblock on implementing it. That's why, this time,
we decided to let you experience the best of both worlds. We've broken this
story into two parts. The first part explains what web services and service
oriented architecture are all about, in simple terms, and with examples. The
second part takes you through the actual steps to follow for publishing a web
service using a variety of tools. This is also more in tune with the spirit of
web services. They're supposed to help an organization combine the business
logic with technology to truly leverage IT for better business. We'll also give
you both business and technology perspectives to web services, so that you can
leverage them better.

Having said that, let's now try to understand what web services are really
all about. For this, it's important to understand how the IT setups have evolved
in every organization. The IT setup in an organization isn't built over night.
It takes many years of hard work. Unfortunately, as it's come up over many
years, it has many heterogeneous systems and applications. As long as these
systems and applications work independently, they're fine, but the world is not
so simple. There are many times when it's critical that different systems talk
to each other. To take an example, a bank has many different applications for
its various functions, like loans, deposits, credit cards, ATM, etc. Now suppose
that the bank needed to find out the credit rating of a customer before offering
him/her a loan. The bank would obviously avoid giving a loan to a customer with
poor credit rating. In this case, the loan application needs to pull out credit
rating data from the credit card application. As both applications support their
own proprietary methods of handling data, getting them to talk to each other
becomes a very difficult task. The field of Enterprise Application Integration,
or EAI deals with such challenges. It allows different applications built on
completely different applications to talk to each other. For a long time, this
job was done by technologies like CORBA, DCOM, etc. Anybody who's worked with
these technologies will tell you how difficult it is to use them. That's where
web services come into the picture.

Understanding web services

A web service would allow both the loan and credit card application to talk
to each other, irrespective of which platform they're running on. It would do it
using a set of open standards. Today, the most widely accepted web services
standards are from W3C. So basically, what happens is that the credit card
application exposes its customer credit rating data as a web service. As this is
based on open standards, anybody a developer can use it to integrate it with the
loan application. Not only that, but other applications can also use this web
service. So essentially, the organization has just developed reusable code. This
saves a lot time, money, and effort.

Let's take another example. Suppose there's a manufacturing firm that's
running an ERP package. This ERP package maintains the inventory levels of the
organization, among other things. What if the organization wanted a way to
inform its suppliers about shortage of raw materials the moment it happens? One
way would be to allow the suppliers to access the ERP system directly to pull
out this information. This however, would be a major security risk as you would
also be exposing company confidential information to them. The other is to
figure out which supply chain management package is each supplier running and
then try to integrate them with your ERP. This would prove to be a mammoth task,
especially if different suppliers are running different SCM software. The best
way out is to expose your inventory level data as a web service. This standard
information can then be -picked up by all your suppliers and integrated with
their SCM applications. This example can be taken in another way. Suppose that
your organization's top management wanted to find out critical information from
the ERP system no matter where they are.

The biggest benefit of doing this is that you've just saved yourself the cost
of recreating software every time you need to do application integration. For
organizations who are already overwhelmed with hundreds of applications, this
can be a real life saver. Once a web service has been created, it can be used by
any other application.

Understanding SOA

A services oriented architecture is an application that's been built by
taking data from multiple web services. It's a complete shift from the
traditional way of developing applications and therefore requires a different
level of thinking. In fact, if you look around, you'll find examples of SOA all
around you. If you have a DVD player, then it will accept any DVD movie you want
to watch. That's because the formats and standards for both the DVD and player
have been defined. It's not as if you need a different player for every DVD you
buy. Unfortunately, in the traditional software applications, tight binding
takes place making them inflexible. In the SOA world however, there's loose
coupling between different applications. It doesn't matter which platform,
software or hardware is the application running on. As long as it's able to
expose a web service, it can be integrated with other applications.

The challenge now is to find out what kind of web services do you really need
to expose? Let's go back to our ERP example. Suppose you wanted your management
to know about significant variations in any of the data provided by the ERP
system. For instance, the moment there's a drop in production, you want your
production floor manager to know. The moment there's a huge drop in sales target
achievement, your sales director needs to know. The moment there's a major
shortfall in collections, you'd like your commercial director to know. Further
still, you want them to find out about this no matter where they are and on the
device they're using. If it's a cellphone, then they should know via SMS. If
they're using a smartphone or PDA, then they should be informed by email. If the
managers receive this kind of critical data on time, then it can really prove to
be beneficial for the business. All this can happen if the ERP system can expose
this data as standard web services. This data can then be fed to a unified
communications platform to deliver the right information to the right person at
the right time. Such kinds of solutions have started emerging. Avaya for
instance, has tied up with SAP to offer this kind of functionality. Similarly,
there are many other successful examples that are available online of SOA and
web services. An airline exposing its reservation system as web services for
travel agents for instance. Likewise, a bank exposing its key customer names and
telephone numbers to a call center, whom its outsourced some work to. The call
center can then integrate this web service with its own CRM application easily.
Likewise, there can be hundreds of examples where SOA can prove beneficial. It
ends where your imagination does.

The critical requirement for SOA and web services to be successful is that
organizations must be in a position to expose certain parts of their
applications as web services for others to use. For that, they must invest in
certain technologies. Unless this investment shows concrete returns, it will not
happen. In the pages to follow, we've given some examples of how to publish web
services on various platforms, which include WebSphere, ASP.Net, and Java.

Anil Chopra, Rahul Sah, Sanjay Majumder, Vinod Unny

Web Services on ASP.NET

Web services have become an integral part of the development world these
days. Thanks to the platform agnostic nature as well as standardized document
format (XML) and transport mechanism (HTTP), it has become a staple requirement
for the SOA model. In this article we shall examine how you can publish data
used in enterprises as a Web service using ASP.NET and then consume it from any
other application that understands Web services as well.

So let's define what we're going to do in this. In our fictitious
organization we wish to have a set of Web services that will provide a list of
current employees to any application requesting it as well as doing other jobs
with this. Assume we have tables (A and B) stored in an enterprise level
database.

Let's first create a Web service that lists out the details of the employees.
For this, fire up Visual Studio 2005 and select File>New Website>ASP.NET Web
Application>Visual C#. Choose a location for creating the site. Once the site is
created, delete the Default.aspx file and right click the solution name and
select 'Add new item...'. In the dialog box select Web service and give it the
name 'EmployeeService'. ASP.NET will by default give all Web services an
extension of 'asmx.' Once the template is created, add the following two lines
of code at the top.

using System.Data;

using System.Data.SqlClient;

Now, add a new function to the service as follows:

public DataSet GetEmployeeList()

{

SqlConnection cn = new SqlConnection(" String>");

String SQL = "select * from tblEmployees";

SqlDataAdapter da = new SqlDataAdapter(SQL, cn);

DataSet ds = new DataSet();

da.Fill(ds);

return (ds);

}

Replace the with the connection string to your database. This
simple method returns a list of all the employees in the table using a Web
service. You can even test it out by running the code and viewing the XML
results in a browser. Let's also add another function to this Web service that
calculates the final salary of an employee given a set of inputs-the ID of the
employee as well as the salary total so far.

public String GetFinalSalary(Int16 EmployeeID,
Single SalaryTotal)

{

SqlConnection cn = new SqlConnection(" String>");

String SQL = String.Format("select
{0}*(1+BonusPercent/100) from tblSalaryBonus, tblEmployees where

tblSalaryBonus.EmployeeLevel=tblEmployees.EmployeeLevel
and EmployeeID={1}", SalaryTotal, EmployeeID);

SqlCommand cmd = new SqlCommand(SQL, cn);

cn.Open();

String sal =
Convert.ToString(cmd.ExecuteScalar());

return sal;

}

You can again test this out by running the Web service and viewing the
results in the browser as XML. This time you will also need to enter the
employee ID and the total salary.

Publishing Web Services on IBM WebSphere

IBM WebSphere is an application server that can publish Java applications as
a Web service. Not every Java application is ported to a Web application
directly; only those which are developed with WS-l compliance can be deployed as
a Web service. This compliance is followed by developer to make the applications
interpretable such that they can be deployed as a Web service in any application
server. Here we will take a look on how you can port Java applications as a Web
service on IBM WebSphere 6.1, and will also show how you can use hosted Web
service in your standalone applications. For this we used a sample application
'WS-1 complaint' which takes string as an input and gets the data from the
address book. We used an HTTP bound Web service, which uses wsdl file. Client
avails the hosted Web service using this file.

While hosting a Java application on WebSphere you need to select the modules you want to expose as a Web service. Java app could have multiple modules

Publish Web service on WebSphere 6.1

Deploying Web service on IBM WebSphere is very easy and straightforward; all
you need is a Java Web service application packaged in a file '.ear', in our
case the application name was Webservice.ear. To deploy this, open WebSphere
administrative console and select Application>Install new application, on the
right windowpane it will start a wizard that deploys the application as a Web
service. On the first screen of the wizard you will be asked to upload the
application that you want to deploy. Here give the path of the application that
you want to host (.ear file) and click Next. On the subsequent screen tick
'deploy Web service' and next. You will see a summary of all the options that
you have selected while going through the wizard. Finally select Finish and this
starts the process of deployment. The status of deployment is visible on your
browser screen. Once the process is complete, the application is
ready to be published as a Web service. But the application will be listed as
'inactive.' To activate it select the application and click 'start.' Next you
need to configure the HTTP endpoint so that a client can avail the Web service
on HTTP. For this select Applications>Enterprise Application from left pane of
the administrative console and on the right windowpane you will be shown a list
of hosted applications. Select the application that you have hosted as a Web
service and a configuration sheet of selected applications will open. Now under
Web Services Properties select 'Provide HTTP endpoint URL information' and on
the configuration sheet select 'default HTTP URL prefix.' Mark the modules that
you want to enable into your hosted Web service, click OK and then the 'save'
hyperlink to save the final settings. Now click 'Publish WSDL file.' If you find
a file with .zip extension it means your Web service has been deployed
successfully. Finally check whether the client can access the hosted Web service
or not. For this open a Web browser and point it toward your hosted Web service.
For example http://localhost: 9080/
AddressBookW2JE/services/AddressBook will give you an output as mentioned below:

{http://addr.webservices.samples.websphere.ibm.com}AddressBook

Hi there, this is a Web service!

Using Web service in application

While using the services from the hosted Web service you have to give HTTP
source of the Web service that you want to use. At present all development IDEs
offer Web service features in their development platform. We used Visual Studio
2005 to create a small application and used a Web service to query information
from Address Book service. For this create new project and select Visual Basic
Windows Application. To use external Web service in your project go to project
menu and select 'Add Web reference,' this will open a window where you need to
add the URL of hosted Web service. In our case the URL for the Web service
hosted on WebSphere application was http://localhost: 9080/AddressBookW2JE/
services/AddressBook? wsdl. Once connected, it will show the name of the hosted
service and the method name, which was 'getAddressFromName (name As string) As
Address.' You can even use this method to get the address book information such
as city, phone, state no., state name and zip code. On the form-1 we used a data
grid and connected it with the Web reference as its data source. Then we used a
text box to get the input data and also used a button to do the query. On the
click method of the button we attached a code (the one given on forums.pcquest.com) to fetch Address Book data from the hosted Web service. On
running the project, fill the string into the textbox and click button. The code
attached will call the method 'getAddressFromName' from the Web service and get
data from Web service and display fetch data on the data grid. In the same way,
you can write a code in Java, C#, C++, etc and use external methods offered by
hosted Web services. There are a few free Web services available which offer
features like weather forecast, horoscope, stock info, etc as Web service so
that developers can use the offerings in application development.

Web Services on Apache Tomcat

Today corporate world is moving toward integrating existing systems in a
standard way to make different implementations interoperable. Web service is one
such method through which integration can be achieved. A Web service is a unit
of managed code that can be remotely invoked using HTTP, i.e., it can be
activated using HTTP requests. So, Web services allow you to expose the
functionality of your existing code over the network. Once it is exposed on the
network, other applications can use the functionality of your program.

In the following article we will demonstrate how to create and test a Web
service on Apache Tomcat server. We will be using Eclipse as the standard IDE to
create the Web service.

Suppose you want to have a Web service that can be used to help convert
temperature in Celsius to Fahrenheit and vice versa. For this demonstration,
we'll use a simple application providing the service. We will be creating a Web
project targeting Tomcat 5.5 server. To do this first create a Dynamic Web
Project named 'WebTest' in Eclipse through File >New>Other. In the subsequent
screen select Dynamic Web Project under section 'Web.' On the New Dynamic Web
Project screen, name the project as 'WebTest,' choose the Target Runtime as
Tomcat and then click Finish. We will now add a class having methods for
temperature conversions. The 'celsius ToFahrenheit' method will convert the
passed data to equivalent Fahrenheit figure while 'fahrenheitToCelsius' method
will do vice versa. To create the Java class select your project in Project
Explorer window and right click on Java Resources and select New> Class. On the
new class form mention the package as pcq.test and class name as 'Convert'. Then
save the project. Our Convert.java class will be as follows:

In Client Type select Java Proxy and drag pointer to Test Client. Under configuration check for Server typess

package pcq.test;

public class Convert {

public float celsiusToFahrenheit (float
celsius)

{

return (celsius * 9 / 5)+32;

}

public float fahrenheitToCelsius (float
fahrenheit)

{

return (fahrenheit - 32)*5 /9;

}

}

Through Eclipse's Web service's explorer we can test the client Web service. The TCP/IP monitor shows various request and responses and their SOAP formats

Web Service Creation

For the 'WebTest' project we will have to create a Web service, which can be
done in Eclipse through File>New>Other and then selecting Web service. On the
Web service form pass the pcq.test.Convert in Service Implementation box. Under
Client Type option, bring the pointer to Test client. Here you will observe that
the default client project has been named as WebTestClient. Also select the
option 'Monitor the Web service.' Continue the wizard by clicking Next and then
Finish. The Web service wizard takes some time for organizing the end-to-end
generation, assembly, deployment, installation and execution of the Web service,
Web service client and sample JSPs. After completing this, the WSDL for the
WebTest Web service can be found under WebContent folder of the WebTest Web
service project. Now when you browse through your web projects, 'WebTest' and 'WebTestClient',
you can see that some JSP files and some Java files have been created in client
Web service. There are classes created under WebTestClient that have following
functions:

On completion of Web service wizard, WSDL file, java and jsp files get created on client web project

• ServiceLocater class: The locator class has information about
  the Web service, most importantly the address by which the service can be
  invoked (the HTTP address). The locator class is populated based on the
  content of the Web service's WSDL file.
• Service class: The service endpoints' interface that is a
  local representation of a Web service. Through this interface appropriate
  methods will be invoked.
• SoapBindingStub class: The stub that implements remote invocation
  methods defined by ConvertService interface.

To test the Web service give the following URL in your browser:



http://localhost:8080/WebTestClient/sampleConvertProxy/TestClient.jsp

This will open the JSP page that shows the two methods we had created for
conversion of temperature units. Select 'celsiusToFahrenheit' method and test
for value 0. Upon invoking the method on the Results frame you will have 32 as
the output. Similarly, test for the other methods also. This shows that the Web
service is up and running.

Alternatively, as Monitor Web service option was selected while configuring
Web service wizard a TCP/IP monitor appears, which is a powerful facility
showing the data that are actually being exchanged between the Web service and
its client, thus simplifying problem analysis with the Web services
implementation. The right-top pane on the monitor includes a list of
interactions (requests/responses) placed in a chronological order. When a
developer clicks on a particular interaction, the system displays the time of
request, how long it took for the system to respond (in milliseconds), and the
type of protocol that was used (in our case HTTP). The right-bottom pane
displays the SOAP response envelope. Whenever we invoke a particular Web
service, this pane is populated with the response of the server in the SOAP
(XML-based) format.

Finally a Web service on Tomcat is created and tested for a client
application.

Web Service on JBoss

JBoss is an open-source Java EE-based application server which supports EJB
3.0. This functionality has made development and deployment of Web services on
JBoss possible. In the following article we will show you how to develop and
deploy a Web service on a JBoss application server.

We would be using NetBeans IDE 5.5 which has support for JBoss. Also you
would be required to add the JBoss Application Server and provide JDK5 as the
Java platform for the IDE. Add JBoss Application Server by right clicking on the
'Servers' node in 'Runtime' window of the NetBeans IDE.

Creating Web service and its client

We would be creating a simple Web service which will be based on JAX-WS
specifications. Since NetBeans does not have support for JAX-WS based Web
services for JBoss, we will be creating them on Tomcat that comes bundled with
NetBeans. But before actually deploying the Web service, we would change the
runtime server to JBoss.

For creating a new Web service in NetBeans, select Web Application option
from the 'Project' pane and name the project as 'PcqMainWebApp'. Uncheck the
checkbox 'Use JDK 1.4' and also select the bundled Tomcat as the server. To
create a Web service right click on the 'PcqMainWebApp' project node and then
select New>Web Service. Name the service as 'PcqMainWS' and define package as 'pcq.labs.'
To visualize the Web service expand the project 'PcqMainWebApp' node and the Web
service can be seen under the project node. Now we will switch to JBoss runtime,
for this right click on 'PcqMainWebApp' project and select Properties option. In
the following window select 'Run' and change the server option to JBoss in the
Server drop-down list. Don't forget to uncheck the JAX-WS option under
'Libraries' tab because NetBeans IDE does not support for JBoss' JAX-WS API. In
order to add some code to the Web service, right click on 'PcqMainWS' and select
'Add Operation' option from the menu that pops up. Name the method as 'sayHello,'
then click on 'Add' button, and in the following screen define the parameter as
'name' and click 'OK.' So, now we have created a method 'sayHello' for the
service body. In the code change the return value as defined below:

public String operation(@WebParam(name =
"name") String name) {

return "Hello Reader - "+ name;

}

As per the JSR-181 specifications we need to specify the endpoints, so that
our service could be accessed from any external service. Hence, select 'web.xml'
from 'Configuration Files' node and open it in the 'Editor' window. Here define
the tag value as 'pcq.labs.PcqMainWS' and delete the tag. Now we are ready to deploy the project, right click on 'PcqMainWebApp' and
select 'Deploy Project' option. To view the WSDL code generated after deployment
of the service, right click on the 'PcqMainWS' and select Properties. Properties
will display the URL of the WSDL file which when opened in a browser would
display the WSDL code.

Next create another Web application project and name it as 'PcqClientApp.'
Then select 'PcqMainWebApp' through File>New File option, select 'Web Service
Client' option under the 'Web Services' category. In the following screen
specify the location of Web service's WSDL file by clicking on 'Browse' button.
Select 'PcqMainWS' and define the package name as 'pcq.labs.' Click 'Finish' and
now you can see the client under 'Web Service References' node in the Projects
window.

EJB modules for Web service

With NetBeans IDE we cannot deploy JAX-WS Web service on JBoss, but as JBoss
supports EJB 3.0 we will be creating EJB modules corresponding to the Web
services we just created.

While creating the project do make sure that option 'Use JKD 1.4' is unchecked and bundled Tomcat is selected as server

For this create a new project named 'PcqMainEjb' through File>New Project and
select 'EJB Module' option under Enterprise category. Add a new Web service to
this project and name it as 'PcqEjbWS'. Now add a method to the service as we
did before and it has to be same as the 'sayHello' method. Deploy the project
'PcqMainEjb' and the WSDL code of the deployed service can be viewed through the
following URL:

http://localhost:8080/PcqMainEjb/PcqEjbWS?wsdl

Next we would create client EJB module. Start a new EJB module project and
name it as 'PcqClientEjb,' right click on this project in 'Project' window and
select New>Web Service Client option. Click on the 'Next' button and with it a
'New Web Service Client' screen pops up. For specifying WSDL paths, click
'Browse' button for 'Project' option and then define 'PcqEjbWS' as the path. For
WSDL URL paste the above URL path and click 'Finish.

Testing Web service

After creating the Web services and their corresponding EJB modules, let us
test if our implementation is successful.

Select the 'PcqClientApp' under the Projects window and expand it to find
index.jsp file. Open the file in Editor and select the commented area in the
page's body starting from <%-- This example......

Now right click on the selected portion and select 'Web Service Client
Resourses' option and then opt for 'Call Web Service Operation'. In 'Select
Operation to Invoke' screen select 'PcqMain WebApp' and expand it to find
'sayHello' operation and click 'OK.' The code will be generated on the page's
body. Find string 'java. lang.String name= “” '. Now place a test name within
the quotes.

Finally and most importantly change the project's server to JBoss from
bundled Tomcat-selected earlier from project's 'Properties' window. Now select
the main Web application, i.e. 'PcqMainWebApp,' right click on the project's
name and select 'Run Project' option. Upon successful execution the resulting
test page will be displayed on the browser.