<?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="(C) Copyright 2005" />
<meta name="DC.rights.owner" content="(C) Copyright 2005" />
<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 Description Language (WSDL)" />
<meta name="abstract" content="Web Services Description Language (WSDL) is a standard specification for describing networked, XML-based services. It provides a simple way for service providers to describe the basic format of requests to their systems regardless of the underlying run-time implementation." />
<meta name="description" content="Web Services Description Language (WSDL) is a standard specification for describing networked, XML-based services. It provides a simple way for service providers to describe the basic format of requests to their systems regardless of the underlying run-time implementation." />
<meta scheme="URI" name="DC.Relation" content="../concepts/cwsstandards.html" />
<meta scheme="URI" name="DC.Relation" content="../ref/rwsdl.html" />
<meta scheme="URI" name="DC.Relation" content="cws.html" />
<meta scheme="URI" name="DC.Relation" content="cwsinwsa.html" />
<meta scheme="URI" name="DC.Relation" content="../tasks/toverws.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="cwsdl" name="DC.Identifier" />
<meta content="en-us" name="DC.Language" />
<link href="../../org.eclipse.wst.doc.user/commonltr.css" type="text/css" rel="stylesheet" />
<title>Web Services Description Language (WSDL)</title>
</head>
<body id="cwsdl"><a name="cwsdl"><!-- --></a>


<h1 class="topictitle1">Web Services Description Language (WSDL)</h1>


<div><p>Web Services Description Language (WSDL) is a standard specification
for describing networked, XML-based services. It provides a simple way for
service providers to describe the basic format of requests to their systems
regardless of the underlying run-time implementation.</p>

<p>WSDL defines an XML format for describing network services as a set of
 <var class="varname">endpoints</var> that operate on messages that contain either
document-oriented or procedure-oriented information. The operations and messages
are first described abstractly and then bound to a concrete network protocol
and message format in order to define an endpoint. Related concrete endpoints
are combined into abstract endpoints (services). WSDL is extensible to allow
description of endpoints and their messages, regardless of which message formats
or network protocols are used to communicate. This means that interfaces are
defined abstractly using XML schema and then bound to concrete representations
that are appropriate for the protocol.</p>

<p>WSDL allows a service provider to specify the following characteristics
of a Web service:</p>

<ul>
<li>The name of the Web service and addressing information</li>

<li>The protocol and encoding style to be used when accessing the public operations
of the Web service</li>

<li>The type information such as operations, parameters, and data types comprising
the interface of the Web service</li>

</ul>

<p>WSDL documents allow developers to expose their applications as network-accessible
services on the Internet. Through UDDI and WSIL, other applications can discover
WSDL documents and bind with them to execute transactions or perform other
business processes.</p>

<p>This development platform supports and encourages the development and use
of WS-I compliant WSDL. Business service providers can deploy Java™ beans
and enterprise beans as a Web service and generate a WSDL document that describes
the service. They can also generate Java and enterprise bean skeletons from
an existing WSDL file. A business service client can generate a Java proxy
from a WSDL document, thereby providing an easy-to-use Java interface
to the Web service. The Java interface hides the network communications
details from the client enabling the business service provider to focus on
business and process portions of the application.</p>

<p>In addition to providing tools to create Web services, the workbench provides
a WSDL editor that allows you to create WSDL files using a graphical interface,
a WSDL validator that ensures that your WSDL file is semantically correct
and optionally checks for WS-I compliance, and the Web Services Explorer which
allows you to dynamically test Web services without requiring you to generate
a proxy.</p>

<p>The workbench supports WSDL 1.1. For more information on the WSDL specification,
refer to  <a href="http://www.w3.org/TR/wsdl" target="_blank">www.w3.org/TR/wsdl</a></p>

</div>

<div>
<ul class="ullinks">
<li class="ulchildlink"><strong><a href="../ref/rwsdl.html">Web Services Description Language (WSDL) reference</a></strong><br />
A WSDL document defines services as collections of network endpoints, or ports. In WSDL, the abstract definition of endpoints and messages is separated from their concrete network deployment or data format bindings. This allows the reuse of abstract definitions: messages, which are abstract descriptions of the data being exchanged, and port types which are abstract collections of operations.</li>
</ul>

<div class="familylinks">
<div class="parentlink"><strong>Parent topic:</strong> <a href="../concepts/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 Concepts</strong><br />

<div><a href="cws.html" title="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.">Web services overview</a></div>
<div><a href="cwsinwsa.html" title="">Tools for Web services development</a></div></div>

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

<div><a href="../tasks/toverws.html"> Developing Web
services</a></div></div>
</div>

</body>
</html>