<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html lang="en-us" xml:lang="en-us">
<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<meta name="copyright" content="Copyright (c) 2000, 2008 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
<meta name="DC.rights.owner" content="(C) Copyright 2000, 2008" />
<meta content="public" name="security" />
<meta content="index,follow" name="Robots" />
<meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
<meta content="concept" name="DC.Type" />
<meta name="DC.Title" content="Web services overview" />
<meta name="abstract" content="A Web service is a set of related application functions that can be programmatically invoked over the Internet. Businesses can dynamically mix and match Web services to perform complex transactions with minimal programming. Web services allow buyers and sellers all over the world to discover each other, connect dynamically, and execute transactions in real time with minimal human interaction." />
<meta name="description" content="A Web service is a set of related application functions that can be programmatically invoked over the Internet. Businesses can dynamically mix and match Web services to perform complex transactions with minimal programming. Web services allow buyers and sellers all over the world to discover each other, connect dynamically, and execute transactions in real time with minimal human interaction." />
<meta content="Web services, overview" name="DC.subject" />
<meta content="Web services, overview" name="keywords" />
<meta scheme="URI" name="DC.Relation" content="../concepts/cwsstandards.html" />
<meta scheme="URI" name="DC.Relation" content="../concepts/cwstopdown.html" />
<meta scheme="URI" name="DC.Relation" content="../concepts/cwsbtmup.html" />
<meta scheme="URI" name="DC.Relation" content="cwsinwsa.html" />
<meta scheme="URI" name="DC.Relation" content="cwsstandards.html" />
<meta scheme="URI" name="DC.Relation" content="../tasks/toverws.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="cws" name="DC.Identifier" />
<meta content="en-us" name="DC.Language" />
<link href="../../org.eclipse.wst.doc.user/common.css" type="text/css" rel="stylesheet" />
<title>Web services overview</title>
</head>
<body id="cws"><a name="cws"><!-- --></a>


<h1 class="topictitle1">Web services overview</h1>



<div><p>A Web service is a set of related application functions that can
be programmatically invoked over the Internet. Businesses can dynamically
mix and match Web services to perform complex transactions with minimal programming.
Web services allow buyers and sellers all over the world to discover each
other, connect dynamically, and execute transactions in real time with minimal
human interaction.</p>

<p>Web services are self-contained, self-describing modular applications that
can be published, located, and invoked across the Web.</p>

<blockquote> <p> <span class="uicontrol">Web services are self-contained.</span> On the client
side, no additional software is required.  A programming language with
XML and HTTP client support is enough to get you started.  On the server
side, a Web server and servlet engine are required.  The client and server
can be implemented in different environments.  It is possible to Web
service enable an existing application without writing a single line of code.</p>
 <p> <span class="uicontrol">Web
services are self-describing.</span> The client and server need to recognize
only the format and content of request and response messages.  The definition
of the message format travels with the message; no external metadata repositories
or code generation tools are required.</p>
 <p> <span class="uicontrol">Web services are
modular.</span> Simple Web services can be aggregated to form more complex
Web services either by using workflow techniques or by calling lower layer
Web services from a Web service implementation.</p>
<p><span class="uicontrol">Web Services
are platform independent.</span> Web services are based on a concise
set of open, XML-based standards designed to promote interoperability between
a Web service and clients across a variety of computing platforms and programming
languages.</p>
 </blockquote>

<p>Web services might be anything, for example, theatre review articles, weather
reports, credit checks, stock quotations, travel advisories, or airline travel
reservation processes. Each of these self-contained business services is an
application that can easily integrate with other services, from the same or
different companies, to create a complete business process. This interoperability
allows businesses to dynamically publish, discover, and bind a range of Web
services through the Internet.</p>

<div class="section"><h4 class="sectiontitle">Categories of Web services</h4><p>Web services can be grouped
into three categories:</p>
<blockquote> <p> <span class="uicontrol">Business information.</span> A
business shares information with consumers or other businesses. In this case,
the business is using Web services to expand its scope. Examples of business
informational Web services are news streams, weather reports, or stock quotations.</p>
 <p> <span class="uicontrol">Business
integration.</span> A business provides transactional, "for fee" services
to its customers. In this case, the business becomes part of a global network
of value-added suppliers that can be used to conduct commerce. Examples of
business integration Web services include bid and auction e-marketplaces,
reservation systems, and credit checking.</p>
 <p> <span class="uicontrol">Business process
externalization.</span> A business differentiates itself from its competition
through the creation of a global value chain. In this case, the business uses
Web services to dynamically integrate its processes. An example of business
process externalization Web services is the associations between different
companies to combine manufacturing, assembly, wholesale distribution, and
retail sales of a particular product.</p>
 </blockquote>
</div>

<div class="section"><h4 class="sectiontitle">Service roles and interactions</h4><p>A network component
in a Web Services architecture can play one or more fundamental roles: service
provider, service broker, and service client.</p>
<ul>
<li>Service providers create and deploy their Web services and can publish
the availability of their WSDL-described services through a service registry,
such as a UDDI Business Registry.</li>

<li>Service brokers register and categorize published services and provide
search services. For example, UDDI acts as a service broker for WSDL-described
Web services.</li>

<li>Service clients use broker services such as the UDDI Business Registry
to discover a needed WSDL-described service and then bind to and call the
service provider.</li>

</ul>
<p>Binding involves establishing all environmental prerequisites that
are necessary to successfully complete the services. Examples of environmental
prerequisites include security, transaction monitoring, and HTTP availability.
The relationships between these roles are described in Figure 1.</p>
<p>Figure
1. Service roles and interactions.</p>
<p> <img src="../images/roles.gif" alt="Figure 1 illustrates the interactions between the service broker, service provider, and service requestor." /> </p>
<p>For more information on Web services,
refer to  <a href="http://www.ibm.com/developerworks/webservices" target="_blank">www.ibm.com/developerworks/webservices</a></p>
</div>

</div>

<div>
<ul class="ullinks">
<li class="ulchildlink"><strong><a href="../concepts/cwsstandards.html">Web services standards</a></strong><br />
One of the key attributes of Internet standards is that they focus on protocols and not on implementations. The Internet is composed of heterogeneous technologies that successfully interoperate through shared protocols. This prevents individual vendors from imposing a standard on the Internet. Open Source software development plays a crucial role in preserving the interoperability of vendor implementations of standards.</li>
<li class="ulchildlink"><strong><a href="../concepts/cwstopdown.html">Creating top-down Web services</a></strong><br />
Web services can be created using two methods: top-down development and bottom-up development. Top-down Web services development involves creating a Web service from a WSDL file.</li>
<li class="ulchildlink"><strong><a href="../concepts/cwsbtmup.html">Creating bottom-up Web services</a></strong><br />
Web services can be created using two methods: top-down development and bottom-up development. Bottom-up Web services development involves creating a Web service from a Java bean or enterprise bean.</li>
</ul>

<div class="linklist"><strong>Related Concepts</strong><br />

<div><a href="cwsinwsa.html" title="">Tools for Web services development</a></div>
<div><a href="cwsstandards.html" title="One of the key attributes of Internet standards is that they focus on protocols and not on implementations. The Internet is composed of heterogeneous technologies that successfully interoperate through shared protocols. This prevents individual vendors from imposing a standard on the Internet. Open Source software development plays a crucial role in preserving the interoperability of vendor implementations of standards.">Web services standards</a></div></div>

<div class="linklist"><strong>Related Tasks</strong><br />

<div><a href="../tasks/toverws.html" title="Use Web services tools to discover, create, and publish Web services that are created from Java beans, enterprise beans, and WSDL files. You can create of Web services using a top-down approach (which starts with a WSDL file) or a bottom-up approach (which starts with a Java bean or EJB)."> Developing Web
services</a></div></div>
</div>

</body>
</html>