<?xml version="1.0" encoding="utf-8"?>
<!--Arbortext, Inc., 1988-2005, v.4002-->
<!DOCTYPE concept PUBLIC "-//OASIS//DTD DITA Concept//EN"
 "concept.dtd">
<concept id="cwsdl" xml:lang="en-us">
<title>Web Services Description Language (WSDL)</title>
<shortdesc>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.</shortdesc>
<prolog><metadata>
<keywords><indexterm>WSDL<indexterm>overview</indexterm></indexterm><indexterm>Web
services<indexterm>WSDL</indexterm></indexterm></keywords>
</metadata></prolog>
<conbody>
<p>WSDL defines an XML format for describing network services as a set of
 <varname>endpoints</varname> 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 <tm tmclass="special"
tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="Java">Java</tm> beans
and enterprise beans as a Web service and generate a WSDL document that describes
the service. They can also generate <tm tmclass="special" tmowner="Sun Microsystems, Inc."
tmtype="tm" trademark="Java">Java</tm> and enterprise bean skeletons from
an existing WSDL file. A business service client can generate a <tm tmclass="special"
tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="Java">Java</tm> proxy
from a WSDL document, thereby providing an easy-to-use <tm tmclass="special"
tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="Java">Java</tm> interface
to the Web service. The <tm tmclass="special" tmowner="Sun Microsystems, Inc."
tmtype="tm" trademark="Java">Java</tm> 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  <xref format="html" href="http://www.w3.org/TR/wsdl" scope="external">www.w3.org/TR/wsdl</xref></p>
</conbody>
<related-links>
<linklist><title>Related Concepts</title>
<link href="cws.dita"><linktext>Web services overview</linktext></link>
<link href="cwsinwsa.dita"><linktext>Tools for Web services development</linktext>
</link>
</linklist>
<linklist><title>Related Tasks</title>
<link href="../tasks/toverws.dita" scope="peer"><linktext> Developing Web
services</linktext></link>
</linklist>
</related-links>
</concept>
